solana-agent 31.1.5__tar.gz → 31.1.6__tar.gz

{solana_agent-31.1.5 → solana_agent-31.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: solana-agent
-Version: 31.1.5
+Version: 31.1.6
 Summary: AI Agents for Solana
 License: MIT
 Keywords: solana,solana ai,solana agent,ai,ai agent,ai agents
@@ -15,10 +15,10 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Dist: instructor (==1.11.2)
-Requires-Dist: llama-index-core (==0.13.3)
+Requires-Dist: llama-index-core (==0.13.5)
 Requires-Dist: llama-index-embeddings-openai (==0.5.0)
 Requires-Dist: logfire (==4.3.6)
-Requires-Dist: openai (==1.102.0)
+Requires-Dist: openai (==1.106.1)
 Requires-Dist: pillow (==11.3.0)
 Requires-Dist: pinecone[asyncio] (==7.3.0)
 Requires-Dist: pydantic (>=2)
@@ -52,7 +52,7 @@ Build your AI agents in three lines of code!
 ## Why?
 * Three lines of code setup
 * Simple Agent Definition
-* Fast Responses
+* Fast & Streaming Responses
 * Solana Integration
 * Multi-Agent Swarm
 * Multi-Modal (Images & Audio & Text)

{solana_agent-31.1.5 → solana_agent-31.1.6}/README.md

@@ -17,7 +17,7 @@ Build your AI agents in three lines of code!
 ## Why?
 * Three lines of code setup
 * Simple Agent Definition
-* Fast Responses
+* Fast & Streaming Responses
 * Solana Integration
 * Multi-Agent Swarm
 * Multi-Modal (Images & Audio & Text)

{solana_agent-31.1.5 → solana_agent-31.1.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "solana-agent"
-version = "31.1.5"
+version = "31.1.6"
 description = "AI Agents for Solana"
 authors = ["Bevan Hunt <bevan@bevanhunt.com>"]
 license = "MIT"
@@ -24,13 +24,13 @@ testpaths = ["tests"]
 
 [tool.poetry.dependencies]
 python = ">=3.12,<4.0"
-openai = "1.102.0"
+openai = "1.106.1"
 pydantic = ">=2"
 pymongo = "4.14.1"
 zep-cloud = "3.4.3"
 instructor = "1.11.2"
 pinecone = { version = "7.3.0", extras = ["asyncio"] }
-llama-index-core = "0.13.3"
+llama-index-core = "0.13.5"
 llama-index-embeddings-openai = "0.5.0"
 pypdf = "6.0.0"
 scrubadub = "2.0.1"
@@ -40,17 +40,17 @@ rich = ">=13,<14.0"
 pillow = "11.3.0"
 
 [tool.poetry.group.dev.dependencies]
-pytest = "^8.4.0"
+pytest = "^8.4.2"
 pytest-cov = "^6.1.1"
 pytest-asyncio = "^1.1.0"
-pytest-mock = "^3.14.0"
+pytest-mock = "^3.15.0"
 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 = "^2024.10.3"
+sphinx-autobuild = "^2025.08.25"
 mongomock = "^4.3.0"
-ruff = "^0.12.10"
+ruff = "^0.12.12"
 
 [tool.poetry.scripts]
 solana-agent = "solana_agent.cli:app"

{solana_agent-31.1.5 → solana_agent-31.1.6}/solana_agent/adapters/openai_adapter.py

@@ -399,6 +399,77 @@ class OpenAIAdapter(LLMProvider):
             logger.exception(f"Error in generate_text_with_images: {e}")
             return f"I apologize, but I encountered an unexpected error: {e}"
 
+    async def chat_stream(
+        self,
+        messages: List[Dict[str, Any]],
+        model: Optional[str] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> AsyncGenerator[Dict[str, Any], None]:  # pragma: no cover
+        """Stream chat completions with optional tool calls, yielding normalized events."""
+        try:
+            request_params: Dict[str, Any] = {
+                "messages": messages,
+                "model": model or self.text_model,
+                "stream": True,
+            }
+            if tools:
+                request_params["tools"] = tools
+
+            client = self.client
+            if self.logfire:
+                logfire.instrument_openai(client)
+
+            stream = await client.chat.completions.create(**request_params)
+            async for chunk in stream:
+                try:
+                    if not chunk or not getattr(chunk, "choices", None):
+                        continue
+                    ch = chunk.choices[0]
+                    delta = getattr(ch, "delta", None)
+                    if delta is None:
+                        # Some SDKs use 'message' instead of 'delta'
+                        delta = getattr(ch, "message", None)
+                    if delta is None:
+                        # Finish event
+                        finish = getattr(ch, "finish_reason", None)
+                        if finish:
+                            yield {"type": "message_end", "finish_reason": finish}
+                        continue
+
+                    # Content delta
+                    content_piece = getattr(delta, "content", None)
+                    if content_piece:
+                        yield {"type": "content", "delta": content_piece}
+
+                    # Tool call deltas
+                    tool_calls = getattr(delta, "tool_calls", None)
+                    if tool_calls:
+                        for idx, tc in enumerate(tool_calls):
+                            try:
+                                tc_id = getattr(tc, "id", None)
+                                func = getattr(tc, "function", None)
+                                name = getattr(func, "name", None) if func else None
+                                args_piece = (
+                                    getattr(func, "arguments", "") if func else ""
+                                )
+                                yield {
+                                    "type": "tool_call_delta",
+                                    "id": tc_id,
+                                    "index": getattr(tc, "index", idx),
+                                    "name": name,
+                                    "arguments_delta": args_piece or "",
+                                }
+                            except Exception:
+                                continue
+                except Exception as parse_err:
+                    logger.debug(f"Error parsing stream chunk: {parse_err}")
+                    continue
+            # End of stream (SDK may not emit finish event in all cases)
+            yield {"type": "message_end", "finish_reason": "end_of_stream"}
+        except Exception as e:
+            logger.exception(f"Error in chat_stream: {e}")
+            yield {"type": "error", "error": str(e)}
+
     async def parse_structured_output(
         self,
         prompt: str,

{solana_agent-31.1.5 → solana_agent-31.1.6}/solana_agent/interfaces/providers/llm.py

@@ -33,6 +33,23 @@ class LLMProvider(ABC):
         """Generate text from the language model."""
         pass
 
+    @abstractmethod
+    async def chat_stream(
+        self,
+        messages: List[Dict[str, Any]],
+        model: Optional[str] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> AsyncGenerator[Dict[str, Any], None]:
+        """Stream chat completion deltas and tool call deltas.
+
+            Yields normalized events:
+            - {"type": "content", "delta": str}
+        - {"type": "tool_call_delta", "id": Optional[str], "index": Optional[int], "name": Optional[str], "arguments_delta": str}
+            - {"type": "message_end", "finish_reason": str}
+            - {"type": "error", "error": str}
+        """
+        pass
+
     @abstractmethod
     async def parse_structured_output(
         self,

{solana_agent-31.1.5 → solana_agent-31.1.6}/solana_agent/services/agent.py

@@ -265,56 +265,57 @@ class AgentService(AgentServiceInterface):
         prompt: Optional[str] = None,
         output_model: Optional[Type[BaseModel]] = None,
     ) -> AsyncGenerator[Union[str, bytes, BaseModel], None]:  # pragma: no cover
-        """Generate a response using OpenAI function calling (tools API) or structured output."""
-
-        agent = next((a for a in self.agents if a.name == agent_name), None)
-        if not agent:
-            error_msg = f"Agent '{agent_name}' not found."
-            logger.warning(error_msg)
-            if output_format == "audio":
-                async for chunk in self.llm_provider.tts(
-                    error_msg,
-                    instructions=audio_instructions,
-                    response_format=audio_output_format,
-                    voice=audio_voice,
-                ):
-                    yield chunk
-            else:
-                yield error_msg
-            return
-
-        # Build system prompt and messages
-        system_prompt = self.get_agent_system_prompt(agent_name)
-        user_content = str(query)
-        if images:
-            user_content += "\n\n[Images attached]"
-
-        # Compose the prompt for generate_text
-        full_prompt = ""
-        if memory_context:
-            full_prompt += f"CONVERSATION HISTORY:\n{memory_context}\n\n Always use your tools to perform actions and don't rely on your memory!\n\n"
-        if prompt:
-            full_prompt += f"ADDITIONAL PROMPT:\n{prompt}\n\n"
-        full_prompt += user_content
-        full_prompt += f"USER IDENTIFIER: {user_id}"
-
-        # Get OpenAI function schemas for this agent's tools
-        tools = [
-            {
-                "type": "function",
-                "function": {
-                    "name": tool["name"],
-                    "description": tool.get("description", ""),
-                    "parameters": tool.get("parameters", {}),
-                    "strict": True,
-                },
-            }
-            for tool in self.get_agent_tools(agent_name)
-        ]
+        """Generate a response using tool-calling with full streaming support."""
 
         try:
+            # Validate agent
+            agent = next((a for a in self.agents if a.name == agent_name), None)
+            if not agent:
+                error_msg = f"Agent '{agent_name}' not found."
+                logger.warning(error_msg)
+                if output_format == "audio":
+                    async for chunk in self.llm_provider.tts(
+                        error_msg,
+                        instructions=audio_instructions,
+                        response_format=audio_output_format,
+                        voice=audio_voice,
+                    ):
+                        yield chunk
+                else:
+                    yield error_msg
+                return
+
+            # Build system prompt and messages
+            system_prompt = self.get_agent_system_prompt(agent_name)
+            user_content = str(query)
+            if images:
+                user_content += "\n\n[Images attached]"
+
+            # Compose the prompt for generate_text
+            full_prompt = ""
+            if memory_context:
+                full_prompt += f"CONVERSATION HISTORY:\n{memory_context}\n\n Always use your tools to perform actions and don't rely on your memory!\n\n"
+            if prompt:
+                full_prompt += f"ADDITIONAL PROMPT:\n{prompt}\n\n"
+            full_prompt += user_content
+            full_prompt += f"USER IDENTIFIER: {user_id}"
+
+            # Get OpenAI function schemas for this agent's tools
+            tools = [
+                {
+                    "type": "function",
+                    "function": {
+                        "name": tool["name"],
+                        "description": tool.get("description", ""),
+                        "parameters": tool.get("parameters", {}),
+                        "strict": True,
+                    },
+                }
+                for tool in self.get_agent_tools(agent_name)
+            ]
+
+            # Structured output path
             if output_model is not None:
-                # --- Structured output with tool support ---
                 model_instance = await self.llm_provider.parse_structured_output(
                     prompt=full_prompt,
                     system_prompt=system_prompt,
@@ -327,83 +328,131 @@ class AgentService(AgentServiceInterface):
                 yield model_instance
                 return
 
-            # --- Streaming text/audio with tool support (as before) ---
-            response_text = ""
-            while True:
-                if not images:
-                    response = await self.llm_provider.generate_text(
-                        prompt=full_prompt,
-                        system_prompt=system_prompt,
-                        api_key=self.api_key,
-                        base_url=self.base_url,
-                        model=self.model,
-                        tools=tools if tools else None,
-                    )
+            # Vision fallback (non-streaming for now)
+            if images:
+                vision_text = await self.llm_provider.generate_text_with_images(
+                    prompt=full_prompt, images=images, system_prompt=system_prompt
+                )
+                if output_format == "audio":
+                    cleaned_audio_buffer = self._clean_for_audio(vision_text)
+                    async for audio_chunk in self.llm_provider.tts(
+                        text=cleaned_audio_buffer,
+                        voice=audio_voice,
+                        response_format=audio_output_format,
+                        instructions=audio_instructions,
+                    ):
+                        yield audio_chunk
                 else:
-                    response = await self.llm_provider.generate_text_with_images(
-                        prompt=full_prompt,
-                        system_prompt=system_prompt,
-                        api_key=self.api_key,
-                        base_url=self.base_url,
-                        model=self.model,
-                        tools=tools if tools else None,
-                        images=images,
-                    )
-                if (
-                    not response
-                    or not hasattr(response, "choices")
-                    or not response.choices
+                    yield vision_text
+                return
+
+            # Build initial messages for chat streaming
+            messages: List[Dict[str, Any]] = []
+            if system_prompt:
+                messages.append({"role": "system", "content": system_prompt})
+            messages.append({"role": "user", "content": full_prompt})
+
+            accumulated_text = ""
+
+            # Loop to handle tool calls in streaming mode
+            while True:
+                # Aggregate tool calls by index and merge late IDs
+                tool_calls: Dict[int, Dict[str, Any]] = {}
+
+                async for event in self.llm_provider.chat_stream(
+                    messages=messages,
+                    model=self.model,
+                    tools=tools if tools else None,
                 ):
-                    logger.error("No response or choices from LLM provider.")
-                    response_text = "I apologize, but I could not generate a response."
-                    break
-
-                choice = response.choices[0]
-                message = getattr(choice, "message", choice)
-
-                if hasattr(message, "tool_calls") and message.tool_calls:
-                    for tool_call in message.tool_calls:
-                        if tool_call.type == "function":
-                            function_name = tool_call.function.name
-                            arguments = json.loads(tool_call.function.arguments)
-                            logger.info(
-                                f"Model requested tool '{function_name}' with args: {arguments}"
-                            )
-                            # Execute the tool (async)
-                            tool_result = await self.execute_tool(
-                                agent_name, function_name, arguments
-                            )
-                            # Add the tool result to the prompt for the next round
-                            full_prompt += (
-                                f"\n\nTool '{function_name}' was called with arguments {arguments}.\n"
-                                f"Result: {tool_result}\n"
+                    etype = event.get("type")
+                    if etype == "content":
+                        delta = event.get("delta", "")
+                        accumulated_text += delta
+                        if output_format == "text":
+                            yield delta
+                    elif etype == "tool_call_delta":
+                        tc_id = event.get("id")
+                        index_raw = event.get("index")
+                        try:
+                            index = int(index_raw) if index_raw is not None else 0
+                        except Exception:
+                            index = 0
+                        name = event.get("name")
+                        args_piece = event.get("arguments_delta", "")
+                        entry = tool_calls.setdefault(
+                            index, {"id": None, "name": None, "arguments": ""}
+                        )
+                        if tc_id and not entry.get("id"):
+                            entry["id"] = tc_id
+                        if name and not entry.get("name"):
+                            entry["name"] = name
+                        entry["arguments"] += args_piece
+                    elif etype == "message_end":
+                        _ = event.get("finish_reason")
+
+                # If tool calls were requested, execute them and continue the loop
+                if tool_calls:
+                    assistant_tool_calls: List[Dict[str, Any]] = []
+                    call_id_map: Dict[int, str] = {}
+                    for idx, tc in tool_calls.items():
+                        name = (tc.get("name") or "").strip()
+                        if not name:
+                            logger.warning(
+                                f"Skipping unnamed tool call at index {idx}; cannot send empty function name."
                             )
-                    continue
+                            continue
+                        norm_id = tc.get("id") or f"call_{idx}"
+                        call_id_map[idx] = norm_id
+                        assistant_tool_calls.append(
+                            {
+                                "id": norm_id,
+                                "type": "function",
+                                "function": {
+                                    "name": name,
+                                    "arguments": tc.get("arguments") or "{}",
+                                },
+                            }
+                        )
 
-                # Otherwise, it's a normal message (final answer)
-                response_text = message.content
-                break
+                    if assistant_tool_calls:
+                        messages.append(
+                            {
+                                "role": "assistant",
+                                "content": None,
+                                "tool_calls": assistant_tool_calls,
+                            }
+                        )
 
-            # Apply output guardrails if any
-            processed_final_text = response_text
-            if self.output_guardrails:
-                for guardrail in self.output_guardrails:
-                    try:
-                        processed_final_text = await guardrail.process(
-                            processed_final_text
+                    # Execute each tool and append the tool result messages
+                    for idx, tc in tool_calls.items():
+                        func_name = (tc.get("name") or "").strip()
+                        if not func_name:
+                            continue
+                        try:
+                            args = json.loads(tc.get("arguments") or "{}")
+                        except Exception:
+                            args = {}
+                        logger.info(
+                            f"Streaming: executing tool '{func_name}' with args: {args}"
                         )
-                    except Exception as e:
-                        logger.error(
-                            f"Error applying output guardrail {guardrail.__class__.__name__}: {e}"
+                        tool_result = await self.execute_tool(
+                            agent_name, func_name, args
+                        )
+                        messages.append(
+                            {
+                                "role": "tool",
+                                "tool_call_id": call_id_map.get(idx, f"call_{idx}"),
+                                "content": json.dumps(tool_result),
+                            }
                         )
 
-            self.last_text_response = processed_final_text
+                    accumulated_text = ""
+                    continue
 
-            if output_format == "text":
-                yield processed_final_text or ""
-            elif output_format == "audio":
-                cleaned_audio_buffer = self._clean_for_audio(processed_final_text)
-                if cleaned_audio_buffer:
+                # No tool calls: we've streamed the final answer
+                final_text = accumulated_text
+                if output_format == "audio":
+                    cleaned_audio_buffer = self._clean_for_audio(final_text)
                     async for audio_chunk in self.llm_provider.tts(
                         text=cleaned_audio_buffer,
                         voice=audio_voice,
@@ -412,7 +461,10 @@ class AgentService(AgentServiceInterface):
                     ):
                         yield audio_chunk
                 else:
-                    yield ""
+                    if not final_text:
+                        yield ""
+                self.last_text_response = final_text
+                break
         except Exception as e:
             import traceback