tinyagent-py 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

tinyagent_py-0.0.3.dist-info/RECORD

@@ -0,0 +1,17 @@
+hooks/__init__.py,sha256=UztCHjoqF5JyDolbWwkBsBZkWguDQg23l2GD_zMHt-s,178
+hooks/agno_storage_hook.py,sha256=5qvvjmtraanPa-A46Zstrqq3s1e-sC7Ly0o3zifuw_4,5003
+hooks/gradio_callback.py,sha256=jGsZlObAd6I5lN9cE53dDL_LfiB8I0tBsicuHwwmL-M,44833
+hooks/logging_manager.py,sha256=UpdmpQ7HRPyer-jrmQSXcBwi409tV9LnGvXSHjTcYTI,7935
+hooks/rich_ui_callback.py,sha256=5iCNOiJmhc1lOL7ZjaOt5Sk3rompko4zu_pAxfTVgJQ,22897
+storage/__init__.py,sha256=NebvYxwEGJtvPnRO9dGa-bgOwA7cPkLjFHnMWDxMg5I,261
+storage/agno_storage.py,sha256=ol4qwdH-9jYjBjDvsYkHh7I-vu8uHArPtQylUpoEaCc,4322
+storage/base.py,sha256=GGAMvOoslmm1INLFG_jtwOkRk2Qg39QXx-1LnN7fxDI,1474
+storage/json_file_storage.py,sha256=SYD8lvTHu2-FEHm1tZmsrcgEOirBrlUsUM186X-UPgI,1114
+storage/postgres_storage.py,sha256=IGwan8UXHNnTZFK1F8x4kvMDex3GAAGWUg9ePx_5IF4,9018
+storage/redis_storage.py,sha256=hu3y7wHi49HkpiR-AW7cWVQuTVOUk1WaB8TEPGUKVJ8,1742
+storage/sqlite_storage.py,sha256=7lk1XZpr2t4s2bjVr9-AqrI74w4hwkuK3taWtyJZhBc,5769
+tinyagent_py-0.0.3.dist-info/licenses/LICENSE,sha256=YIogcVQnknaaE4K-oaQylFWo8JGRBWnwmGb3fWB_Pww,1064
+tinyagent_py-0.0.3.dist-info/METADATA,sha256=KPHCk1QjAfTE9HPwChyJr5e1s9ukQ2rJi0YxQTWwESk,7050
+tinyagent_py-0.0.3.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+tinyagent_py-0.0.3.dist-info/top_level.txt,sha256=PfpFqZliMhzue7YU7RrBiZGoAqVBPr9sRc310dWabug,14
+tinyagent_py-0.0.3.dist-info/RECORD,,

{tinyagent_py-0.0.1.dist-info → tinyagent_py-0.0.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.3.1)
+Generator: setuptools (80.7.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

tinyagent_py-0.0.3.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+hooks
+storage

tinyagent/__init__.py

@@ -1,4 +0,0 @@
-from .tiny_agent import TinyAgent
-from .mcp_client import MCPClient
-
-__all__ = ["TinyAgent", "MCPClient"]

tinyagent/mcp_client.py

@@ -1,52 +0,0 @@
-import asyncio
-import json
-import logging
-from typing import Dict, List, Optional, Any, Tuple
-
-# Keep your MCPClient implementation unchanged
-import asyncio
-from contextlib import AsyncExitStack
-
-# MCP core imports
-from mcp import ClientSession, StdioServerParameters
-from mcp.client.stdio import stdio_client
-
-class MCPClient:
-    def __init__(self):
-        self.session = None
-        self.exit_stack = AsyncExitStack()
-
-    async def connect(self, command: str, args: list[str]):
-        """
-        Launches the MCP server subprocess and initializes the client session.
-        :param command: e.g. "python" or "node"
-        :param args: list of args to pass, e.g. ["my_server.py"] or ["build/index.js"]
-        """
-        # Prepare stdio transport parameters
-        params = StdioServerParameters(command=command, args=args)
-        # Open the stdio client transport
-        self.stdio, self.sock_write = await self.exit_stack.enter_async_context(
-            stdio_client(params)
-        )
-        # Create and initialize the MCP client session
-        self.session = await self.exit_stack.enter_async_context(
-            ClientSession(self.stdio, self.sock_write)
-        )
-        await self.session.initialize()
-
-    async def list_tools(self):
-        resp = await self.session.list_tools()
-        print("Available tools:")
-        for tool in resp.tools:
-            print(f" • {tool.name}: {tool.description}")
-
-    async def call_tool(self, name: str, arguments: dict):
-        """
-        Invokes a named tool and returns its raw content list.
-        """
-        resp = await self.session.call_tool(name, arguments)
-        return resp.content
-
-    async def close(self):
-        # Clean up subprocess and streams
-        await self.exit_stack.aclose()

tinyagent/tiny_agent.py

@@ -1,247 +0,0 @@
-# Import LiteLLM for model interaction
-import litellm
-import json
-import logging
-from typing import Dict, List, Optional, Any, Tuple
-from .mcp_client import MCPClient
-
-# Set up logging
-logging.basicConfig(level=logging.DEBUG)
-logger = logging.getLogger(__name__)
-#litellm.callbacks = ["arize_phoenix"]
-
-
-
-class TinyAgent:
-    """
-    A minimal implementation of an agent powered by MCP and LiteLLM.
-    This agent is literally just a while loop on top of MCPClient.
-    """
-    
-    def __init__(self, model: str = "gpt-4o", api_key: Optional[str] = None, system_prompt: Optional[str] = None):
-        """
-        Initialize the Tiny Agent.
-        
-        Args:
-            model: The model to use with LiteLLM
-            api_key: The API key for the model provider
-            system_prompt: Custom system prompt for the agent
-        """
-        # Create the MCPClient
-        self.mcp_client = MCPClient()
-        
-        # LiteLLM configuration
-        self.model = model
-        self.api_key = api_key
-        if api_key:
-            litellm.api_key = api_key
-            
-        # Conversation state
-        self.messages = [{
-            "role": "system",
-            "content": system_prompt or (
-                "You are a helpful AI assistant with access to a variety of tools. "
-                "Use the tools when appropriate to accomplish tasks. "
-                "If a tool you need isn't available, just say so."
-            )
-        }]
-        
-        # Available tools (will be populated after connecting to MCP servers)
-        self.available_tools = []
-        
-        # Control flow tools
-        self.exit_loop_tools = [
-            {
-                "type": "function",
-                "function": {
-                    "name": "task_complete",
-                    "description": "Call this tool when the task given by the user is complete",
-                    "parameters": {"type": "object", "properties": {}}
-                }
-            },
-            {
-                "type": "function",
-                "function": {
-                    "name": "ask_question",
-                    "description": "Ask a question to the user to get more info required to solve or clarify their problem.",
-                    "parameters": {
-                        "type": "object",
-                        "properties": {
-                            "question": {
-                                "type": "string",
-                                "description": "The question to ask the user"
-                            }
-                        },
-                        "required": ["question"]
-                    }
-                }
-            }
-        ]
-    
-    async def connect_to_server(self, command: str, args: List[str]) -> None:
-        """
-        Connect to an MCP server and fetch available tools.
-        
-        Args:
-            command: The command to run the server
-            args: List of arguments for the server
-        """
-        await self.mcp_client.connect(command, args)
-        
-        # Get available tools from the server and format them for LiteLLM
-        resp = await self.mcp_client.session.list_tools()
-        
-        tool_descriptions = []
-        for tool in resp.tools:
-            tool_descriptions.append({
-                "type": "function",
-                "function": {
-                    "name": tool.name,
-                    "description": tool.description,
-                    "parameters": tool.inputSchema
-                }
-            })
-        
-        logger.info(f"Added {len(tool_descriptions)} tools from MCP server")
-        self.available_tools.extend(tool_descriptions)
-    
-    async def run(self, user_input: str, max_turns: int = 10) -> str:
-        """
-        Run the agent with user input.
-        
-        Args:
-            user_input: The user's request
-            max_turns: Maximum number of turns before giving up
-            
-        Returns:
-            The final agent response
-        """
-        # Add user message to conversation
-        self.messages.append({"role": "user", "content": user_input})
-        
-        # Initialize loop control variables
-        num_turns = 0
-        next_turn_should_call_tools = True
-        
-        # The main agent loop
-        while True:
-            # Get all available tools including exit loop tools
-            all_tools = self.available_tools + self.exit_loop_tools
-            
-            # Call LLM with messages and tools
-            try:
-                logger.info(f"Calling LLM with {len(self.messages)} messages and {len(all_tools)} tools")
-                response = await litellm.acompletion(
-                    model=self.model,
-                    messages=self.messages,
-                    tools=all_tools,
-                    tool_choice="auto"
-                )
-                
-                # Process the response - properly handle the object
-                response_message = response.choices[0].message
-                logger.debug(f"🔥🔥🔥🔥🔥🔥 Response : {response_message}")
-                
-                # Create a proper message dictionary from the response object's attributes
-                assistant_message = {
-                    "role": "assistant",
-                    "content": response_message.content if hasattr(response_message, "content") else ""
-                }
-                
-                # Check if the message has tool_calls attribute and it's not empty
-                has_tool_calls = hasattr(response_message, "tool_calls") and response_message.tool_calls
-                
-                if has_tool_calls:
-                    # Add tool_calls to the message if present
-                    assistant_message["tool_calls"] = response_message.tool_calls
-                
-                # Add the properly formatted assistant message to conversation
-                self.messages.append(assistant_message)
-                
-                # Process tool calls if they exist
-                if has_tool_calls:
-                    tool_calls = response_message.tool_calls
-                    logger.info(f"Tool calls detected: {len(tool_calls)}")
-                    
-                    # Process each tool call one by one
-                    for tool_call in tool_calls:
-                        tool_call_id = tool_call.id
-                        function_info = tool_call.function
-                        tool_name = function_info.name
-                        
-                        # Create a tool message
-                        tool_message = {
-                            "role": "tool",
-                            "tool_call_id": tool_call_id,
-                            "name": tool_name,
-                            "content": ""  # Default empty content
-                        }
-                        
-                        try:
-                            # Parse tool arguments
-                            try:
-                                tool_args = json.loads(function_info.arguments)
-                            except json.JSONDecodeError:
-                                logger.error(f"Could not parse tool arguments: {function_info.arguments}")
-                                tool_args = {}
-                            
-                            # Handle control flow tools
-                            if tool_name == "task_complete":
-                                # Add a response for this tool call before returning
-                                tool_message["content"] = "Task has been completed successfully."
-                                self.messages.append(tool_message)
-                                return "Task completed."
-                            elif tool_name == "ask_question":
-                                question = tool_args.get("question", "Could you provide more details?")
-                                # Add a response for this tool call before returning
-                                tool_message["content"] = f"Question asked: {question}"
-                                self.messages.append(tool_message)
-                                return f"I need more information: {question}"
-                            else:
-                                # Call the actual tool using MCPClient
-                                try:
-                                    content_list = await self.mcp_client.call_tool(tool_name, tool_args)
-                                    
-                                    # Safely extract text from the content
-                                    if content_list:
-                                        # Try different ways to extract the content
-                                        if hasattr(content_list[0], 'text'):
-                                            tool_message["content"] = content_list[0].text
-                                        elif isinstance(content_list[0], dict) and 'text' in content_list[0]:
-                                            tool_message["content"] = content_list[0]['text']
-                                        else:
-                                            tool_message["content"] = str(content_list)
-                                    else:
-                                        tool_message["content"] = "Tool returned no content"
-                                except Exception as e:
-                                    logger.error(f"Error calling tool {tool_name}: {str(e)}")
-                                    tool_message["content"] = f"Error executing tool {tool_name}: {str(e)}"
-                        except Exception as e:
-                            # If any error occurs during tool call processing, make sure we still have a tool response
-                            logger.error(f"Unexpected error processing tool call {tool_call_id}: {str(e)}")
-                            tool_message["content"] = f"Error processing tool call: {str(e)}"
-                        
-                        # Always add the tool message to ensure each tool call has a response
-                        self.messages.append(tool_message)
-                    
-                    next_turn_should_call_tools = False
-                else:
-                    # No tool calls in this message
-                    if next_turn_should_call_tools and num_turns > 0:
-                        # If we expected tool calls but didn't get any, we're done
-                        return assistant_message["content"] or ""
-                    
-                    next_turn_should_call_tools = True
-                
-                num_turns += 1
-                if num_turns >= max_turns:
-                    return "Max turns reached. Task incomplete."
-                
-            except Exception as e:
-                logger.error(f"Error in agent loop: {str(e)}")
-                return f"Error: {str(e)}"
-
-    
-    async def close(self):
-        """Clean up resources."""
-        await self.mcp_client.close()

tinyagent_py-0.0.1.dist-info/METADATA

@@ -1,79 +0,0 @@
-Metadata-Version: 2.4
-Name: tinyagent-py
-Version: 0.0.1
-Summary: Tiny Agent with MCP Client
-Author-email: Mahdi Golchin <golchin@askdev.ai>
-License: MIT
-Project-URL: Homepage, https://github.com/askbudi/tinyagent
-Project-URL: Bug Tracker, https://github.com/askbudi/tinyagent/issues
-Project-URL: Chat, https://askdev.ai/github/askbudi/tinyagent
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: mcp
-Requires-Dist: litellm
-Requires-Dist: openai
-Provides-Extra: dev
-Requires-Dist: pytest; extra == "dev"
-Dynamic: license-file
-
-# tinyagent
-Tiny Agent: 100 lines Agent with MCP
-
-Inspired by:
-- [Tiny Agents blog post](https://huggingface.co/blog/tiny-agents)
-- [12-factor-agents repository](https://github.com/humanlayer/12-factor-agents)
-- Created by chatting to the source code of JS Tiny Agent using [AskDev.ai](https://askdev.ai/search)
-
-## Quick Links
-- [Build your own Tiny Agent](https://askdev.ai/github/askbudi/tinyagent)
-
-## Overview
-This is a tiny agent that uses MCP and LiteLLM to interact with a model. You have full control over the agent, you can add any tools you like from MCP and extend the agent using its event system.
-
-## Installation
-
-### Using pip
-```bash
-pip install tinyagent
-```
-
-### Using uv
-```bash
-uv pip install tinyagent
-```
-
-## Usage
-
-```python
-from tinyagent import TinyAgent
-from textwrap import dedent
-import asyncio
-import os
-
-async def test_agent(task, model="o4-mini", api_key=None):
-    # Initialize the agent with model and API key
-    agent = TinyAgent(
-        model=model,  # Or any model supported by LiteLLM
-        api_key=os.environ.get("OPENAI_API_KEY") if not api_key else api_key  # Set your API key as an env variable
-    )
-    
-    try:
-        # Connect to an MCP server
-        # Replace with your actual server command and args
-        await agent.connect_to_server("npx", ["@openbnb/mcp-server-airbnb", "--ignore-robots-txt"])
-        
-        # Run the agent with a user query
-        result = await agent.run(task)
-        print("\nFinal result:", result)
-        return result
-    finally:
-        # Clean up resources
-        await agent.close()
-
-# Example usage
-task = dedent("""
-I need accommodation in Toronto between 15th to 20th of May. Give me 5 options for 2 adults.
-""")
-await test_agent(task, model="gpt-4.1-mini")
-```

tinyagent_py-0.0.1.dist-info/RECORD

@@ -1,8 +0,0 @@
-tinyagent/__init__.py,sha256=V3nU-BA-Ddi8ErLJ5CoYsdRZpV2l-vIE5D5e1nrXhI8,105
-tinyagent/mcp_client.py,sha256=vVzItP9fI5khxq8O4HZwNIyo3nv0_7ITWw7GB2tbTyg,1776
-tinyagent/tiny_agent.py,sha256=ORVb1ipSXJ09A2tTBqrtdoikGuYu8P6o-zZg6Ra6CRA,10990
-tinyagent_py-0.0.1.dist-info/licenses/LICENSE,sha256=YIogcVQnknaaE4K-oaQylFWo8JGRBWnwmGb3fWB_Pww,1064
-tinyagent_py-0.0.1.dist-info/METADATA,sha256=puT81QO-JHyF15KO1yQPsz7cBxEgFMY1FzPEgJuh5Jk,2335
-tinyagent_py-0.0.1.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-tinyagent_py-0.0.1.dist-info/top_level.txt,sha256=Ny8aJNchZpc2Vvhp3306L5vjceJakvFxBk-UjjVeA_I,10
-tinyagent_py-0.0.1.dist-info/RECORD,,

tinyagent_py-0.0.1.dist-info/top_level.txt

@@ -1 +0,0 @@
-tinyagent