Add Venice provider and refactor LLM clients

Add support for the Venice (OpenAI-compatible) provider and refactor how LLM clients/agents are built. Updates include: README and Settings.yaml entries for Venice; new Provider::Venice and venice config in Settings; generic build functions build_anthropic_client and build_openai_client with helpers for base URLs; new Inner/ReviewAgent enums to abstract Anthropic vs OpenAI-style agents; split out build_tools and a generic build_inner<C: CompletionClient> so agents can be constructed for either client type; update GemmyAgent and ChatwootReviewReplyTool to select the appropriate client/agent based on settings. This enables using PROVIDER=venice with VENICE_KEY and keeps existing anthropic/deepseek behavior.

Author: gemcoder21

core/apps/agent/README.md

@@ -32,4 +32,5 @@ cargo run -p agent --bin repl -- security
 
 Config is layered (later overrides earlier): `Settings.yaml` → `agents/<name>/agent.yaml` →
 environment variables (`_`-separated, e.g. `SLACK_BOT_TOKEN` → `slack.bot.token`). The agent to
-run is selected by `AGENT_NAME` (or `argv[1]`).
+run is selected by `AGENT_NAME` (or `argv[1]`). Supported LLM providers are `anthropic`,
+`deepseek`, and `venice`; set `PROVIDER=venice` with `VENICE_KEY` to use Venice.

core/apps/agent/Settings.yaml

@@ -13,13 +13,16 @@ slack:
   bot:
     token: ""        # SLACK_BOT_TOKEN
 
-provider: anthropic   # PROVIDER — anthropic | deepseek
+provider: anthropic   # PROVIDER — anthropic | deepseek | venice
 
 anthropic:
   key: ""             # ANTHROPIC_KEY
 deepseek:
   key: ""             # DEEPSEEK_KEY
   base: "https://api.deepseek.com/anthropic"
+venice:
+  key: ""             # VENICE_KEY
+  base: "https://api.venice.ai/api/v1"
 
 embedding:
   model: "nomic-embed-text-v1.5-q"

core/apps/agent/src/agent.rs

@@ -8,11 +8,11 @@ use rig::agent::{Agent as RigAgent, PromptResponse};
 use rig::client::CompletionClient;
 use rig::completion::Prompt;
 use rig::completion::message::{Message, UserContent};
-use rig::providers::anthropic;
+use rig::providers::{anthropic, openai};
 use rig::tool::ToolDyn;
 
 use crate::chatwoot::ChatwootClient;
-use crate::config::Settings;
+use crate::config::{Provider, ProviderConfig, Settings};
 use crate::images::ImageAttachment;
 use crate::preamble;
 use crate::slack::SlackClient;
@@ -22,14 +22,67 @@ use crate::tools::{
     ShellTool, SlackHistoryTool, SlackPostTool, TelegramPostTool, ToolName,
 };
 
-type Inner = RigAgent<anthropic::completion::CompletionModel>;
+const VENICE_BASE_URL: &str = "https://api.venice.ai/api/v1";
 
-pub(crate) fn build_client(provider: &crate::config::ProviderConfig) -> Result<anthropic::Client> {
-    let mut builder = anthropic::Client::builder().api_key(&provider.key);
-    if !provider.base.is_empty() {
-        builder = builder.base_url(&provider.base);
+type AnthropicInner = RigAgent<anthropic::completion::CompletionModel>;
+type OpenAiInner = RigAgent<openai::completion::CompletionModel>;
+
+enum Inner {
+    Anthropic(AnthropicInner),
+    OpenAi(OpenAiInner),
+}
+
+impl Inner {
+    async fn prompt_response(&self, msg: &str) -> Result<PromptResponse> {
+        match self {
+            Inner::Anthropic(inner) => Ok(inner.prompt(msg).extended_details().await?),
+            Inner::OpenAi(inner) => Ok(inner.prompt(msg).extended_details().await?),
+        }
+    }
+
+    async fn prompt_message(&self, msg: Message) -> Result<String> {
+        match self {
+            Inner::Anthropic(inner) => Ok(inner.prompt(msg).await?),
+            Inner::OpenAi(inner) => Ok(inner.prompt(msg).await?),
+        }
+    }
+}
+
+pub(crate) fn build_anthropic_client(provider: Provider, config: &ProviderConfig) -> Result<anthropic::Client> {
+    let name = provider_name(provider);
+    let mut builder = anthropic::Client::builder().api_key(&config.key);
+    if !config.base.is_empty() {
+        builder = builder.base_url(&config.base);
+    }
+    builder.build().map_err(|e| format!("building {name} client: {e}").into())
+}
+
+pub(crate) fn build_openai_client(provider: Provider, config: &ProviderConfig) -> Result<openai::CompletionsClient> {
+    let name = provider_name(provider);
+    let base_url = openai_base_url(provider, config);
+    let mut builder = openai::CompletionsClient::builder().api_key(&config.key);
+    if let Some(base_url) = base_url {
+        builder = builder.base_url(base_url);
+    }
+    builder.build().map_err(|e| format!("building {name} client: {e}").into())
+}
+
+fn openai_base_url(provider: Provider, config: &ProviderConfig) -> Option<&str> {
+    if !config.base.is_empty() {
+        return Some(&config.base);
+    }
+    match provider {
+        Provider::Venice => Some(VENICE_BASE_URL),
+        Provider::Anthropic | Provider::Deepseek => None,
+    }
+}
+
+fn provider_name(provider: Provider) -> &'static str {
+    match provider {
+        Provider::Anthropic => "anthropic",
+        Provider::Deepseek => "deepseek",
+        Provider::Venice => "venice",
     }
-    builder.build().map_err(|e| format!("building Anthropic client: {e}").into())
 }
 
 pub struct GemmyAgent {
@@ -45,14 +98,22 @@ impl GemmyAgent {
         slack: Arc<SlackClient>,
         mcp_tools: Vec<Box<dyn ToolDyn>>,
     ) -> Result<Self> {
-        let provider = settings.llm_provider();
-        if provider.key.is_empty() {
+        let config = settings.llm_provider();
+        if config.key.is_empty() {
             return Err(format!("no key for the active provider {:?} — set its key in vault/.env", settings.provider).into());
         }
         let preamble = preamble::render(settings)?;
-        let client = build_client(provider)?;
-
-        let inner = build_inner(&client, settings, &preamble, memory, chatwoot, slack, mcp_tools);
+        let tools = build_tools(settings, memory, chatwoot, slack, mcp_tools);
+        let inner = match settings.provider {
+            Provider::Anthropic | Provider::Deepseek => {
+                let client = build_anthropic_client(settings.provider, config)?;
+                Inner::Anthropic(build_inner(&client, settings, &preamble, tools))
+            }
+            Provider::Venice => {
+                let client = build_openai_client(settings.provider, config)?;
+                Inner::OpenAi(build_inner(&client, settings, &preamble, tools))
+            }
+        };
 
         info!(
             agent = %settings.agent_name,
@@ -77,7 +138,7 @@ impl GemmyAgent {
             images = 0,
             "agent.prompt"
         );
-        Ok(self.inner.prompt(msg).extended_details().await?)
+        self.inner.prompt_response(msg).await
     }
 
     pub async fn prompt_with_images(&self, msg: &str, images: Vec<ImageAttachment>) -> Result<String> {
@@ -96,20 +157,17 @@ impl GemmyAgent {
             blocks.push(UserContent::image_base64(engine.encode(&img.bytes), Some(img.media_type), None));
         }
         let content = OneOrMany::many(blocks).expect("text block always present");
-        Ok(self.inner.prompt(Message::User { content }).await?)
+        self.inner.prompt_message(Message::User { content }).await
     }
 }
 
-fn build_inner(
-    client: &anthropic::Client,
+fn build_tools(
     settings: &Settings,
-    preamble: &str,
     memory: Option<Arc<MemoryStore>>,
     chatwoot: Option<Arc<ChatwootClient>>,
     slack: Arc<SlackClient>,
     mcp_tools: Vec<Box<dyn ToolDyn>>,
-) -> Inner {
-    let model_id = &settings.agent.model;
+) -> Vec<Box<dyn ToolDyn>> {
     let mut tools: Vec<Box<dyn ToolDyn>> = mcp_tools;
     for entry in &settings.agent.tools {
         let policy = entry.policy();
@@ -159,6 +217,14 @@ fn build_inner(
             tools.push(Box::new(GatedTool { inner, policy }));
         }
     }
+    tools
+}
+
+fn build_inner<C>(client: &C, settings: &Settings, preamble: &str, tools: Vec<Box<dyn ToolDyn>>) -> RigAgent<C::CompletionModel>
+where
+    C: CompletionClient,
+{
+    let model_id = &settings.agent.model;
     let tool_names: Vec<String> = tools.iter().map(|t| t.name()).collect();
     info!(model = %model_id, tools = ?tool_names, "built agent");
     client

core/apps/agent/src/config.rs

@@ -224,6 +224,7 @@ pub enum Provider {
     #[default]
     Anthropic,
     Deepseek,
+    Venice,
 }
 
 #[derive(Debug, Deserialize, Clone, Default)]
@@ -269,6 +270,8 @@ pub struct Settings {
     pub anthropic: ProviderConfig,
     #[serde(default)]
     pub deepseek: ProviderConfig,
+    #[serde(default)]
+    pub venice: ProviderConfig,
     pub embedding: EmbeddingConfig,
     pub agent: AgentProfile,
     #[serde(default)]
@@ -288,6 +291,7 @@ impl Settings {
         match self.provider {
             Provider::Anthropic => &self.anthropic,
             Provider::Deepseek => &self.deepseek,
+            Provider::Venice => &self.venice,
         }
     }
 

core/apps/agent/src/tools/chatwoot_review_reply.rs

@@ -5,17 +5,32 @@ use gem_tracing::tracing::{debug, warn};
 use rig::agent::Agent as RigAgent;
 use rig::client::CompletionClient;
 use rig::completion::{Prompt, ToolDefinition};
-use rig::providers::anthropic;
+use rig::providers::{anthropic, openai};
 use rig::tool::Tool;
 use serde::{Deserialize, Serialize};
 use serde_json::json;
 
-use crate::config::Settings;
+use crate::config::{Provider, Settings};
 use crate::tools::ToolFailure;
 
 #[derive(Clone)]
 pub struct ChatwootReviewReplyTool {
-    inner: Arc<RigAgent<anthropic::completion::CompletionModel>>,
+    inner: ReviewAgent,
+}
+
+#[derive(Clone)]
+enum ReviewAgent {
+    Anthropic(Arc<RigAgent<anthropic::completion::CompletionModel>>),
+    OpenAi(Arc<RigAgent<openai::completion::CompletionModel>>),
+}
+
+impl ReviewAgent {
+    async fn prompt(&self, prompt: &str) -> Result<String, rig::completion::PromptError> {
+        match self {
+            ReviewAgent::Anthropic(inner) => inner.prompt(prompt).await,
+            ReviewAgent::OpenAi(inner) => inner.prompt(prompt).await,
+        }
+    }
 }
 
 #[derive(Debug, Deserialize)]
@@ -39,17 +54,32 @@ impl ChatwootReviewReplyTool {
             return Ok(None);
         }
         let preamble = fs::read_to_string(&preamble_path)?;
-        let provider = settings.llm_provider();
-        if provider.key.is_empty() {
+        let config = settings.llm_provider();
+        if config.key.is_empty() {
             return Ok(None);
         }
-        let client = crate::agent::build_client(provider)?;
         let model = &settings.agent.model;
-        let inner = client.agent(model).preamble(&preamble).max_tokens(2048).temperature(0.2).build();
-        Ok(Some(Self { inner: Arc::new(inner) }))
+        let inner = match settings.provider {
+            Provider::Anthropic | Provider::Deepseek => {
+                let client = crate::agent::build_anthropic_client(settings.provider, config)?;
+                ReviewAgent::Anthropic(Arc::new(build_inner(&client, model, &preamble)))
+            }
+            Provider::Venice => {
+                let client = crate::agent::build_openai_client(settings.provider, config)?;
+                ReviewAgent::OpenAi(Arc::new(build_inner(&client, model, &preamble)))
+            }
+        };
+        Ok(Some(Self { inner }))
     }
 }
 
+fn build_inner<C>(client: &C, model: &str, preamble: &str) -> RigAgent<C::CompletionModel>
+where
+    C: CompletionClient,
+{
+    client.agent(model).preamble(preamble).max_tokens(2048).temperature(0.2).build()
+}
+
 impl Tool for ChatwootReviewReplyTool {
     const NAME: &'static str = "chatwoot_review_reply";
     type Error = ToolFailure;