solana-agent 14.0.2__py3-none-any.whl → 15.0.0__py3-none-any.whl

solana_agent/adapters/llm_adapter.py

@@ -3,7 +3,8 @@ LLM provider adapters for the Solana Agent system.
 
 These adapters implement the LLMProvider interface for different LLM services.
 """
-from typing import AsyncGenerator, List, Type, TypeVar
+from pathlib import Path
+from typing import AsyncGenerator, BinaryIO, List, Literal, Type, TypeVar, Union
 
 from openai import OpenAI
 from pydantic import BaseModel
@@ -16,22 +17,98 @@ T = TypeVar('T', bound=BaseModel)
 class OpenAIAdapter(LLMProvider):
     """OpenAI implementation of LLMProvider with web search capabilities."""
 
-    def __init__(self, api_key: str, model: str = "gpt-4o-mini"):
+    def __init__(self, api_key: str):
         self.client = OpenAI(api_key=api_key)
-        self.model = model
-        # Add search-enabled model variants
-        self.search_models = {
-            "gpt-4o": "gpt-4o-search-preview",
-            "gpt-4o-mini": "gpt-4o-mini-search-preview"
-        }
+        self.parse_model = "gpt-4o-mini"
+        self.search_model = "gpt-4o-mini-search-preview"
+        self.transcription_model = "gpt-4o-mini-transcribe"
+        self.tts_model = "gpt-4o-mini-tts"
+
+    async def tts(
+        self,
+        text: str,
+        instructions: str = "",
+        voice: Literal["alloy", "ash", "ballad", "coral", "echo",
+                       "fable", "onyx", "nova", "sage", "shimmer"] = "nova",
+    ) -> AsyncGenerator[bytes, None]:  # pragma: no cover
+        """Stream text-to-speech audio from OpenAI models.
+
+        Args:
+            text: Text to convert to speech
+            instructions: Optional instructions for speech generation
+            voice: Voice to use for synthesis
+
+        Yields:
+            Audio bytes as they become available
+        """
+        try:
+            stream = self.client.audio.speech.create(
+                model=self.tts_model,
+                voice=voice,
+                input=text,
+                instructions=instructions,
+            )
+
+            # Stream the bytes in chunks
+            for chunk in stream.iter_bytes(chunk_size=1024 * 16):  # 16KB chunks
+                yield chunk
+
+        except Exception as e:
+            print(f"Error in text_to_speech: {str(e)}")
+            import traceback
+            print(traceback.format_exc())
+            yield b""  # Return empty bytes on error
+
+        except Exception as e:
+            print(f"Error in text_to_speech: {str(e)}")
+            import traceback
+            print(traceback.format_exc())
+            yield f"I apologize, but I encountered an error converting text to speech: {str(e)}"
+
+    async def transcribe_audio(
+        self,
+        audio_file: Union[str, Path, BinaryIO],
+    ) -> AsyncGenerator[str, None]:  # pragma: no cover
+        """Stream transcription of an audio file.
+
+        Args:
+            audio_file: Path to audio file or file-like object
+
+        Yields:
+            Transcript text chunks as they become available
+        """
+        try:
+            # Handle file path vs file object
+            if isinstance(audio_file, (str, Path)):
+                audio_file = open(audio_file, "rb")
+
+            stream = self.client.audio.transcriptions.create(
+                model=self.transcription_model,
+                file=audio_file,
+                response_format="text",
+                stream=True
+            )
+
+            for event in stream:
+                if hasattr(event, 'text') and event.text:
+                    yield event.text
+
+        except Exception as e:
+            print(f"Error in transcribe_audio: {str(e)}")
+            import traceback
+            print(traceback.format_exc())
+            yield f"I apologize, but I encountered an error transcribing the audio: {str(e)}"
+
+        finally:
+            # Close file if we opened it
+            if isinstance(audio_file, (str, Path)):
+                audio_file.close()
 
     async def generate_text(
         self,
         prompt: str,
         system_prompt: str = "",
-        needs_search: bool = False,
-        **kwargs,
-    ) -> AsyncGenerator[str, None]:
+    ) -> AsyncGenerator[str, None]:  # pragma: no cover
         """Generate text from OpenAI models with web search capability."""
         messages = []
 
@@ -43,38 +120,16 @@ class OpenAIAdapter(LLMProvider):
         # Prepare request parameters
         request_params = {
             "messages": messages,
-            "stream": kwargs.get("stream", True),
-            "response_format": kwargs.get("response_format", None),
+            "stream": True,
+            "model": self.search_model,
         }
-
-        # If search is needed, update model and add search options
-        if needs_search:
-            base_model = kwargs.get("model", self.model)
-            request_params["model"] = self.search_models.get(
-                base_model, "gpt-4o-mini-search-preview")
-            request_params["web_search_options"] = {
-                "search_context_size": "medium",
-                "user_location": {
-                    "type": "approximate",
-                    "approximate": {
-                        "country": "US",
-                        "timezone": "America/Los_Angeles"
-                    }
-                }
-            }
-        else:
-            request_params["model"] = kwargs.get("model", self.model)
-
         try:
             response = self.client.chat.completions.create(**request_params)
-            current_text = ""
 
             for chunk in response:
                 if chunk.choices:
-                    # Handle content
                     if chunk.choices[0].delta.content:
                         text = chunk.choices[0].delta.content
-                        current_text += text
                         yield text
 
         except Exception as e:
@@ -83,7 +138,7 @@ class OpenAIAdapter(LLMProvider):
             print(traceback.format_exc())
             yield f"I apologize, but I encountered an error: {str(e)}"
 
-    def generate_embedding(self, text: str) -> List[float]:
+    def generate_embedding(self, text: str) -> List[float]:  # pragma: no cover
         """Generate embeddings for a given text using OpenAI's embedding model."""
         try:
             response = self.client.embeddings.create(
@@ -101,8 +156,7 @@ class OpenAIAdapter(LLMProvider):
         prompt: str,
         system_prompt: str,
         model_class: Type[T],
-        **kwargs
-    ) -> T:
+    ) -> T:  # pragma: no cover
         """Generate structured output using Pydantic model parsing."""
         messages = []
         if system_prompt:
@@ -113,10 +167,9 @@ class OpenAIAdapter(LLMProvider):
         try:
             # First try the beta parsing API
             completion = self.client.beta.chat.completions.parse(
-                model=kwargs.get("model", self.model),
+                model=self.parse_model,
                 messages=messages,
                 response_format=model_class,
-                temperature=kwargs.get("temperature", 0.2),
             )
             return completion.choices[0].message.parsed
         except Exception as e:

solana_agent/client/solana_agent.py

@@ -6,13 +6,14 @@ the agent system without dealing with internal implementation details.
 """
 import json
 import importlib.util
-from typing import AsyncGenerator, Dict, Any
+from pathlib import Path
+from typing import AsyncGenerator, BinaryIO, Dict, Any, Literal, Optional, Union
 
 from solana_agent.factories.agent_factory import SolanaAgentFactory
-from solana_agent.interfaces.client.client import SolanaAgent
+from solana_agent.interfaces.client.client import SolanaAgent as SolanaAgentInterface
 
 
-class SolanaAgent(SolanaAgent):
+class SolanaAgent(SolanaAgentInterface):
     """Simplified client interface for interacting with the agent system."""
 
     def __init__(self, config_path: str = None, config: Dict[str, Any] = None):
@@ -39,17 +40,34 @@ class SolanaAgent(SolanaAgent):
 
         self.query_service = SolanaAgentFactory.create_from_config(config)
 
-    async def process(self, user_id: str, message: str) -> AsyncGenerator[str, None]:
+    async def process(
+        self,
+        user_id: str,
+        message: Union[str, Path, BinaryIO],
+        output_format: Literal["text", "audio"] = "text",
+        voice: Literal["alloy", "ash", "ballad", "coral", "echo",
+                       "fable", "onyx", "nova", "sage", "shimmer"] = "nova",
+        audio_instructions: Optional[str] = None,
+    ) -> AsyncGenerator[Union[str, bytes], None]:  # pragma: no cover
         """Process a user message and return the response stream.
 
         Args:
             user_id: User ID
-            message: User message
+            message: Text message or audio file input
+            output_format: Response format ("text" or "audio")
+            voice: Voice to use for audio output (only used if output_format is "audio")
+            audio_instructions: Optional instructions for audio synthesis
 
         Returns:
-            Async generator yielding response chunks
+            Async generator yielding response chunks (text strings or audio bytes)
         """
-        async for chunk in self.query_service.process(user_id, message):
+        async for chunk in self.query_service.process(
+            user_id=user_id,
+            query=message,
+            output_format=output_format,
+            voice=voice,
+            audio_instructions=audio_instructions
+        ):
             yield chunk
 
     async def get_user_history(

solana_agent/domains/{agents.py → agent.py}

@@ -53,7 +53,6 @@ class AIAgent(BaseModel):
     instructions: str = Field(...,
                               description="Base instructions for the agent")
     specialization: str = Field(..., description="Agent's specialized domain")
-    model: str = Field("gpt-4o-mini", description="Language model to use")
     created_at: datetime = Field(
         default_factory=datetime.now, description="Creation timestamp")
     updated_at: datetime = Field(

solana_agent/factories/agent_factory.py

@@ -20,7 +20,7 @@ from solana_agent.adapters.llm_adapter import OpenAIAdapter
 from solana_agent.adapters.mongodb_adapter import MongoDBAdapter
 
 # Domain and plugin imports
-from solana_agent.domains.agents import OrganizationMission
+from solana_agent.domains.agent import OrganizationMission
 from solana_agent.plugins.manager import PluginManager
 
 
@@ -45,7 +45,6 @@ class SolanaAgentFactory:
 
         llm_adapter = OpenAIAdapter(
             api_key=config["openai"]["api_key"],
-            model=config.get("openai", {}).get("default_model", "gpt-4o-mini"),
         )
 
         # Create organization mission if specified in config
@@ -110,7 +109,6 @@ class SolanaAgentFactory:
                 name=agent_config["name"],
                 instructions=agent_config["instructions"],
                 specialization=agent_config["specialization"],
-                model=agent_config.get("model", "gpt-4o-mini"),
             )
 
             # Register tools for this agent

solana_agent/interfaces/client/client.py

@@ -1,12 +1,21 @@
 from abc import ABC, abstractmethod
-from typing import Any, AsyncGenerator, Dict
+from pathlib import Path
+from typing import Any, AsyncGenerator, BinaryIO, Dict, Literal, Union
 
 
 class SolanaAgent(ABC):
     """Interface for the Solana agent system."""
 
     @abstractmethod
-    async def process(self, user_id: str, message: str) -> AsyncGenerator[str, None]:
+    async def process(
+        self,
+        user_id: str,
+        message: Union[str, Path, BinaryIO],
+        output_format: Literal["text", "audio"] = "text",
+        voice: Literal["alloy", "ash", "ballad", "coral", "echo",
+                       "fable", "onyx", "nova", "sage", "shimmer"] = "nova",
+        audio_instructions: str = None
+    ) -> AsyncGenerator[Union[str, bytes], None]:
         """Process a user message and return the response stream."""
         pass
 

solana_agent/interfaces/providers/llm.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
-from typing import AsyncGenerator, List, Type, TypeVar
+from pathlib import Path
+from typing import AsyncGenerator, BinaryIO, List, Literal, Type, TypeVar, Union
 
 from pydantic import BaseModel
 
@@ -15,8 +16,6 @@ class LLMProvider(ABC):
         self,
         prompt: str,
         system_prompt: str = "",
-        needs_search: bool = False,
-        **kwargs,
     ) -> AsyncGenerator[str, None]:
         """Generate text from the language model."""
         pass
@@ -28,7 +27,26 @@ class LLMProvider(ABC):
 
     @abstractmethod
     async def parse_structured_output(
-        self, prompt: str, system_prompt: str, model_class: Type[T], **kwargs
+        self, prompt: str, system_prompt: str, model_class: Type[T],
     ) -> T:
         """Generate structured output using a specific model class."""
         pass
+
+    @abstractmethod
+    async def tts(
+        self,
+        text: str,
+        instructions: str = "",
+        voice: Literal["alloy", "ash", "ballad", "coral", "echo",
+                       "fable", "onyx", "nova", "sage", "shimmer"] = "nova",
+    ) -> AsyncGenerator[bytes, None]:
+        """Stream text-to-speech audio from the language model."""
+        pass
+
+    @abstractmethod
+    async def transcribe_audio(
+        self,
+        audio_file: Union[str, Path, BinaryIO],
+    ) -> AsyncGenerator[str, None]:
+        """Transcribe audio from the language model."""
+        pass

solana_agent/interfaces/repositories/agent.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 from typing import List, Optional
 
-from solana_agent.domains.agents import AIAgent
+from solana_agent.domains.agent import AIAgent
 
 
 class AgentRepository(ABC):

solana_agent/interfaces/services/agent.py

@@ -1,12 +1,15 @@
 from abc import ABC, abstractmethod
-from typing import Any, AsyncGenerator, Dict, List
+from pathlib import Path
+from typing import Any, AsyncGenerator, BinaryIO, Dict, List, Literal, Union
+
+from solana_agent.domains.agent import AIAgent
 
 
 class AgentService(ABC):
     """Interface for agent management and response generation."""
 
     @abstractmethod
-    def register_ai_agent(self, name: str, instructions: str, specialization: str, model: str = "gpt-4o-mini") -> None:
+    def register_ai_agent(self, name: str, instructions: str, specialization: str) -> None:
         """Register an AI agent with its specialization."""
         pass
 
@@ -21,7 +24,17 @@ class AgentService(ABC):
         pass
 
     @abstractmethod
-    async def generate_response(self, agent_name: str, user_id: str, query: str, memory_context: str = "", **kwargs) -> AsyncGenerator[str, None]:
+    async def generate_response(
+        self,
+        agent_name: str,
+        user_id: str,
+        query: Union[str, Path, BinaryIO],
+        memory_context: str = "",
+        output_format: Literal["text", "audio"] = "text",
+        voice: Literal["alloy", "ash", "ballad", "coral", "echo",
+                       "fable", "onyx", "nova", "sage", "shimmer"] = "nova",
+        audio_instructions: str = None,
+    ) -> AsyncGenerator[Union[str, bytes], None]:
         """Generate a response from an agent."""
         pass
 
@@ -39,3 +52,8 @@ class AgentService(ABC):
     def execute_tool(self, agent_name: str, tool_name: str, parameters: Dict[str, Any]) -> Dict[str, Any]:
         """Execute a tool on behalf of an agent."""
         pass
+
+    @abstractmethod
+    def get_all_ai_agents(self) -> Dict[str, AIAgent]:
+        """Get all registered AI agents."""
+        pass

solana_agent/interfaces/services/query.py

@@ -1,13 +1,22 @@
 from abc import ABC, abstractmethod
-from typing import Any, AsyncGenerator, Dict
+from pathlib import Path
+from typing import Any, AsyncGenerator, BinaryIO, Dict, Literal, Optional, Union
 
 
 class QueryService(ABC):
     """Interface for processing user queries."""
 
     @abstractmethod
-    async def process(self, user_id: str, query: str) -> AsyncGenerator[str, None]:
-        """Process a query from a user."""
+    async def process(
+        self,
+        user_id: str,
+        query: Union[str, Path, BinaryIO],
+        output_format: Literal["text", "audio"] = "text",
+        voice: Literal["alloy", "ash", "ballad", "coral", "echo",
+                       "fable", "onyx", "nova", "sage", "shimmer"] = "nova",
+        audio_instructions: Optional[str] = None,
+    ) -> AsyncGenerator[Union[str, bytes], None]:
+        """Process the user request and generate a response."""
         pass
 
     @abstractmethod

solana_agent/interfaces/services/routing.py

@@ -6,7 +6,7 @@ class RoutingService(ABC):
     """Interface for query routing services."""
 
     @abstractmethod
-    async def route_query(self, user_id: str, query: str) -> Tuple[str, Any]:
+    async def route_query(self, query: str) -> Tuple[str, Any]:
         """Route a query to the appropriate agent.
 
         Args:

solana_agent/repositories/agent.py

@@ -3,7 +3,7 @@ MongoDB implementation of the agent repository.
 """
 from typing import List, Optional, Any
 
-from solana_agent.domains.agents import AIAgent
+from solana_agent.domains.agent import AIAgent
 from solana_agent.interfaces.repositories.agent import AgentRepository
 
 

solana_agent/services/agent.py

@@ -7,13 +7,14 @@ and response generation.
 import datetime as main_datetime
 from datetime import datetime
 import json
-from typing import AsyncGenerator, Dict, List, Optional, Any
+from pathlib import Path
+from typing import AsyncGenerator, BinaryIO, Dict, List, Literal, Optional, Any, Union
 
 from solana_agent.interfaces.services.agent import AgentService as AgentServiceInterface
 from solana_agent.interfaces.providers.llm import LLMProvider
 from solana_agent.interfaces.repositories.agent import AgentRepository
 from solana_agent.interfaces.plugins.plugins import ToolRegistry
-from solana_agent.domains.agents import AIAgent, OrganizationMission
+from solana_agent.domains.agent import AIAgent, OrganizationMission
 
 
 class AgentService(AgentServiceInterface):
@@ -52,7 +53,7 @@ class AgentService(AgentServiceInterface):
         self.plugin_manager = None
 
     def register_ai_agent(
-        self, name: str, instructions: str, specialization: str, model: str = "gpt-4o-mini"
+        self, name: str, instructions: str, specialization: str,
     ) -> None:
         """Register an AI agent with its specialization.
 
@@ -60,13 +61,11 @@ class AgentService(AgentServiceInterface):
             name: Agent name
             instructions: Agent instructions
             specialization: Agent specialization
-            model: LLM model to use
         """
         agent = AIAgent(
             name=name,
             instructions=instructions,
             specialization=specialization,
-            model=model
         )
         self.agent_repository.save_ai_agent(agent)
 
@@ -190,84 +189,131 @@ class AgentService(AgentServiceInterface):
         self,
         agent_name: str,
         user_id: str,
-        query: str,
+        query: Union[str, Path, BinaryIO],
         memory_context: str = "",
-        **kwargs
-    ) -> AsyncGenerator[str, None]:  # pragma: no cover
-        """Generate a response with tool execution support."""
+        output_format: Literal["text", "audio"] = "text",
+        voice: Literal["alloy", "ash", "ballad", "coral", "echo",
+                       "fable", "onyx", "nova", "sage", "shimmer"] = "nova",
+        audio_instructions: Optional[str] = None,
+    ) -> AsyncGenerator[Union[str, bytes], None]:  # pragma: no cover
+        """Generate a response with support for text/audio input/output.
+
+        Args:
+            agent_name: Agent name
+            user_id: User ID
+            query: Text query or audio file input
+            memory_context: Optional conversation context
+            output_format: Response format ("text" or "audio")
+            voice: Voice to use for audio output
+            audio_instructions: Optional instructions for audio synthesis
+
+        Yields:
+            Text chunks or audio bytes depending on output_format
+        """
         agent = self.agent_repository.get_ai_agent_by_name(agent_name)
         if not agent:
-            yield f"Agent '{agent_name}' not found."
+            error_msg = f"Agent '{agent_name}' not found."
+            if output_format == "audio":
+                async for chunk in self.llm_provider.tts(error_msg, voice=voice):
+                    yield chunk
+            else:
+                yield error_msg
             return
 
-        # Get system prompt and add tool instructions
-        system_prompt = self.get_agent_system_prompt(agent_name)
-        if self.tool_registry:
-            tool_usage_prompt = self._get_tool_usage_prompt(agent_name)
-            if tool_usage_prompt:
-                system_prompt = f"{system_prompt}\n\n{tool_usage_prompt}"
-
-        # Add User ID context
-        system_prompt += f"\n\n User ID: {user_id}"
-
-        # Add memory context
-        if memory_context:
-            system_prompt += f"\n\n Memory Context: {memory_context}"
-
         try:
-            json_response = ""
-            is_json = False
-
+            # Handle audio input if provided
+            query_text = ""
+            if not isinstance(query, str):
+                async for transcript in self.llm_provider.transcribe_audio(query):
+                    query_text += transcript
+            else:
+                query_text = query
+
+            # Get system prompt and add tool instructions
+            system_prompt = self.get_agent_system_prompt(agent_name)
+            if self.tool_registry:
+                tool_usage_prompt = self._get_tool_usage_prompt(agent_name)
+                if tool_usage_prompt:
+                    system_prompt = f"{system_prompt}\n\n{tool_usage_prompt}"
+
+            # Add User ID and memory context
+            system_prompt += f"\n\nUser ID: {user_id}"
+            if memory_context:
+                system_prompt += f"\n\nMemory Context: {memory_context}"
+
+            # Buffer for collecting text when generating audio
+            text_buffer = ""
+
+            # Generate and stream response
             async for chunk in self.llm_provider.generate_text(
-                user_id=user_id,
-                prompt=query,
+                prompt=query_text,
                 system_prompt=system_prompt,
-                model=agent.model,
-                needs_search=True,  # Enable web search by default
-                **kwargs
             ):
-                # Check for JSON start
                 if chunk.strip().startswith("{"):
-                    is_json = True
-                    json_response = chunk
-                    continue
-
-                # Collect JSON or yield normal text
-                if is_json:
-                    json_response += chunk
-                    try:
-                        # Try to parse complete JSON
-                        data = json.loads(json_response)
-
-                        # Handle tool call
-                        if "tool_call" in data:
-                            tool_data = data["tool_call"]
-                            tool_name = tool_data.get("name")
-                            parameters = tool_data.get("parameters", {})
-
-                            if tool_name:
-                                result = self.execute_tool(
-                                    agent_name, tool_name, parameters)
-                                if result.get("status") == "success":
-                                    yield result.get("result", "")
-                                else:
-                                    yield f"I apologize, but I encountered an issue: {result.get('message', 'Unknown error')}"
-                                break
-                        else:
-                            # If JSON but not a tool call, yield as text
-                            yield json_response
-                            break
-                    except json.JSONDecodeError:
-                        # Not complete JSON yet, keep collecting
-                        continue
+                    # Handle tool calls
+                    result = await self._handle_tool_call(
+                        agent_name, chunk, output_format, voice
+                    )
+                    if output_format == "audio":
+                        async for audio_chunk in self.llm_provider.tts(result, instructions=audio_instructions, voice=voice):
+                            yield audio_chunk
+                    else:
+                        yield result
                 else:
-                    yield chunk
+                    if output_format == "audio":
+                        # Buffer text until we have a complete sentence
+                        text_buffer += chunk
+                        if any(punct in chunk for punct in ".!?"):
+                            async for audio_chunk in self.llm_provider.tts(
+                                text_buffer, instructions=audio_instructions, voice=voice
+                            ):
+                                yield audio_chunk
+                            text_buffer = ""
+                    else:
+                        yield chunk
+
+            # Handle any remaining text in buffer
+            if output_format == "audio" and text_buffer:
+                async for audio_chunk in self.llm_provider.tts(
+                    text_buffer, instructions=audio_instructions, voice=voice
+                ):
+                    yield audio_chunk
 
         except Exception as e:
+            error_msg = f"I apologize, but I encountered an error: {str(e)}"
+            if output_format == "audio":
+                async for chunk in self.llm_provider.tts(error_msg, instructions=audio_instructions, voice=voice):
+                    yield chunk
+            else:
+                yield error_msg
+
             print(f"Error in generate_response: {str(e)}")
             import traceback
             print(traceback.format_exc())
-            yield f"I apologize, but I encountered an error: {str(e)}"
+
+    async def _handle_tool_call(
+        self,
+        agent_name: str,
+        json_chunk: str,
+    ) -> str:
+        """Handle tool calls and return formatted response."""
+        try:
+            data = json.loads(json_chunk)
+            if "tool_call" in data:
+                tool_data = data["tool_call"]
+                tool_name = tool_data.get("name")
+                parameters = tool_data.get("parameters", {})
+
+                if tool_name:
+                    result = self.execute_tool(
+                        agent_name, tool_name, parameters)
+                    if result.get("status") == "success":
+                        return result.get("result", "")
+                    else:
+                        return f"I apologize, but I encountered an issue: {result.get('message', 'Unknown error')}"
+            return json_chunk
+        except json.JSONDecodeError:
+            return json_chunk
 
     def _get_tool_usage_prompt(self, agent_name: str) -> str:
         """Generate JSON-based instructions for tool usage."""

solana_agent/services/query.py

@@ -5,7 +5,8 @@ This service orchestrates the processing of user queries, coordinating
 other services to provide comprehensive responses while maintaining
 clean separation of concerns.
 """
-from typing import Any, AsyncGenerator, Dict, Optional
+from pathlib import Path
+from typing import Any, AsyncGenerator, BinaryIO, Dict, Literal, Optional, Union
 
 from solana_agent.interfaces.services.query import QueryService as QueryServiceInterface
 from solana_agent.services.agent import AgentService
@@ -34,23 +35,44 @@ class QueryService(QueryServiceInterface):
         self.memory_provider = memory_provider
 
     async def process(
-        self, user_id: str, user_text: str, timezone: str = None
-    ) -> AsyncGenerator[str, None]:  # pragma: no cover
+        self,
+        user_id: str,
+        query: Union[str, Path, BinaryIO],
+        output_format: Literal["text", "audio"] = "text",
+        voice: Literal["alloy", "ash", "ballad", "coral", "echo",
+                       "fable", "onyx", "nova", "sage", "shimmer"] = "nova",
+        audio_instructions: Optional[str] = None,
+    ) -> AsyncGenerator[Union[str, bytes], None]:  # pragma: no cover
         """Process the user request with appropriate agent.
 
         Args:
             user_id: User ID
-            user_text: User query text
-            timezone: Optional user timezone
+            query: Text query or audio file input
+            output_format: Response format ("text" or "audio")
+            voice: Voice to use for audio output
+            audio_instructions: Optional instructions for audio synthesis
 
         Yields:
-            Response text chunks
+            Response chunks (text strings or audio bytes)
         """
         try:
+            # Handle audio input if provided
+            user_text = ""
+            if not isinstance(query, str):
+                async for transcript in self.agent_service.llm_provider.transcribe_audio(query):
+                    user_text += transcript
+            else:
+                user_text = query
+
             # Handle simple greetings
             if user_text.strip().lower() in ["test", "hello", "hi", "hey", "ping"]:
-                response = f"Hello! How can I help you today?"
-                yield response
+                response = "Hello! How can I help you today?"
+                if output_format == "audio":
+                    async for chunk in self.agent_service.llm_provider.tts(response, instructions=audio_instructions, voice=voice):
+                        yield chunk
+                else:
+                    yield response
+
                 # Store simple interaction in memory
                 if self.memory_provider:
                     await self._store_conversation(user_id, user_text, response)
@@ -62,27 +84,48 @@ class QueryService(QueryServiceInterface):
                 memory_context = await self.memory_provider.retrieve(user_id)
 
             # Route query to appropriate agent
-            agent_name = await self.routing_service.route_query(user_id, user_text)
+            agent_name = await self.routing_service.route_query(user_text)
 
-            # Generate response
+            # Generate response using agent service
             full_response = ""
             async for chunk in self.agent_service.generate_response(
                 agent_name=agent_name,
                 user_id=user_id,
                 query=user_text,
-                memory_context=memory_context
+                memory_context=memory_context,
+                output_format=output_format,
+                voice=voice
             ):
                 yield chunk
-                full_response += chunk
+                if output_format == "text":
+                    full_response += chunk
+
+            # For audio responses, get transcription for storage
+            if output_format == "audio":
+                # Re-generate response in text format for storage
+                async for chunk in self.agent_service.generate_response(
+                    agent_name=agent_name,
+                    user_id=user_id,
+                    query=user_text,
+                    memory_context=memory_context,
+                    output_format="text"
+                ):
+                    full_response += chunk
 
             # Store conversation and extract insights
             if self.memory_provider:
                 await self._store_conversation(user_id, user_text, full_response)
 
         except Exception as e:
-            yield f"I apologize for the technical difficulty. {str(e)}"
-            import traceback
+            error_msg = f"I apologize for the technical difficulty. {str(e)}"
+            if output_format == "audio":
+                async for chunk in self.agent_service.llm_provider.tts(error_msg, instructions=audio_instructions, voice=voice):
+                    yield chunk
+            else:
+                yield error_msg
+
             print(f"Error in query processing: {str(e)}")
+            import traceback
             print(traceback.format_exc())
 
     async def get_user_history(

solana_agent/services/routing.py

@@ -54,7 +54,6 @@ class RoutingService(RoutingServiceInterface):
                 prompt=prompt,
                 system_prompt="Analyze user queries to determine appropriate routing.",
                 model_class=QueryAnalysis,
-                temperature=0.2
             )
 
             return {
@@ -75,27 +74,30 @@ class RoutingService(RoutingServiceInterface):
                 "confidence": 0.0
             }
 
-    async def route_query(self, user_id: str, query: str) -> str:
+    async def route_query(self, query: str) -> str:
         """Route a query to the appropriate agent.
 
         Args:
-            user_id: ID of the user making the query
             query: The query text
 
         Returns:
-            Name of the selected agent
+            Name of the best agent
         """
+        # If only one agent - use that agent
+        if len(self.agent_service.get_all_ai_agents()) == 1:
+            return next(iter(self.agent_service.get_all_ai_agents().keys()))
+
         # Analyze query
         analysis = await self._analyze_query(query)
 
         # Find best agent based on analysis
-        selected_agent = await self._find_best_ai_agent(
+        best_agent = await self._find_best_ai_agent(
             analysis["primary_specialization"],
             analysis["secondary_specializations"]
         )
 
-        # Return default agent if none found
-        return selected_agent or "general_ai"
+        # Return best agent
+        return best_agent
 
     async def _find_best_ai_agent(
         self,

{solana_agent-14.0.2.dist-info → solana_agent-15.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: solana-agent
-Version: 14.0.2
+Version: 15.0.0
 Summary: The Future of Work
 License: MIT
 Keywords: ai,openai,ai agents,agi
@@ -34,7 +34,7 @@ Description-Content-Type: text/markdown
 
 ## Features
 
-* Text streaming messages by AI Agents
+* Multi-modal input-output streaming with text or audio by AI Agents
 * Conversational memory per user shared by all AI Agents
 * Routing based on AI Agent specializations
 * Built-in Internet Search for all AI Agents
@@ -85,21 +85,18 @@ config = {
     },
     "openai": {
         "api_key": "your-openai-key",
-        "default_model": "gpt-4o-mini"
     },
     "agents": [
         {
             "name": "research_specialist",
             "instructions": "You are an expert researcher who synthesizes complex information clearly.",
             "specialization": "Research and knowledge synthesis",
-            "model": "o3-mini",
             "tools": ["some_tool"]
         },
         {
             "name": "customer_support",
             "instructions": "You provide friendly, helpful customer support responses.",
             "specialization": "Customer inquiries",
-            "model": "gpt-4o-mini"
         }
     ],
 }
@@ -112,6 +109,12 @@ async for response in solana_agent.process("user123", "What are the latest AI de
     print(response, end="")
 ```
 
+## LLMs Used
+* The model used for AI Agents is `gpt-4o-mini-search-preview`
+* The model used for internal structured outputs is `gpt-4o-mini`
+* The model used for audio_transcription is `gpt-4o-mini-transcribe`
+* The model used for tts is `gpt-4o-mini-tts`
+
 ## Solana Agent Kit
 
 [Solana Agent Kit](https://github.com/truemagic-coder/solana-agent-kit)

{solana_agent-14.0.2.dist-info → solana_agent-15.0.0.dist-info}/RECORD

@@ -1,37 +1,37 @@
 solana_agent/__init__.py,sha256=ceYeUpjIitpln8YK1r0JVJU8mzG6cRPYu-HLny3d-Tw,887
 solana_agent/adapters/__init__.py,sha256=tiEEuuy0NF3ngc_tGEcRTt71zVI58v3dYY9RvMrF2Cg,204
-solana_agent/adapters/llm_adapter.py,sha256=-MmQL71JlNJeWr16a-qZ5OzTg1_69ewgAR9ZSwXpsbw,4326
+solana_agent/adapters/llm_adapter.py,sha256=Fj-UGLc3vAcdtO_ZN0dX2zdh6wW7ae5Olvkg3q-Jtv4,6085
 solana_agent/adapters/mongodb_adapter.py,sha256=zvcIZ61zx45cwfjMimXC2RV_D_s6sL5b2Dz6H3HCgFc,2456
 solana_agent/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-solana_agent/client/solana_agent.py,sha256=Y2SRwysvUsW3_NM8dqURdabkmS1lMsiAKrPG9dtSQ4g,2676
+solana_agent/client/solana_agent.py,sha256=-mwUoCrSyiY6k6Gw4RbaqpV3gWC9n8t1JRWalFvTWPo,3550
 solana_agent/domains/__init__.py,sha256=HiC94wVPRy-QDJSSRywCRrhrFfTBeHjfi5z-QfZv46U,168
-solana_agent/domains/agents.py,sha256=S8OKtkUQ7npl8bZrSH64TZuu5bnwnMYXXx3IbKvJOuU,3005
+solana_agent/domains/agent.py,sha256=Ak_hD5gTCzRqAHLmqtxnny0Xki1qAKR7RzLW9LOQBTg,2930
 solana_agent/domains/routing.py,sha256=UDlgTjUoC9xIBVYu_dnf9-KG_bBgdEXAv_UtDOrYo0w,650
 solana_agent/factories/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-solana_agent/factories/agent_factory.py,sha256=yjB3G8ItXFH3DaoRf1BB1acPnL84Pd2pbqz5W03-5Jc,5711
+solana_agent/factories/agent_factory.py,sha256=zrDezSNT167ePTYAZSPLg9imPlz8nTXoSr5kO83ePCg,5566
 solana_agent/interfaces/__init__.py,sha256=IQs1WIM1FeKP1-kY2FEfyhol_dB-I-VAe2rD6jrVF6k,355
-solana_agent/interfaces/client/client.py,sha256=SouFRSUhXK5qN88ln5anHnStrZfPJyY2cr5sVRRDBEw,668
+solana_agent/interfaces/client/client.py,sha256=NzsY2vBv3BbBOfgfRoQCluqS9oBCPkHBHbrzde4gG1Y,1027
 solana_agent/interfaces/plugins/plugins.py,sha256=TMmTXwHhmkdJpIhgADfrpGGGk7PHP7O9Qi89uA26uMI,3013
 solana_agent/interfaces/providers/data_storage.py,sha256=Qjui9ISvX_NtOUPTUyjPMNxDoYRpml-aMG8DZy_Qxzc,1509
-solana_agent/interfaces/providers/llm.py,sha256=y4OFj2Wq4XicMxArWsYBHSp6cFe3BcK9sCemfyaWV_A,887
+solana_agent/interfaces/providers/llm.py,sha256=uJE1-WClY0K2n2ZIzylnwBl-q_7YXyKjkL3ao-b2t3A,1461
 solana_agent/interfaces/providers/memory.py,sha256=oNOH8WZXVW8assDigIWZAWiwkxbpDiKupxA2RB6tQvQ,1010
-solana_agent/interfaces/repositories/agent.py,sha256=HZL5q7DoOj-qK5IDSShAJnu4_A75OR0xgJD_2W6Zr6k,820
-solana_agent/interfaces/services/agent.py,sha256=JHUVsxAnOsopiNilU_zDBAhJfQT_BFrtOczDL2atoZo,1407
-solana_agent/interfaces/services/query.py,sha256=w2ZeAX3j0n7dfh5EtesWqEy4YZ-cqjI3EmR3lyGnyJs,641
-solana_agent/interfaces/services/routing.py,sha256=tKMK97m6U5I__F406sm60az4QInGLX_N3knc_AbMZ80,452
+solana_agent/interfaces/repositories/agent.py,sha256=r2MzVYOpEBVN00yqRxr3bUgWUgSwqoI1hRrdHhgFpFU,819
+solana_agent/interfaces/services/agent.py,sha256=nTLJVymnVHrCzm0gQPhQiU3KZoH93OeXdFjZU3gs3Bc,1926
+solana_agent/interfaces/services/query.py,sha256=1ubfhQLx5l2b1UZCKnqUhGg-v_qpf7Ve_8KD5KRXvx8,1042
+solana_agent/interfaces/services/routing.py,sha256=gohkt5f9uYDLpu4iDVDk9yj8js9P56R6QHSIDNylgwA,438
 solana_agent/plugins/__init__.py,sha256=coZdgJKq1ExOaj6qB810i3rEhbjdVlrkN76ozt_Ojgo,193
 solana_agent/plugins/manager.py,sha256=GWwhfMBn9THwVn7biOvVa25GLthCA1ilWIoDkt5hXNI,5084
 solana_agent/plugins/registry.py,sha256=dRKWoOEqiU7OLsjpBWf4VJfDQYZdJPjW5AKxeITmVMA,2283
 solana_agent/plugins/tools/__init__.py,sha256=c0z7ij42gs94_VJrcn4Y8gUlTxMhsFNY6ahIsNswdLk,231
 solana_agent/plugins/tools/auto_tool.py,sha256=Z3CcOzwdXpzciH-5yphhd9qt1b9owTxhwC-dYmPF6B0,1489
 solana_agent/repositories/__init__.py,sha256=fP83w83CGzXLnSdq-C5wbw9EhWTYtqE2lQTgp46-X_4,163
-solana_agent/repositories/agent.py,sha256=7FTT3WvOaBacWme7d-qaOyqAlUhf9LVLXnIiPb16FDk,3188
+solana_agent/repositories/agent.py,sha256=e1rnsQiigkKwJNLKro86a3b6TBiky3GMfmCRc5b_jPw,3187
 solana_agent/repositories/memory.py,sha256=0wgoa2bXhpgdBgn9-i9G10PB1bMGYObxcoY9Newll40,4742
 solana_agent/services/__init__.py,sha256=ab_NXJmwYUCmCrCzuTlZ47bJZINW0Y0F5jfQ9OovidU,163
-solana_agent/services/agent.py,sha256=Z5b6aOuEAMw8CHjvQ__reG4b9P056hKquFisNzwzosg,11509
-solana_agent/services/query.py,sha256=5_Py2t3p8oB4EVZZnbi7BezP9yigRe1EU9ZQ9AzQAog,7901
-solana_agent/services/routing.py,sha256=L3nZaMeX4ENYfHoc2KrOtfzhScCWfrXS5RRaUIJPwNY,4956
-solana_agent-14.0.2.dist-info/LICENSE,sha256=BnSRc-NSFuyF2s496l_4EyrwAP6YimvxWcjPiJ0J7g4,1057
-solana_agent-14.0.2.dist-info/METADATA,sha256=8RG-LRrM9BBzXlb-159YvTacsao2BW4c7MgrutTY2ps,4774
-solana_agent-14.0.2.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-solana_agent-14.0.2.dist-info/RECORD,,
+solana_agent/services/agent.py,sha256=RTd7ulqBFd8Y-Ix1sao3BYJvhaAUuVtv_Qqu-26zI2Y,13625
+solana_agent/services/query.py,sha256=d7p7Uop-UmthHqYN_rTv3_fb0idxzo026SHttXE4uGk,9865
+solana_agent/services/routing.py,sha256=TPJ2Pas4acE93QzMEV6ZP670OtTNrVEPa76fz6urEV4,4996
+solana_agent-15.0.0.dist-info/LICENSE,sha256=BnSRc-NSFuyF2s496l_4EyrwAP6YimvxWcjPiJ0J7g4,1057
+solana_agent-15.0.0.dist-info/METADATA,sha256=4ktEyE89ap3ZBOA137EVG9_Bod4IYpZtlOAYIMcMyYc,4956
+solana_agent-15.0.0.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+solana_agent-15.0.0.dist-info/RECORD,,