v31.4.0 (#135)

Author: truemagic-coder

README.md

@@ -86,6 +86,7 @@ Smart workflows are as easy as combining your tools and prompts.
 
 * [Python](https://python.org) - Programming Language
 * [OpenAI](https://openai.com) - AI Model Provider
+* [Grok](https://x.ai) - Alternative AI Model Provider (optional)
 * [MongoDB](https://mongodb.com) - Conversational History (optional)
 * [Zep Cloud](https://getzep.com) - Conversational Memory (optional)
 * [Pinecone](https://pinecone.io) - Knowledge Base (optional)
@@ -536,6 +537,40 @@ uvx solana-agent --user-id my_cli_session --config ./my_agent_config.json
 
 ## Optional Feature Configs
 
+### Grok
+
+Solana Agent supports using Grok from xAI as an alternative to OpenAI. When Grok is configured, it will be used for all LLM operations except embeddings, TTS, and STT (which still require OpenAI).
+
+**Note:** Grok configuration takes priority over OpenAI. If both are present, Grok will be used.
+
+```python
+config = {
+    "grok": {
+        "api_key": "your-grok-api-key",
+        "base_url": "https://api.x.ai/v1",  # Optional, defaults to https://api.x.ai/v1
+        "model": "grok-4-1-fast-non-reasoning"  # Optional, defaults to grok-4-1-fast-non-reasoning
+    },
+    # You can still include OpenAI for embeddings, TTS, and STT
+    "openai": {
+        "api_key": "your-openai-api-key"
+    },
+    "agents": [
+        {
+            "name": "research_specialist",
+            "instructions": "You are an expert researcher.",
+            "specialization": "Research",
+        }
+    ],
+}
+```
+
+**Verified Capabilities:**
+- ✅ Chat completions
+- ✅ Streaming responses
+- ✅ Function calling/Tool usage
+- ✅ Structured outputs (via Instructor TOOLS_STRICT and JSON modes)
+- ✅ Native JSON mode
+
 ### Business Alignment
 
 ```python

config.json

@@ -2,6 +2,9 @@
     "openai": {
         "api_key": "your-openai-api-key"
     },
+    "grok": {
+        "api_key": "your-grok-api-key"
+    },
     "agents": [
         {
             "name": "default_agent",

poetry.lock

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "solana-agent"
-version = "31.3.0"
+version = "31.4.0"
 description = "AI Agents for Solana"
 authors = ["Bevan Hunt <[email protected]>"]
 license = "MIT"
@@ -24,34 +24,34 @@ testpaths = ["tests"]
 
 [tool.poetry.dependencies]
 python = ">=3.12,<4.0"
-openai = "1.107.2"
+openai = "2.8.1"
 pydantic = ">=2"
-pymongo = "4.15.0"
-zep-cloud = "3.4.3"
-instructor = "1.11.3"
-pinecone = { version = "7.3.0", extras = ["asyncio"] }
-llama-index-core = "0.14.1"
+pymongo = "4.15.4"
+zep-cloud = "3.13.0"
+instructor = "1.13.0"
+pinecone = { version = "8.0.0", extras = ["asyncio"] }
+llama-index-core = "0.14.8"
 llama-index-embeddings-openai = "0.5.1"
-pypdf = "6.0.0"
+pypdf = "6.4.0"
 scrubadub = "2.0.1"
-logfire = "4.7.0"
-typer = "0.17.4"
+logfire = "4.15.1"
+typer = "0.20.0"
 rich = ">=13,<14.0"
-pillow = "11.3.0"
+pillow = "12.0.0"
 websockets = ">=13,<16"
 
 [tool.poetry.group.dev.dependencies]
-pytest = "^8.4.2"
+pytest = "^9.0.1"
 pytest-cov = "^7.0.0"
-pytest-asyncio = "^1.2.0"
-pytest-mock = "^3.15.0"
+pytest-asyncio = "^1.3.0"
+pytest-mock = "^3.15.1"
 pytest-github-actions-annotate-failures = "^0.3.0"
 sphinx = "^8.2.3"
 sphinx-rtd-theme = "^3.0.2"
 myst-parser = "^4.0.1"
 sphinx-autobuild = "^2025.08.25"
 mongomock = "^4.3.0"
-ruff = "^0.13.0"
+ruff = "^0.14.6"
 
 [tool.poetry.scripts]
 solana-agent = "solana_agent.cli:app"

pyproject.toml

@@ -55,23 +55,49 @@
 class OpenAIAdapter(LLMProvider):
     """OpenAI implementation of LLMProvider with web search capabilities."""
 
-    def __init__(self, api_key: str, logfire_api_key: Optional[str] = None):
+    def __init__(
+        self,
+        api_key: str,
+        base_url: Optional[str] = None,
+        model: Optional[str] = None,
+        logfire_api_key: Optional[str] = None,
+    ):
         self.api_key = api_key
-        self.client = AsyncOpenAI(api_key=api_key)
+        self.base_url = base_url
+
+        # Create client with base_url if provided (for Grok support)
+        if base_url:
+            self.client = AsyncOpenAI(api_key=api_key, base_url=base_url)
+        else:
+            self.client = AsyncOpenAI(api_key=api_key)
 
         self.logfire = False
         if logfire_api_key:
             try:
                 logfire.configure(token=logfire_api_key)
                 self.logfire = True
-                logger.info("Logfire configured successfully.")
+                # Instrument the main client immediately after configuring logfire
+                logfire.instrument_openai(self.client)
+                logger.info(
+                    "Logfire configured and OpenAI client instrumented successfully."
+                )
             except Exception as e:
                 logger.error(f"Failed to configure Logfire: {e}")
                 self.logfire = False
 
-        self.parse_model = DEFAULT_PARSE_MODEL
-        self.text_model = DEFAULT_CHAT_MODEL
-        self.vision_model = DEFAULT_VISION_MODEL  # Add vision model attribute
+        # Use provided model or defaults (for Grok or OpenAI)
+        if model:
+            # Custom model provided (e.g., from Grok config)
+            self.parse_model = model
+            self.text_model = model
+            self.vision_model = model
+        else:
+            # Use OpenAI defaults
+            self.parse_model = DEFAULT_PARSE_MODEL
+            self.text_model = DEFAULT_CHAT_MODEL
+            self.vision_model = DEFAULT_VISION_MODEL
+
+        # These remain OpenAI-specific
         self.transcription_model = DEFAULT_TRANSCRIPTION_MODEL
         self.tts_model = DEFAULT_TTS_MODEL
         self.embedding_model = DEFAULT_EMBEDDING_MODEL
@@ -409,6 +435,8 @@ async def chat_stream(
         messages: List[Dict[str, Any]],
         model: Optional[str] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
     ) -> AsyncGenerator[Dict[str, Any], None]:  # pragma: no cover
         """Stream chat completions with optional tool calls, yielding normalized events."""
         try:
@@ -420,7 +448,12 @@ async def chat_stream(
             if tools:
                 request_params["tools"] = tools
 
-            client = self.client
+            # Use custom client if api_key and base_url provided, otherwise use default
+            if api_key and base_url:
+                client = AsyncOpenAI(api_key=api_key, base_url=base_url)
+            else:
+                client = self.client
+
             if self.logfire:
                 logfire.instrument_openai(client)
 

solana_agent/adapters/openai_adapter.py

@@ -104,20 +104,39 @@ def create_from_config(config: Dict[str, Any]) -> QueryService:  # pragma: no co
         else:
             db_adapter = None
 
+        # Determine which LLM provider to use (Grok or OpenAI)
+        # Priority: grok > openai
+        llm_api_key = None
+        llm_base_url = None
+        llm_model = None
+
+        if "grok" in config and "api_key" in config["grok"]:
+            llm_api_key = config["grok"]["api_key"]
+            llm_base_url = config["grok"].get("base_url", "https://api.x.ai/v1")
+            llm_model = config["grok"].get("model", "grok-4-1-fast-non-reasoning")
+            logger.info(f"Using Grok as LLM provider with model: {llm_model}")
+        elif "openai" in config and "api_key" in config["openai"]:
+            llm_api_key = config["openai"]["api_key"]
+            llm_base_url = None  # Use default OpenAI endpoint
+            llm_model = None  # Will use OpenAI adapter defaults
+            logger.info("Using OpenAI as LLM provider")
+        else:
+            raise ValueError("Either OpenAI or Grok API key is required in config.")
+
         if "logfire" in config:
             if "api_key" not in config["logfire"]:
                 raise ValueError("Pydantic Logfire API key is required.")
-            if "openai" not in config or "api_key" not in config["openai"]:
-                raise ValueError("OpenAI API key is required.")
             llm_adapter = OpenAIAdapter(
-                api_key=config["openai"]["api_key"],
+                api_key=llm_api_key,
+                base_url=llm_base_url,
+                model=llm_model,
                 logfire_api_key=config["logfire"].get("api_key"),
             )
         else:
-            if "openai" not in config or "api_key" not in config["openai"]:
-                raise ValueError("OpenAI API key is required.")
             llm_adapter = OpenAIAdapter(
-                api_key=config["openai"].get("api_key"),
+                api_key=llm_api_key,
+                base_url=llm_base_url,
+                model=llm_model,
             )
 
         # Create business mission if specified in config
@@ -172,19 +191,27 @@ def create_from_config(config: Dict[str, Any]) -> QueryService:  # pragma: no co
             llm_provider=llm_adapter,
             business_mission=business_mission,
             config=config,
+            api_key=llm_api_key,
+            base_url=llm_base_url,
+            model=llm_model,
             output_guardrails=output_guardrails,
         )
 
         # Create routing service
-        # Optional routing model override (use small, cheap model by default in service)
-        routing_model = (
-            config.get("openai", {}).get("routing_model")
-            if isinstance(config.get("openai"), dict)
-            else None
-        )
+        # Use Grok model if configured, otherwise check for OpenAI routing_model override
+        routing_model = llm_model  # Use the same model as the main LLM by default
+        if not routing_model:
+            # Fall back to OpenAI routing_model config if no Grok model
+            routing_model = (
+                config.get("openai", {}).get("routing_model")
+                if isinstance(config.get("openai"), dict)
+                else None
+            )
         routing_service = RoutingService(
             llm_provider=llm_adapter,
             agent_service=agent_service,
+            api_key=llm_api_key,
+            base_url=llm_base_url,
             model=routing_model,
         )
 

solana_agent/factories/agent_factory.py

@@ -39,6 +39,8 @@ async def chat_stream(
         messages: List[Dict[str, Any]],
         model: Optional[str] = None,
         tools: Optional[List[Dict[str, Any]]] = None,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
     ) -> AsyncGenerator[Dict[str, Any], None]:
         """Stream chat completion deltas and tool call deltas.
 

solana_agent/interfaces/providers/llm.py

@@ -360,6 +360,8 @@ async def generate_response(
                     messages=messages,
                     model=self.model,
                     tools=tools if tools else None,
+                    api_key=self.api_key,
+                    base_url=self.base_url,
                 ):
                     etype = event.get("type")
                     if etype == "content":

solana_agent/services/agent.py

@@ -1277,44 +1277,49 @@ async def _drain_out_tr_text():
             agents = self.agent_service.get_all_ai_agents() or {}
             available_agent_names = list(agents.keys())
 
-            # LLM detects switch intent
-            (
-                switch_requested,
-                requested_agent_raw,
-                start_new,
-            ) = await self._detect_switch_intent(user_text, available_agent_names)
-
-            # Normalize requested agent to an exact available key
-            requested_agent = None
-            if requested_agent_raw:
-                raw_lower = requested_agent_raw.lower()
-                for a in available_agent_names:
-                    if a.lower() == raw_lower or raw_lower in a.lower():
-                        requested_agent = a
-                        break
+            # Fast path: if only one agent, skip all routing logic entirely
+            if len(available_agent_names) == 1:
+                agent_name = available_agent_names[0]
+                self._set_sticky_agent(user_id, agent_name, required_complete=False)
+            else:
+                # LLM detects switch intent (only needed with multiple agents)
+                (
+                    switch_requested,
+                    requested_agent_raw,
+                    start_new,
+                ) = await self._detect_switch_intent(user_text, available_agent_names)
+
+                # Normalize requested agent to an exact available key
+                requested_agent = None
+                if requested_agent_raw:
+                    raw_lower = requested_agent_raw.lower()
+                    for a in available_agent_names:
+                        if a.lower() == raw_lower or raw_lower in a.lower():
+                            requested_agent = a
+                            break
 
-            sticky_agent = self._get_sticky_agent(user_id)
+                sticky_agent = self._get_sticky_agent(user_id)
 
-            if sticky_agent and not switch_requested:
-                agent_name = sticky_agent
-            else:
-                try:
-                    if start_new:
-                        # Start fresh
-                        self._clear_sticky_agent(user_id)
-                    if requested_agent:
-                        agent_name = requested_agent
-                    else:
-                        # Route if no explicit target
-                        if router:
-                            agent_name = await router.route_query(routing_input)
+                if sticky_agent and not switch_requested:
+                    agent_name = sticky_agent
+                else:
+                    try:
+                        if start_new:
+                            # Start fresh
+                            self._clear_sticky_agent(user_id)
+                        if requested_agent:
+                            agent_name = requested_agent
                         else:
-                            agent_name = await self.routing_service.route_query(
-                                routing_input
-                            )
-                except Exception:
-                    agent_name = next(iter(agents.keys())) if agents else "default"
-                self._set_sticky_agent(user_id, agent_name, required_complete=False)
+                            # Route if no explicit target
+                            if router:
+                                agent_name = await router.route_query(routing_input)
+                            else:
+                                agent_name = await self.routing_service.route_query(
+                                    routing_input
+                                )
+                    except Exception:
+                        agent_name = next(iter(agents.keys())) if agents else "default"
+                    self._set_sticky_agent(user_id, agent_name, required_complete=False)
 
             # 7) Captured data context + incremental save using previous assistant message
             capture_context = ""