solana-agent 29.2.0__py3-none-any.whl → 29.2.1__py3-none-any.whl

solana_agent/adapters/openai_adapter.py

@@ -163,8 +163,10 @@ class OpenAIAdapter(LLMProvider):
         api_key: Optional[str] = None,
         base_url: Optional[str] = None,
         model: Optional[str] = None,
-    ) -> str:  # pragma: no cover
-        """Generate text from OpenAI models as a single string (no images)."""
+        functions: Optional[List[Dict[str, Any]]] = None,
+        function_call: Optional[Union[str, Dict[str, Any]]] = None,
+    ) -> Any:  # pragma: no cover
+        """Generate text or function call from OpenAI models."""
         messages = []
         if system_prompt:
             messages.append({"role": "system", "content": system_prompt})
@@ -174,6 +176,10 @@ class OpenAIAdapter(LLMProvider):
             "messages": messages,
             "model": model or self.text_model,
         }
+        if functions:
+            request_params["functions"] = functions
+        if function_call:
+            request_params["function_call"] = function_call
 
         if api_key and base_url:
             client = AsyncOpenAI(api_key=api_key, base_url=base_url)
@@ -185,17 +191,13 @@ class OpenAIAdapter(LLMProvider):
 
         try:
             response = await client.chat.completions.create(**request_params)
-            if response.choices and response.choices[0].message.content:
-                return response.choices[0].message.content
-            else:
-                logger.warning("Received non-streaming response with no content.")
-                return ""
-        except OpenAIError as e:  # Catch specific OpenAI errors
+            return response
+        except OpenAIError as e:
             logger.error(f"OpenAI API error during text generation: {e}")
-            return f"I apologize, but I encountered an API error: {e}"
+            return None
         except Exception as e:
             logger.exception(f"Error in generate_text: {e}")
-            return f"I apologize, but I encountered an unexpected error: {e}"
+            return None
 
     def _calculate_gpt41_image_cost(self, width: int, height: int, model: str) -> int:
         """Calculates the token cost for an image with GPT-4.1 models."""

solana_agent/interfaces/providers/llm.py

@@ -1,6 +1,8 @@
 from abc import ABC, abstractmethod
 from typing import (
+    Any,
     AsyncGenerator,
+    Dict,
     List,
     Literal,
     Optional,
@@ -26,7 +28,9 @@ class LLMProvider(ABC):
         api_key: Optional[str] = None,
         base_url: Optional[str] = None,
         model: Optional[str] = None,
-    ) -> str:
+        functions: Optional[List[Dict[str, Any]]] = None,
+        function_call: Optional[Union[str, Dict[str, Any]]] = None,
+    ) -> Any:
         """Generate text from the language model."""
         pass
 

solana_agent/services/agent.py

@@ -5,7 +5,6 @@ This service manages AI and human agents, their registration, tool assignments,
 and response generation.
 """
 
-import asyncio
 import datetime as main_datetime
 from datetime import datetime
 import json
@@ -205,137 +204,6 @@ class AgentService(AgentServiceInterface):
             )
             return {"status": "error", "message": f"Error executing tool: {str(e)}"}
 
-    # --- Helper function to recursively substitute placeholders ---
-    def _substitute_placeholders(self, data: Any, results_map: Dict[str, str]) -> Any:
-        """Recursively substitutes placeholders like {{tool_name.result}} or {output_of_tool_name} in strings."""
-        if isinstance(data, str):
-            # Regex to find placeholders like {{tool_name.result}} or {output_of_tool_name}
-            placeholder_pattern = re.compile(
-                r"\{\{(?P<name1>[a-zA-Z0-9_]+)\.result\}\}|\{output_of_(?P<name2>[a-zA-Z0-9_]+)\}"
-            )
-
-            def replace_match(match):
-                tool_name = match.group("name1") or match.group("name2")
-                if tool_name and tool_name in results_map:
-                    logger.debug(f"Substituting placeholder for '{tool_name}'")
-                    return results_map[tool_name]
-                else:
-                    # If placeholder not found, leave it as is but log warning
-                    logger.warning(
-                        f"Could not find result for placeholder tool '{tool_name}'. Leaving placeholder."
-                    )
-                    return match.group(0)  # Return original placeholder
-
-            # Use re.sub with the replacement function
-            return placeholder_pattern.sub(replace_match, data)
-        elif isinstance(data, dict):
-            # Recursively process dictionary values
-            return {
-                k: self._substitute_placeholders(v, results_map)
-                for k, v in data.items()
-            }
-        elif isinstance(data, list):
-            # Recursively process list items
-            return [self._substitute_placeholders(item, results_map) for item in data]
-        else:
-            # Return non-string/dict/list types as is
-            return data
-
-    # --- Helper to parse tool calls ---
-    def _parse_tool_calls(self, text: str) -> List[Dict[str, Any]]:
-        """Parses all [TOOL]...[/TOOL] blocks in the text."""
-        tool_calls = []
-        # Regex to find all tool blocks, non-greedy match for content
-        pattern = re.compile(r"\[TOOL\](.*?)\[/TOOL\]", re.DOTALL | re.IGNORECASE)
-        matches = pattern.finditer(text)
-
-        for match in matches:
-            tool_content = match.group(1).strip()
-            tool_name = None
-            parameters = {}
-            try:
-                for line in tool_content.split("\n"):
-                    line = line.strip()
-                    if not line:
-                        continue
-                    if line.lower().startswith("name:"):
-                        tool_name = line[5:].strip()
-                    elif line.lower().startswith("parameters:"):
-                        params_text = line[11:].strip()
-                        try:
-                            # Prefer JSON parsing
-                            parameters = json.loads(params_text)
-                        except json.JSONDecodeError:
-                            logger.warning(
-                                f"Failed to parse parameters as JSON, falling back: {params_text}"
-                            )
-                            # Fallback: Treat as simple key=value (less robust)
-                            try:
-                                # Basic eval might work for {"key": "value"} but is risky
-                                # parameters = eval(params_text) # Avoid eval if possible
-                                # Safer fallback: Assume simple string if not JSON-like
-                                if not params_text.startswith("{"):
-                                    # Try splitting key=value pairs? Very brittle.
-                                    # For now, log warning and skip complex fallback parsing
-                                    logger.error(
-                                        f"Cannot parse non-JSON parameters reliably: {params_text}"
-                                    )
-                                    parameters = {
-                                        "_raw_params": params_text
-                                    }  # Store raw string
-                                else:
-                                    # If it looks like a dict but isn't valid JSON, log error
-                                    logger.error(
-                                        f"Invalid dictionary format for parameters: {params_text}"
-                                    )
-                                    parameters = {"_raw_params": params_text}
-
-                            except Exception as parse_err:
-                                logger.error(
-                                    f"Fallback parameter parsing failed: {parse_err}"
-                                )
-                                parameters = {
-                                    "_raw_params": params_text
-                                }  # Store raw string on error
-
-                if tool_name:
-                    tool_calls.append({"name": tool_name, "parameters": parameters})
-                else:
-                    logger.warning(f"Parsed tool block missing name: {tool_content}")
-            except Exception as e:
-                logger.error(f"Error parsing tool content: {tool_content} - {e}")
-
-        logger.info(f"Parsed {len(tool_calls)} tool calls from response.")
-        return tool_calls
-
-    # --- Helper to execute a single parsed tool call ---
-    async def _execute_single_tool(
-        self, agent_name: str, tool_call: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """Executes a single tool call dictionary and returns its result."""
-        tool_name = tool_call.get("name")
-        parameters = tool_call.get("parameters", {})
-        if not tool_name:
-            return {
-                "tool_name": "unknown",
-                "status": "error",
-                "message": "Tool name missing in parsed call",
-            }
-        # Ensure parameters is a dict, even if parsing failed
-        if not isinstance(parameters, dict):
-            logger.warning(
-                f"Parameters for tool '{tool_name}' is not a dict: {parameters}. Attempting execution with empty params."
-            )
-            parameters = {}
-
-        logger.debug(
-            f"Preparing to execute tool '{tool_name}' with params: {parameters}"
-        )
-        result = await self.execute_tool(agent_name, tool_name, parameters)
-        # Add tool name to result for easier aggregation
-        result["tool_name"] = tool_name
-        return result
-
     async def generate_response(
         self,
         agent_name: str,
@@ -362,9 +230,8 @@ class AgentService(AgentServiceInterface):
         ] = "aac",
         prompt: Optional[str] = None,
     ) -> AsyncGenerator[Union[str, bytes], None]:  # pragma: no cover
-        """Generate a response, supporting multiple sequential tool calls with placeholder substitution.
-        Optionally accepts images for vision-capable models.
-        """
+        """Generate a response using OpenAI function calling (tools API) via generate_text."""
+
         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."
@@ -381,268 +248,88 @@ class AgentService(AgentServiceInterface):
                 yield error_msg
             return
 
-        logger.debug(
-            f"Generating response for agent '{agent_name}'. Output format: {output_format}. Images provided: {bool(images)}."
-        )
+        # 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]"  # Optionally, handle images as needed
+            )
+
+        # Compose the prompt for generate_text
+        full_prompt = ""
+        if memory_context:
+            full_prompt += f"CONVERSATION HISTORY:\n{memory_context}\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
+        functions = []
+        for tool in self.get_agent_tools(agent_name):
+            functions.append(
+                {
+                    "name": tool["name"],
+                    "description": tool.get("description", ""),
+                    "parameters": tool.get("parameters", {}),
+                }
+            )
 
+        response_text = ""
         try:
-            # --- System Prompt Assembly ---
-            system_prompt_parts = [self.get_agent_system_prompt(agent_name)]
-            tool_instructions = self._get_tool_usage_prompt(agent_name)
-            if tool_instructions:
-                system_prompt_parts.append(tool_instructions)
-            system_prompt_parts.append(f"USER IDENTIFIER: {user_id}")
-            if memory_context:
-                system_prompt_parts.append(f"\nCONVERSATION HISTORY:\n{memory_context}")
-            if prompt:
-                system_prompt_parts.append(f"\nADDITIONAL PROMPT:\n{prompt}")
-            final_system_prompt = "\n\n".join(filter(None, system_prompt_parts))
-
-            # --- Initial Response Generation (No Streaming) ---
-            initial_llm_response_buffer = ""
-            tool_calls_detected = False
-            start_marker = "[TOOL]"
-
-            logger.info(f"Generating initial response for agent '{agent_name}'...")
-
-            # --- CHOOSE LLM METHOD BASED ON IMAGE PRESENCE ---
-            if images:
-                # Use the new vision method if images are present
-                logger.info(
-                    f"Using generate_text_with_images for {len(images)} images."
-                )
-                # Ensure query is string for the text part
-                text_query = str(query) if isinstance(query, bytes) else query
-                initial_llm_response_buffer = (
-                    await self.llm_provider.generate_text_with_images(
-                        prompt=text_query,
-                        images=images,
-                        system_prompt=final_system_prompt,
-                    )
-                )
-            else:
-                # Use the standard text generation method
-                logger.info("Using generate_text (no images provided).")
-                initial_llm_response_buffer = await self.llm_provider.generate_text(
-                    prompt=str(query),
-                    system_prompt=final_system_prompt,
+            while True:
+                response = await self.llm_provider.generate_text(
+                    prompt=full_prompt,
+                    system_prompt=system_prompt,
+                    functions=functions if functions else None,
+                    function_call="auto" if functions else None,
                     api_key=self.api_key,
                     base_url=self.base_url,
                     model=self.model,
                 )
-            # --- END LLM METHOD CHOICE ---
-
-            # Check for errors returned as string by the adapter
-            if isinstance(initial_llm_response_buffer, str) and (
-                initial_llm_response_buffer.startswith(
-                    "I apologize, but I encountered an"
-                )
-                or initial_llm_response_buffer.startswith("Error:")
-            ):
-                logger.error(
-                    f"LLM provider failed during initial generation: {initial_llm_response_buffer}"
-                )
-                # Yield the error and exit
-                if output_format == "audio":
-                    async for chunk in self.llm_provider.tts(
-                        initial_llm_response_buffer,
-                        voice=audio_voice,
-                        response_format=audio_output_format,
-                        instructions=audio_instructions,
-                    ):
-                        yield chunk
-                else:
-                    yield initial_llm_response_buffer
-                return
-
-            # Check for tool markers in the complete response
-            if start_marker.lower() in initial_llm_response_buffer.lower():
-                tool_calls_detected = True
-                logger.info("Tool call marker detected in initial response.")
-
-            logger.debug(
-                f"Full initial LLM response buffer:\n--- START ---\n{initial_llm_response_buffer}\n--- END ---"
-            )
-            logger.info(
-                f"Initial LLM response received (length: {len(initial_llm_response_buffer)}). Tools detected: {tool_calls_detected}"
-            )
-
-            # --- Tool Execution Phase (if tools were detected) ---
-            final_response_text = ""
-            if tool_calls_detected:
-                # NOTE: If tools need to operate on image content, this logic needs significant changes.
-                # Assuming for now tools operate based on the text query or the LLM's understanding derived from images.
-                parsed_calls = self._parse_tool_calls(initial_llm_response_buffer)
-
-                if parsed_calls:
-                    # ... (existing sequential tool execution with substitution) ...
-                    executed_tool_results = []
-                    tool_results_map: Dict[str, str] = {}
+                if (
+                    not response
+                    or not hasattr(response, "choices")
+                    or not response.choices
+                ):
+                    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
+                )  # Support both OpenAI and instructor
+
+                # If the model wants to call a function/tool
+                if hasattr(message, "function_call") and message.function_call:
+                    function_name = message.function_call.name
+                    arguments = json.loads(message.function_call.arguments)
                     logger.info(
-                        f"Executing {len(parsed_calls)} tools sequentially with substitution..."
-                    )
-                    for i, call in enumerate(parsed_calls):
-                        # ... (existing substitution logic) ...
-                        tool_name_to_exec = call.get("name", "unknown")
-                        logger.info(
-                            f"Executing tool {i + 1}/{len(parsed_calls)}: {tool_name_to_exec}"
-                        )
-                        try:
-                            original_params = call.get("parameters", {})
-                            substituted_params = self._substitute_placeholders(
-                                original_params, tool_results_map
-                            )
-                            if substituted_params != original_params:
-                                logger.info(
-                                    f"Substituted parameters for tool '{tool_name_to_exec}': {substituted_params}"
-                                )
-                            call["parameters"] = substituted_params
-                        except Exception as sub_err:
-                            logger.error(
-                                f"Error substituting placeholders for tool '{tool_name_to_exec}': {sub_err}",
-                                exc_info=True,
-                            )
-
-                        # ... (existing tool execution call) ...
-                        try:
-                            result = await self._execute_single_tool(agent_name, call)
-                            executed_tool_results.append(result)
-                            if result.get("status") == "success":
-                                tool_result_str = str(result.get("result", ""))
-                                tool_results_map[tool_name_to_exec] = tool_result_str
-                                logger.debug(
-                                    f"Stored result for '{tool_name_to_exec}' (length: {len(tool_result_str)})"
-                                )
-                            else:
-                                error_message = result.get("message", "Unknown error")
-                                tool_results_map[tool_name_to_exec] = (
-                                    f"Error: {error_message}"
-                                )
-                                logger.warning(
-                                    f"Tool '{tool_name_to_exec}' failed, storing error message."
-                                )
-                        except Exception as tool_exec_err:
-                            logger.error(
-                                f"Exception during execution of tool {tool_name_to_exec}: {tool_exec_err}",
-                                exc_info=True,
-                            )
-                            error_result = {
-                                "tool_name": tool_name_to_exec,
-                                "status": "error",
-                                "message": f"Exception during execution: {str(tool_exec_err)}",
-                            }
-                            executed_tool_results.append(error_result)
-                            tool_results_map[tool_name_to_exec] = (
-                                f"Error: {str(tool_exec_err)}"
-                            )
-
-                    logger.info("Sequential tool execution with substitution complete.")
-
-                    # ... (existing formatting of tool results) ...
-                    tool_results_text_parts = []
-                    for i, result in enumerate(executed_tool_results):
-                        tool_name = result.get("tool_name", "unknown")
-                        if (
-                            isinstance(result, Exception)
-                            or result.get("status") == "error"
-                        ):
-                            error_msg = (
-                                result.get("message", str(result))
-                                if isinstance(result, dict)
-                                else str(result)
-                            )
-                            logger.error(f"Tool '{tool_name}' failed: {error_msg}")
-                            tool_results_text_parts.append(
-                                f"Tool {i + 1} ({tool_name}) Execution Failed:\n{error_msg}"
-                            )
-                        else:
-                            tool_output = str(result.get("result", ""))
-                            tool_results_text_parts.append(
-                                f"Tool {i + 1} ({tool_name}) Result:\n{tool_output}"
-                            )
-                    tool_results_context = "\n\n".join(tool_results_text_parts)
-
-                    # --- Generate Final Response using Tool Results (No Streaming) ---
-                    # Include original query (text part) and mention images were provided if applicable
-                    original_query_context = f"Original Query: {str(query)}"
-                    if images:
-                        original_query_context += f" (with {len(images)} image(s))"
-
-                    follow_up_prompt = f"{original_query_context}\n\nRESULTS FROM TOOL CALLS:\n{tool_results_context}\n\nBased on the original query, any provided images, and the tool results, please provide the final response to the user."
-                    follow_up_system_prompt_parts = [
-                        self.get_agent_system_prompt(agent_name)
-                    ]
-                    follow_up_system_prompt_parts.append(f"USER IDENTIFIER: {user_id}")
-                    if memory_context:
-                        follow_up_system_prompt_parts.append(
-                            f"\nORIGINAL CONVERSATION HISTORY:\n{memory_context}"
-                        )
-                    if prompt:
-                        follow_up_system_prompt_parts.append(
-                            f"\nORIGINAL ADDITIONAL PROMPT:\n{prompt}"
-                        )
-                    follow_up_system_prompt_parts.append(
-                        f"\nCONTEXT: You previously decided to run {len(parsed_calls)} tool(s) sequentially. The results are provided above."
-                    )
-                    final_follow_up_system_prompt = "\n\n".join(
-                        filter(None, follow_up_system_prompt_parts)
+                        f"Model requested tool '{function_name}' with args: {arguments}"
                     )
 
-                    logger.info(
-                        "Generating final response incorporating tool results..."
-                    )
-                    # Use standard text generation for the final synthesis
-                    synthesized_response_buffer = await self.llm_provider.generate_text(
-                        prompt=follow_up_prompt,
-                        system_prompt=final_follow_up_system_prompt,
-                        api_key=self.api_key,
-                        base_url=self.base_url,
-                        model=self.model
-                        or self.llm_provider.text_model,  # Use text model for synthesis
+                    # Execute the tool (async)
+                    tool_result = await self.execute_tool(
+                        agent_name, function_name, arguments
                     )
 
-                    if isinstance(synthesized_response_buffer, str) and (
-                        synthesized_response_buffer.startswith(
-                            "I apologize, but I encountered an"
-                        )
-                        or synthesized_response_buffer.startswith("Error:")
-                    ):
-                        logger.error(
-                            f"LLM provider failed during final generation: {synthesized_response_buffer}"
-                        )
-                        if output_format == "audio":
-                            async for chunk in self.llm_provider.tts(
-                                synthesized_response_buffer,
-                                voice=audio_voice,
-                                response_format=audio_output_format,
-                                instructions=audio_instructions,
-                            ):
-                                yield chunk
-                        else:
-                            yield synthesized_response_buffer
-                        return
-
-                    final_response_text = synthesized_response_buffer
-                    logger.info(
-                        f"Final synthesized response length: {len(final_response_text)}"
+                    # Add the tool result to the prompt for the next round
+                    # (You may want to format this differently for your use case)
+                    full_prompt += (
+                        f"\n\nTool '{function_name}' was called with arguments {arguments}.\n"
+                        f"Result: {tool_result}\n"
                     )
+                    continue  # Loop again, LLM will see tool result and may call another tool or finish
 
-                else:
-                    logger.warning(
-                        "Tool markers detected, but no valid tool calls parsed. Treating initial response as final."
-                    )
-                    final_response_text = initial_llm_response_buffer
-            else:
-                final_response_text = initial_llm_response_buffer
-                logger.info("No tools detected. Using initial response as final.")
+                # Otherwise, it's a normal message (final answer)
+                response_text = message.content
+                break
 
-            # --- Final Output Processing (Guardrails, TTS, Yielding) ---
-            processed_final_text = final_response_text
+            # Apply output guardrails if any
+            processed_final_text = response_text
             if self.output_guardrails:
-                logger.info(
-                    f"Applying output guardrails to final text response (length: {len(processed_final_text)})"
-                )
-                original_len = len(processed_final_text)
                 for guardrail in self.output_guardrails:
                     try:
                         processed_final_text = await guardrail.process(
@@ -652,25 +339,13 @@ class AgentService(AgentServiceInterface):
                         logger.error(
                             f"Error applying output guardrail {guardrail.__class__.__name__}: {e}"
                         )
-                if len(processed_final_text) != original_len:
-                    logger.info(
-                        f"Guardrails modified final text length from {original_len} to {len(processed_final_text)}"
-                    )
 
             self.last_text_response = processed_final_text
 
             if output_format == "text":
-                if processed_final_text:
-                    yield processed_final_text
-                else:
-                    logger.warning("Final processed text was empty.")
-                    yield ""
+                yield processed_final_text or ""
             elif output_format == "audio":
-                text_for_tts = processed_final_text
-                cleaned_audio_buffer = self._clean_for_audio(text_for_tts)
-                logger.info(
-                    f"Processing {len(cleaned_audio_buffer)} characters for audio output"
-                )
+                cleaned_audio_buffer = self._clean_for_audio(processed_final_text)
                 if cleaned_audio_buffer:
                     async for audio_chunk in self.llm_provider.tts(
                         text=cleaned_audio_buffer,
@@ -680,14 +355,8 @@ class AgentService(AgentServiceInterface):
                     ):
                         yield audio_chunk
                 else:
-                    logger.warning("Final text for audio was empty after cleaning.")
-
-            logger.info(
-                f"Response generation complete for agent '{agent_name}': {len(self.last_text_response)} final chars"
-            )
-
+                    yield ""
         except Exception as e:
-            # --- Error Handling ---
             import traceback
 
             error_msg = (
@@ -707,166 +376,8 @@ class AgentService(AgentServiceInterface):
             else:
                 yield error_msg
 
-    async def _bytes_to_generator(self, data: bytes) -> AsyncGenerator[bytes, None]:
-        """Convert bytes to an async generator for streaming."""
-        chunk_size = 4096
-        for i in range(0, len(data), chunk_size):
-            yield data[i : i + chunk_size]
-            await asyncio.sleep(0.01)
-
-    async def _handle_tool_call(self, agent_name: str, tool_text: str) -> str:
-        """Handle marker-based tool calls."""
-        try:
-            start_marker = "[TOOL]"
-            end_marker = "[/TOOL]"
-            start_idx = tool_text.find(start_marker) + len(start_marker)
-            end_idx = tool_text.find(end_marker)
-            if start_idx == -1 or end_idx == -1 or end_idx <= start_idx:
-                logger.error(f"Malformed tool call text received: {tool_text}")
-                return "Error: Malformed tool call format."
-
-            tool_content = tool_text[start_idx:end_idx].strip()
-            tool_name = None
-            parameters = {}
-
-            for line in tool_content.split("\n"):
-                line = line.strip()
-                if not line:
-                    continue
-                if line.startswith("name:"):
-                    tool_name = line[5:].strip()
-                elif line.startswith("parameters:"):
-                    params_text = line[11:].strip()
-                    try:
-                        # Attempt to parse as JSON first for robustness
-                        parameters = json.loads(params_text)
-                    except json.JSONDecodeError:
-                        # Fallback to comma-separated key=value pairs
-                        param_pairs = params_text.split(",")
-                        for pair in param_pairs:
-                            if "=" in pair:
-                                k, v = pair.split("=", 1)
-                                parameters[k.strip()] = v.strip()
-                        logger.warning(
-                            f"Parsed tool parameters using fallback method: {params_text}"
-                        )
-
-            if not tool_name:
-                logger.error(f"Tool name missing in tool call: {tool_content}")
-                return "Error: Tool name missing in call."
-
-            result = await self.execute_tool(agent_name, tool_name, parameters)
-
-            if result.get("status") == "success":
-                tool_result = str(result.get("result", ""))
-                return tool_result
-            else:
-                error_msg = f"Error calling {tool_name}: {result.get('message', 'Unknown error')}"
-                logger.error(error_msg)
-                return error_msg
-
-        except Exception as e:
-            import traceback
-
-            logger.error(f"Error processing tool call: {e}\n{traceback.format_exc()}")
-            return f"Error processing tool call: {str(e)}"
-
-    def _get_tool_usage_prompt(self, agent_name: str) -> str:
-        """Generate marker-based instructions for tool usage."""
-        # Only include tools actually assigned to this agent
-        agent_tools = self.tool_registry.get_agent_tools(agent_name)
-        if not agent_tools:
-            return ""
-
-        # Simplify tool representation for the prompt
-        simplified_tools = []
-        for tool in agent_tools:
-            simplified_tool = {
-                "name": tool.get("name"),
-                "description": tool.get("description"),
-                "parameters": tool.get("parameters", {}).get("properties", {}),
-            }
-            simplified_tools.append(simplified_tool)
-
-        tools_json = json.dumps(simplified_tools, indent=2)
-
-        return f"""
-        AVAILABLE TOOLS:
-        {tools_json}
-
-        ⚠️ CRITICAL INSTRUCTIONS FOR TOOL USAGE:
-        1. EXECUTION ORDER MATTERS: If multiple steps are needed (e.g., get information THEN use it), you MUST output the [TOOL] blocks in the exact sequence they need to run. Output the information-gathering tool call FIRST, then the tool call that uses the information.
-        2. ONLY TOOL CALLS: When using a tool, NEVER include explanatory text before or after the tool call block. Only output the exact tool call format shown below.
-        3. USE TOOLS WHEN NEEDED: Always call the necessary tool to give the latest information, especially for time-sensitive queries.
-
-        TOOL USAGE FORMAT:
-        [TOOL]
-        name: tool_name
-        parameters: {{"key1": "value1", "key2": "value2"}}
-        [/TOOL]
-
-        EXAMPLES:
-
-        ✅ CORRECT - Get news THEN email (Correct Order):
-        [TOOL]
-        name: search_internet
-        parameters: {{"query": "latest news on Canada"}}
-        [/TOOL]
-        [TOOL]
-        name: mcp
-        parameters: {{"query": "Send an email to
-                             bob@bob.com with subject
-                             'Friendly Reminder to Clean Your Room'
-                             and body 'Hi Bob, just a friendly
-                             reminder to please clean your room
-                             when you get a chance.'"}}
-        [/TOOL]
-        (Note: The system will handle replacing placeholders like '{{output_of_search_internet}}' if possible, but the ORDER is crucial.)
-
-
-        ❌ INCORRECT - Wrong Order:
-        [TOOL]
-        name: mcp
-        parameters: {{"query": "Send an email to
-                             bob@bob.com with subject
-                             'Friendly Reminder to Clean Your Room'
-                             and body 'Hi Bob, just a friendly
-                             reminder to please clean your room
-                             when you get a chance.'"}}
-        [/TOOL]
-        [TOOL]
-        name: search_internet
-        parameters: {{"query": "latest news on Canada"}}
-        [/TOOL]
-
-
-        ❌ INCORRECT - Explanatory Text:
-        To get the news, I'll search.
-        [TOOL]
-        name: search_internet
-        parameters: {{"query": "latest news on Solana"}}
-        [/TOOL]
-        Now I will email it.
-        [TOOL]
-        name: mcp
-        parameters: {{"query": "Send an email to
-                             bob@bob.com with subject
-                             'Friendly Reminder to Clean Your Room'
-                             and body 'Hi Bob, just a friendly
-                             reminder to please clean your room
-                             when you get a chance.'"}}
-        [/TOOL]
-
-
-        REMEMBER:
-        - Output ONLY the [TOOL] blocks in the correct execution order.
-        - I will execute the tools sequentially as you provide them.
-        - You will receive the results of ALL tool calls before formulating the final response.
-        """
-
     def _clean_for_audio(self, text: str) -> str:
         """Remove Markdown formatting, emojis, and non-pronounceable characters from text."""
-        import re
 
         if not text:
             return ""

{solana_agent-29.2.0.dist-info → solana_agent-29.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: solana-agent
-Version: 29.2.0
+Version: 29.2.1
 Summary: AI Agents for Solana
 License: MIT
 Keywords: solana,solana ai,solana agent,ai,ai agent,ai agents
@@ -41,9 +41,7 @@ Description-Content-Type: text/markdown
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
 [![codecov](https://img.shields.io/codecov/c/github/truemagic-coder/solana-agent/main.svg)](https://codecov.io/gh/truemagic-coder/solana-agent)
 [![Build Status](https://img.shields.io/github/actions/workflow/status/truemagic-coder/solana-agent/ci.yml?branch=main)](https://github.com/truemagic-coder/solana-agent/actions/workflows/ci.yml)
-[![Lines of Code](https://tokei.rs/b1/github/truemagic-coder/solana-agent?type=python&category=code&style=flat)](https://github.com/truemagic-coder/solana-agent)
 [![Ruff Style](https://img.shields.io/badge/style-ruff-41B5BE)](https://github.com/astral-sh/ruff)
-[![Libraries.io dependency status for GitHub repo](https://img.shields.io/librariesio/github/truemagic-coder/solana-agent)](https://libraries.io/pypi/solana-agent)
 
 ![Solana Agent Logo](https://dl.walletbubbles.com/solana-agent-logo.png?width=200)
 

{solana_agent-29.2.0.dist-info → solana_agent-29.2.1.dist-info}/RECORD

@@ -1,7 +1,7 @@
 solana_agent/__init__.py,sha256=g83qhMOCwcWL19V4CYbQwl0Ykpb0xn49OUh05i-pu3g,1001
 solana_agent/adapters/__init__.py,sha256=tiEEuuy0NF3ngc_tGEcRTt71zVI58v3dYY9RvMrF2Cg,204
 solana_agent/adapters/mongodb_adapter.py,sha256=Hq3S8VzfLmnPjV40z8yJXGqUamOJcX5GbOMd-1nNWO4,3175
-solana_agent/adapters/openai_adapter.py,sha256=XnocNAV1nJGcjpRgOyMXnyDQSU8HvTx9zmb4pWtSb58,23432
+solana_agent/adapters/openai_adapter.py,sha256=nKfJzgtxNfQWLp6vcu-2Z8zBbvpYgTOEil7nPH7QIlU,23340
 solana_agent/adapters/pinecone_adapter.py,sha256=XlfOpoKHwzpaU4KZnovO2TnEYbsw-3B53ZKQDtBeDgU,23847
 solana_agent/cli.py,sha256=FGvTIQmKLp6XsQdyKtuhIIfbBtMmcCCXfigNrj4bzMc,4704
 solana_agent/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -17,7 +17,7 @@ solana_agent/interfaces/client/client.py,sha256=hFYe04lFGbp4BDlUMOnYQrp_SQXFPckt
 solana_agent/interfaces/guardrails/guardrails.py,sha256=gZCQ1FrirW-mX6s7FoYrbRs6golsp-x269kk4kQiZzc,572
 solana_agent/interfaces/plugins/plugins.py,sha256=Rz52cWBLdotwf4kV-2mC79tRYlN29zHSu1z9-y1HVPk,3329
 solana_agent/interfaces/providers/data_storage.py,sha256=Y92Cq8BtC55VlsYLD7bo3ofqQabNnlg7Q4H1Q6CDsLU,1713
-solana_agent/interfaces/providers/llm.py,sha256=FbK6HNMBOIONPE-ljPRElkO2fmFbkzWEo4KuYfcDEFE,2727
+solana_agent/interfaces/providers/llm.py,sha256=IBtvl_p2Dd9pzuA6ub6DZRn50Td8f-XMtcc1M4V3gvA,2872
 solana_agent/interfaces/providers/memory.py,sha256=h3HEOwWCiFGIuFBX49XOv1jFaQW3NGjyKPOfmQloevk,1011
 solana_agent/interfaces/providers/vector_storage.py,sha256=XPYzvoWrlDVFCS9ItBmoqCFWXXWNYY-d9I7_pvP7YYk,1561
 solana_agent/interfaces/services/agent.py,sha256=MgLudTwzCzzzSR6PsVTB-w5rhGDHB5B81TGjo2z3G-A,2152
@@ -32,12 +32,12 @@ solana_agent/plugins/tools/auto_tool.py,sha256=uihijtlc9CCqCIaRcwPuuN7o1SHIpWL2G
 solana_agent/repositories/__init__.py,sha256=fP83w83CGzXLnSdq-C5wbw9EhWTYtqE2lQTgp46-X_4,163
 solana_agent/repositories/memory.py,sha256=SKQJJisrERccqd4cm4ERlp5BmKHVQAp1fzp8ce4i2bw,8377
 solana_agent/services/__init__.py,sha256=iko0c2MlF8b_SA_nuBGFllr2E3g_JowOrOzGcnU9tkA,162
-solana_agent/services/agent.py,sha256=0zehiZyTw91IQ_nskxYZF8plecA66m5rD-OA7Cr1Xq8,42462
+solana_agent/services/agent.py,sha256=q5cYzY6Jp5HFtYgJtrqTBWp5Z2n3dXdpQ5YScSKfvPo,18056
 solana_agent/services/knowledge_base.py,sha256=ZvOPrSmcNDgUzz4bJIQ4LeRl9vMZiK9hOfs71IpB7Bk,32735
 solana_agent/services/query.py,sha256=ENUfs4WSTpODMRXppDVW-Y3li9jYn8pOfQIHIPerUdQ,18498
 solana_agent/services/routing.py,sha256=C5Ku4t9TqvY7S8wlUPMTC04HCrT4Ib3E8Q8yX0lVU_s,7137
-solana_agent-29.2.0.dist-info/LICENSE,sha256=BnSRc-NSFuyF2s496l_4EyrwAP6YimvxWcjPiJ0J7g4,1057
-solana_agent-29.2.0.dist-info/METADATA,sha256=7GiWgj6IbAnxg-xP5kvROu_qUFYK7ZUcf3H-w84My_o,35946
-solana_agent-29.2.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-solana_agent-29.2.0.dist-info/entry_points.txt,sha256=-AuT_mfqk8dlZ0pHuAjx1ouAWpTRjpqvEUa6YV3lmc0,53
-solana_agent-29.2.0.dist-info/RECORD,,
+solana_agent-29.2.1.dist-info/LICENSE,sha256=BnSRc-NSFuyF2s496l_4EyrwAP6YimvxWcjPiJ0J7g4,1057
+solana_agent-29.2.1.dist-info/METADATA,sha256=5yfqF9bxgPvHMjsxgor_vHhpmnRHODY8N3IQ4QgexQU,35620
+solana_agent-29.2.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+solana_agent-29.2.1.dist-info/entry_points.txt,sha256=-AuT_mfqk8dlZ0pHuAjx1ouAWpTRjpqvEUa6YV3lmc0,53
+solana_agent-29.2.1.dist-info/RECORD,,