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

tinyagent_py-0.0.4.dist-info/METADATA

@@ -0,0 +1,252 @@
+Metadata-Version: 2.4
+Name: tinyagent-py
+Version: 0.0.4
+Summary: Tiny Agent with MCP Client
+Author-email: Mahdi Golchin <golchin@askdev.ai>
+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
+Requires-Dist: tiktoken
+Requires-Dist: uuid
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Provides-Extra: postgres
+Requires-Dist: asyncpg>=0.27.0; extra == "postgres"
+Provides-Extra: sqlite
+Requires-Dist: aiosqlite>=0.18.0; extra == "sqlite"
+Provides-Extra: gradio
+Requires-Dist: gradio>=3.50.0; extra == "gradio"
+Provides-Extra: all
+Requires-Dist: asyncpg>=0.27.0; extra == "all"
+Requires-Dist: aiosqlite>=0.18.0; extra == "all"
+Requires-Dist: gradio>=3.50.0; extra == "all"
+Dynamic: license-file
+
+# tinyagent
+Tiny Agent: 100 lines Agent with MCP
+![TinyAgent Logo](https://raw.githubusercontent.com/askbudi/tinyagent/main/public/logo.png)
+
+
+
+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
+# Basic installation
+pip install tinyagent-py
+
+# Install with all optional dependencies
+pip install tinyagent-py[all]
+
+# Install with PostgreSQL support
+pip install tinyagent-py[postgres]
+
+# Install with SQLite support
+pip install tinyagent-py[sqlite]
+
+# Install with Gradio UI support
+pip install tinyagent-py[gradio]
+
+```
+
+### Using uv
+```bash
+# Basic installation
+uv pip install tinyagent-py
+
+# Install with PostgreSQL support
+uv pip install tinyagent-py[postgres]
+
+# Install with SQLite support
+uv pip install tinyagent-py[sqlite]
+
+# Install with Gradio UI support
+uv pip install tinyagent-py[gradio]
+
+# Install with all optional dependencies
+uv pip install tinyagent-py[all]
+
+# Install with development tools
+uv pip install tinyagent-py[dev]
+```
+
+## 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")
+```
+
+## How the TinyAgent Hook System Works
+
+TinyAgent is designed to be **extensible** via a simple, event-driven hook (callback) system. This allows you to add custom logic, logging, UI, memory, or any other behavior at key points in the agent's lifecycle.
+
+### How Hooks Work
+
+- **Hooks** are just callables (functions or classes with `__call__`) that receive events from the agent.
+- You register hooks using `agent.add_callback(hook)`.
+- Hooks are called with:  
+  `event_name, agent, **kwargs`
+- Events include:  
+  - `"agent_start"`: Agent is starting a new run
+  - `"message_add"`: A new message is added to the conversation
+  - `"llm_start"`: LLM is about to be called
+  - `"llm_end"`: LLM call finished
+  - `"agent_end"`: Agent is done (final result)
+  - (MCPClient also emits `"tool_start"` and `"tool_end"` for tool calls)
+
+Hooks can be **async** or regular functions. If a hook is a class with an async `__call__`, it will be awaited.
+
+#### Example: Adding a Custom Hook
+
+```python
+def my_logger_hook(event_name, agent, **kwargs):
+    print(f"[{event_name}] {kwargs}")
+
+agent.add_callback(my_logger_hook)
+```
+
+#### Example: Async Hook
+
+```python
+async def my_async_hook(event_name, agent, **kwargs):
+    if event_name == "agent_end":
+        print("Agent finished with result:", kwargs.get("result"))
+
+agent.add_callback(my_async_hook)
+```
+
+#### Example: Class-based Hook
+
+```python
+class MyHook:
+    async def __call__(self, event_name, agent, **kwargs):
+        if event_name == "llm_start":
+            print("LLM is starting...")
+
+agent.add_callback(MyHook())
+```
+
+### How to Extend the Hook System
+
+- **Create your own hook**: Write a function or class as above.
+- **Register it**: Use `agent.add_callback(your_hook)`.
+- **Listen for events**: Check `event_name` and use `**kwargs` for event data.
+- **See examples**: Each official hook (see below) includes a `run_example()` in its file.
+
+---
+
+## List of Available Hooks
+
+You can import and use these hooks from `tinyagent.hooks`:
+
+| Hook Name                | Description                                      | Example Import                                  |
+|--------------------------|--------------------------------------------------|-------------------------------------------------|
+| `LoggingManager`         | Granular logging control for all modules         | `from tinyagent.hooks.logging_manager import LoggingManager` |
+| `RichUICallback`         | Rich terminal UI (with [rich](https://github.com/Textualize/rich)) | `from tinyagent.hooks.rich_ui_callback import RichUICallback` |
+| `GradioCallback` | Interactive browser-based chat UI: file uploads, live thinking, tool calls, token stats | `from tinyagent.hooks.gradio_callback import GradioCallback`         |
+
+To see more details and usage, check the docstrings and `run_example()` in each hook file.
+
+## Using the GradioCallback Hook
+
+The `GradioCallback` hook lets you spin up a full-featured web chat interface for your agent in just a few lines. You get:
+
+Features:
+- **Browser-based chat** with streaming updates  
+- **File uploads** (\*.pdf, \*.docx, \*.txt) that the agent can reference  
+- **Live "thinking" view** so you see intermediate thoughts  
+- **Collapsible tool-call sections** showing inputs & outputs  
+- **Real-time token usage** (prompt, completion, total)  
+- **Toggleable display options** for thinking & tool calls  
+- **Non-blocking launch** for asyncio apps (`prevent_thread_lock=True`)
+
+```python
+import asyncio
+from tinyagent import TinyAgent
+from tinyagent.hooks.gradio_callback import GradioCallback
+async def main():
+    # 1. Initialize your agent
+    agent = TinyAgent(model="gpt-4.1-mini", api_key="YOUR_API_KEY")
+    # 2. (Optional) Add tools or connect to MCP servers
+    # await agent.connect_to_server("npx", ["-y","@openbnb/mcp-server-airbnb","--ignore-robots-txt"])
+    # 3. Instantiate the Gradio UI callback
+    gradio_ui = GradioCallback(
+    file_upload_folder="uploads/",
+    show_thinking=True,
+    show_tool_calls=True
+    )
+    # 4. Register the callback with the agent
+    agent.add_callback(gradio_ui)
+    # 5. Launch the web interface (non-blocking)
+    gradio_ui.launch(
+    agent,
+    title="TinyAgent Chat",
+    description="Ask me to plan a trip or fetch data!",
+    share=False,
+    prevent_thread_lock=True
+    )
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+---
+
+## Contributing Hooks
+
+- Place new hooks in the `tinyagent/hooks/` directory.
+- Add an example usage as `async def run_example()` in the same file.
+- Use `"gpt-4.1-mini"` as the default model in examples.
+
+---
+
+## License
+
+MIT License. See [LICENSE](LICENSE).

tinyagent_py-0.0.4.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.4.dist-info/licenses/LICENSE,sha256=YIogcVQnknaaE4K-oaQylFWo8JGRBWnwmGb3fWB_Pww,1064
+tinyagent_py-0.0.4.dist-info/METADATA,sha256=MDvRoleb36ya8z44BxQvtgSFJ_-WfH5kv7eSWeaMdJQ,8254
+tinyagent_py-0.0.4.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+tinyagent_py-0.0.4.dist-info/top_level.txt,sha256=PfpFqZliMhzue7YU7RrBiZGoAqVBPr9sRc310dWabug,14
+tinyagent_py-0.0.4.dist-info/RECORD,,

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

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

tinyagent_py-0.0.4.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