tinyagent-py 0.0.13__py3-none-any.whl → 0.0.15__py3-none-any.whl

tinyagent/tiny_agent.py

@@ -12,10 +12,21 @@ import uuid
 from .storage import Storage    # ← your abstract base
 import traceback
 import time  # Add time import for Unix timestamps
+from pathlib import Path
+
 # Module-level logger; configuration is handled externally.
 logger = logging.getLogger(__name__)
 #litellm.callbacks = ["arize_phoenix"]
 
+def load_template(path: str,key:str="system_prompt") -> str:
+    """
+    Load the YAML file and extract its 'system_prompt' field.
+    """
+    import yaml
+    with open(path, "r") as f:
+        data = yaml.safe_load(f)
+    return data[key]
+
 def tool(name: Optional[str] = None, description: Optional[str] = None, 
          schema: Optional[Dict[str, Any]] = None):
     """
@@ -39,6 +50,11 @@ def tool(name: Optional[str] = None, description: Optional[str] = None,
         # Get the description (use provided description or docstring)
         tool_description = description or inspect.getdoc(func_or_class) or f"Tool based on {tool_name}"
         
+        # Temporarily attach the description to the function/class
+        # This allows _generate_schema_from_function to access it for param extraction
+        if description:
+            func_or_class._temp_tool_description = description
+        
         # Generate schema if not provided
         tool_schema = schema or {}
         if not tool_schema:
@@ -50,6 +66,10 @@ def tool(name: Optional[str] = None, description: Optional[str] = None,
                 # For functions, use the function itself
                 tool_schema = _generate_schema_from_function(func_or_class)
         
+        # Clean up temporary attribute
+        if hasattr(func_or_class, '_temp_tool_description'):
+            delattr(func_or_class, '_temp_tool_description')
+        
         # Attach metadata to the function or class
         func_or_class._tool_metadata = {
             "name": tool_name,
@@ -76,6 +96,65 @@ def _generate_schema_from_function(func: Callable) -> Dict[str, Any]:
     sig = inspect.signature(func)
     type_hints = get_type_hints(func)
     
+    # Extract parameter descriptions from docstring
+    param_descriptions = {}
+    
+    # First check if we have a tool decorator description (has higher priority)
+    decorator_description = None
+    if hasattr(func, '_temp_tool_description'):
+        decorator_description = func._temp_tool_description
+    
+    # Get function docstring
+    docstring = inspect.getdoc(func) or ""
+    
+    # Combine sources to check for parameter descriptions
+    sources_to_check = []
+    if decorator_description:
+        sources_to_check.append(decorator_description)
+    if docstring:
+        sources_to_check.append(docstring)
+    
+    # Parse parameter descriptions from all sources
+    for source in sources_to_check:
+        lines = source.split('\n')
+        in_args_section = False
+        current_param = None
+        
+        for line in lines:
+            line = line.strip()
+            
+            # Check for Args/Parameters section markers
+            if line.lower() in ('args:', 'arguments:', 'parameters:'):
+                in_args_section = True
+                continue
+                
+            # Check for other section markers that would end the args section
+            if line.lower() in ('returns:', 'raises:', 'yields:', 'examples:') and in_args_section:
+                in_args_section = False
+                
+            # Look for :param or :arg style parameter descriptions
+            if line.startswith((":param", ":arg")):
+                try:
+                    # e.g., ":param user_id: The ID of the user."
+                    parts = line.split(" ", 2)
+                    if len(parts) >= 3:
+                        param_name = parts[1].strip().split(" ")[0]
+                        param_descriptions[param_name] = parts[2].strip()
+                except (ValueError, IndexError):
+                    continue
+                    
+            # Look for indented parameter descriptions in Args section
+            elif in_args_section and line.strip():
+                # Check for param: description pattern
+                param_match = line.lstrip().split(":", 1)
+                if len(param_match) == 2:
+                    param_name = param_match[0].strip()
+                    description = param_match[1].strip()
+                    param_descriptions[param_name] = description
+                    current_param = param_name
+                # Check for continued description from previous param
+                elif current_param and line.startswith((' ', '\t')):
+                    param_descriptions[current_param] += " " + line.strip()
     # Skip 'self' parameter for methods
     params = {
         name: param for name, param in sig.parameters.items() 
@@ -91,9 +170,12 @@ def _generate_schema_from_function(func: Callable) -> Dict[str, Any]:
         param_type = type_hints.get(name, Any)
         
         # Create property schema
-        prop_schema = {"description": ""}
+        prop_schema = {}
+        description = param_descriptions.get(name)
+        if description:
+            prop_schema["description"] = description
         
-        # Map Python types to JSON schema types
+        # Handle different types of type annotations
         if param_type == str:
             prop_schema["type"] = "string"
         elif param_type == int:
@@ -107,7 +189,113 @@ def _generate_schema_from_function(func: Callable) -> Dict[str, Any]:
         elif param_type == dict or param_type == Dict:
             prop_schema["type"] = "object"
         else:
-            prop_schema["type"] = "string"  # Default to string for complex types
+            # Handle generic types
+            origin = getattr(param_type, "__origin__", None)
+            args = getattr(param_type, "__args__", None)
+            
+            if origin is not None and args is not None:
+                # Handle List[X], Sequence[X], etc.
+                if origin in (list, List) or (hasattr(origin, "__name__") and "List" in origin.__name__):
+                    prop_schema["type"] = "array"
+                    # Add items type if we can determine it
+                    if args and len(args) == 1:
+                        item_type = args[0]
+                        if item_type == str:
+                            prop_schema["items"] = {"type": "string"}
+                        elif item_type == int:
+                            prop_schema["items"] = {"type": "integer"}
+                        elif item_type == float:
+                            prop_schema["items"] = {"type": "number"}
+                        elif item_type == bool:
+                            prop_schema["items"] = {"type": "boolean"}
+                        else:
+                            prop_schema["items"] = {"type": "string"}
+                
+                # Handle Dict[K, V], Mapping[K, V], etc.
+                elif origin in (dict, Dict) or (hasattr(origin, "__name__") and "Dict" in origin.__name__):
+                    prop_schema["type"] = "object"
+                    # We could add additionalProperties for value type, but it's not always needed
+                    if args and len(args) == 2:
+                        value_type = args[1]
+                        if value_type == str:
+                            prop_schema["additionalProperties"] = {"type": "string"}
+                        elif value_type == int:
+                            prop_schema["additionalProperties"] = {"type": "integer"}
+                        elif value_type == float:
+                            prop_schema["additionalProperties"] = {"type": "number"}
+                        elif value_type == bool:
+                            prop_schema["additionalProperties"] = {"type": "boolean"}
+                        else:
+                            prop_schema["additionalProperties"] = {"type": "string"}
+                
+                # Handle Union types (Optional is Union[T, None])
+                elif origin is Union:
+                    # Check if this is Optional[X] (Union[X, None])
+                    if type(None) in args:
+                        # Get the non-None type
+                        non_none_types = [arg for arg in args if arg is not type(None)]
+                        if non_none_types:
+                            # Use the first non-None type
+                            main_type = non_none_types[0]
+                            # Recursively process this type
+                            if main_type == str:
+                                prop_schema["type"] = "string"
+                            elif main_type == int:
+                                prop_schema["type"] = "integer"
+                            elif main_type == float:
+                                prop_schema["type"] = "number"
+                            elif main_type == bool:
+                                prop_schema["type"] = "boolean"
+                            elif main_type == list or main_type == List:
+                                prop_schema["type"] = "array"
+                            elif main_type == dict or main_type == Dict:
+                                prop_schema["type"] = "object"
+                            else:
+                                # Try to handle generic types like List[str]
+                                inner_origin = getattr(main_type, "__origin__", None)
+                                inner_args = getattr(main_type, "__args__", None)
+                                
+                                if inner_origin is not None and inner_args is not None:
+                                    if inner_origin in (list, List) or (hasattr(inner_origin, "__name__") and "List" in inner_origin.__name__):
+                                        prop_schema["type"] = "array"
+                                        if inner_args and len(inner_args) == 1:
+                                            inner_item_type = inner_args[0]
+                                            if inner_item_type == str:
+                                                prop_schema["items"] = {"type": "string"}
+                                            elif inner_item_type == int:
+                                                prop_schema["items"] = {"type": "integer"}
+                                            elif inner_item_type == float:
+                                                prop_schema["items"] = {"type": "number"}
+                                            elif inner_item_type == bool:
+                                                prop_schema["items"] = {"type": "boolean"}
+                                            else:
+                                                prop_schema["items"] = {"type": "string"}
+                                    elif inner_origin in (dict, Dict) or (hasattr(inner_origin, "__name__") and "Dict" in inner_origin.__name__):
+                                        prop_schema["type"] = "object"
+                                        # Add additionalProperties for value type
+                                        if inner_args and len(inner_args) == 2:
+                                            value_type = inner_args[1]
+                                            if value_type == str:
+                                                prop_schema["additionalProperties"] = {"type": "string"}
+                                            elif value_type == int:
+                                                prop_schema["additionalProperties"] = {"type": "integer"}
+                                            elif value_type == float:
+                                                prop_schema["additionalProperties"] = {"type": "number"}
+                                            elif value_type == bool:
+                                                prop_schema["additionalProperties"] = {"type": "boolean"}
+                                            else:
+                                                prop_schema["additionalProperties"] = {"type": "string"}
+                                    else:
+                                        prop_schema["type"] = "string"  # Default for complex types
+                                else:
+                                    prop_schema["type"] = "string"  # Default for complex types
+                    else:
+                        # For non-Optional Union types, default to string
+                        prop_schema["type"] = "string"
+                else:
+                    prop_schema["type"] = "string"  # Default for other complex types
+            else:
+                prop_schema["type"] = "string"  # Default to string for complex types
         
         properties[name] = prop_schema
         
@@ -132,6 +320,13 @@ DEFAULT_SYSTEM_PROMPT = (
     "If a tool you need isn't available, just say so."
 )
 
+DEFAULT_SUMMARY_SYSTEM_PROMPT = (
+    "You are an expert assistant. Your goal is to generate a concise, structured summary "
+    "of the conversation below that captures all essential information needed to continue "
+    "development after context replacement. Include tasks performed, code areas modified or "
+    "reviewed, key decisions or assumptions, test results or errors, and outstanding tasks or next steps."
+)
+
 class TinyAgent:
     """
     A minimal implementation of an agent powered by MCP and LiteLLM,
@@ -154,7 +349,8 @@ class TinyAgent:
         session_id: Optional[str] = None,
         metadata: Optional[Dict[str, Any]] = None,
         storage: Optional[Storage] = None,
-        persist_tool_configs: bool = False
+        persist_tool_configs: bool = False,
+        summary_config: Optional[Dict[str, Any]] = None
     ):
         """
         Initialize the Tiny Agent.
@@ -168,6 +364,8 @@ class TinyAgent:
             metadata: Optional metadata for the session
             storage: Optional storage backend for persistence
             persist_tool_configs: Whether to persist tool configurations
+            summary_model: Optional model to use for generating conversation summaries
+            summary_system_prompt: Optional system prompt for the summary model
         """
         # Set up logger
         self.logger = logger or logging.getLogger(__name__)
@@ -197,6 +395,8 @@ class TinyAgent:
             "content": system_prompt or DEFAULT_SYSTEM_PROMPT
         }]
         
+        self.summary_config = summary_config or {}
+        
         # This list now accumulates tools from *all* connected MCP servers:
         self.available_tools: List[Dict[str, Any]] = []
         
@@ -586,6 +786,42 @@ class TinyAgent:
         self.messages.append(user_message)
         await self._run_callbacks("message_add", message=self.messages[-1])
         
+        return await self._run_agent_loop(max_turns)
+    
+    async def resume(self, max_turns: int = 10) -> str:
+        """
+        Resume the conversation without adding a new user message.
+        
+        This method continues the conversation from the current state,
+        allowing the agent to process the existing conversation history
+        and potentially take additional actions.
+        
+        Args:
+            max_turns: Maximum number of conversation turns
+            
+        Returns:
+            The agent's response
+        """
+        # Ensure any deferred session-load happens exactly once
+        if self._needs_session_load:
+            self.logger.debug(f"Deferred session load detected for {self.session_id}; loading now")
+        await self.init_async()
+        
+        # Notify start with resume flag
+        await self._run_callbacks("agent_start", resume=True)
+        
+        return await self._run_agent_loop(max_turns)
+    
+    async def _run_agent_loop(self, max_turns: int = 10) -> str:
+        """
+        Internal method that runs the agent's main loop.
+        
+        Args:
+            max_turns: Maximum number of conversation turns
+            
+        Returns:
+            The agent's response
+        """
         # Initialize loop control variables
         num_turns = 0
         next_turn_should_call_tools = True
@@ -651,6 +887,10 @@ class TinyAgent:
                         function_info = tool_call.function
                         tool_name = function_info.name
                         
+                        await self._run_callbacks("tool_start", tool_call=tool_call)
+
+                        tool_result_content = ""
+                        
                         # Create a tool message
                         tool_message = {
                             "role": "tool",
@@ -671,28 +911,32 @@ class TinyAgent:
                             # Handle control flow tools
                             if tool_name == "final_answer":
                                 # Add a response for this tool call before returning
-                                tool_message["content"] = tool_args.get("content", "Task completed without final answer.!!!")
+                                tool_result_content = tool_args.get("content", "Task completed without final answer.!!!")
+                                tool_message["content"] = tool_result_content
                                 self.messages.append(tool_message)
                                 await self._run_callbacks("message_add", message=tool_message)
                                 await self._run_callbacks("agent_end", result="Task completed.")
+                                await self._run_callbacks("tool_end", tool_call=tool_call, result=tool_result_content)
                                 return tool_message["content"] 
                             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}"
+                                tool_result_content = f"Question asked: {question}"
+                                tool_message["content"] = tool_result_content
                                 self.messages.append(tool_message)
                                 await self._run_callbacks("message_add", message=tool_message)
                                 await self._run_callbacks("agent_end", result=f"I need more information: {question}")
+                                await self._run_callbacks("tool_end", tool_call=tool_call, result=tool_result_content)
                                 return f"I need more information: {question}"
                             else:
                                 # Check if it's a custom tool first
                                 if tool_name in self.custom_tool_handlers:
-                                    tool_message["content"] = await self._execute_custom_tool(tool_name, tool_args)
+                                    tool_result_content = await self._execute_custom_tool(tool_name, tool_args)
                                 else:
                                     # Dispatch to the proper MCPClient
                                     client = self.tool_to_client.get(tool_name)
                                     if not client:
-                                        tool_message["content"] = f"No MCP server registered for tool '{tool_name}'"
+                                        tool_result_content = f"No MCP server registered for tool '{tool_name}'"
                                     else:
                                         try:
                                             self.logger.debug(f"Calling tool {tool_name} with args: {tool_args}")
@@ -703,22 +947,25 @@ class TinyAgent:
                                             if content_list:
                                                 # Try different ways to extract the content
                                                 if hasattr(content_list[0], 'text'):
-                                                    tool_message["content"] = content_list[0].text
+                                                    tool_result_content = content_list[0].text
                                                 elif isinstance(content_list[0], dict) and 'text' in content_list[0]:
-                                                    tool_message["content"] = content_list[0]['text']
+                                                    tool_result_content = content_list[0]['text']
                                                 else:
-                                                    tool_message["content"] = str(content_list)
+                                                    tool_result_content = str(content_list)
                                             else:
-                                                tool_message["content"] = "Tool returned no content"
+                                                tool_result_content = "Tool returned no content"
                                         except Exception as e:
                                             self.logger.error(f"Error calling tool {tool_name}: {str(e)}")
-                                            tool_message["content"] = f"Error executing tool {tool_name}: {str(e)}"
+                                            tool_result_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
                             self.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
+                            tool_result_content = f"Error processing tool call: {str(e)}"
+                        finally:
+                            # Always add the tool message to ensure each tool call has a response
+                            tool_message["content"] = tool_result_content
+                            await self._run_callbacks("tool_end", tool_call=tool_call, result=tool_result_content)
+
                         self.messages.append(tool_message)
                         await self._run_callbacks("message_add", message=tool_message)
                     
@@ -934,6 +1181,162 @@ class TinyAgent:
             
             # Tool configs would be handled separately if needed
 
+    async def summarize(self) -> str:
+        """
+        Generate a summary of the current conversation history.
+        
+        Args:
+            custom_model: Optional model to use for summary generation (overrides self.summary_model)
+            custom_system_prompt: Optional system prompt for summary generation (overrides self.summary_system_prompt)
+            
+        Returns:
+            A string containing the conversation summary
+        """
+        # Skip if there are no messages or just the system message
+        if len(self.messages) <= 1:
+            return "No conversation to summarize."
+        
+        # Use provided parameters or defaults
+        system_prompt = self.summary_config.get("system_prompt",DEFAULT_SUMMARY_SYSTEM_PROMPT)
+        
+        # Format the conversation into a single string
+        conversation_text = self._format_conversation_for_summary()
+
+        task_prompt = load_template(str(Path(__file__).parent / "prompts" / "summarize.yaml"),"user_prompt")
+        
+        # Build the prompt for the summary model
+        summary_messages = [
+            {
+                "role": "system",
+                "content": system_prompt
+            },
+            {
+                "role": "user",
+                #"content": f"Here is the conversation so far:\n{conversation_text}\n\nPlease summarize this conversation, covering:\n0. What is the task its requirments, goals and constraints\n1. Tasks performed and outcomes\n2. Code files, modules, or functions modified or examined\n3. Important decisions or assumptions made\n4. Errors encountered and test or build results\n5. Remaining tasks, open questions, or next steps\nProvide the summary in a clear, concise format."
+                "content":conversation_text
+            },
+            {
+                "role": "user",
+                "content": task_prompt
+            }
+        ]
+        
+        try:
+            # Log that we're generating a summary
+            self.logger.info(f"Generating conversation summary using model {self.summary_config.get('model',self.model)}")
+            
+            # Call the LLM to generate the summary
+            response = await litellm.acompletion(
+                model=self.summary_config.get("model",self.model),
+                api_key=self.summary_config.get("api_key",self.api_key),
+                messages=summary_messages,
+                temperature=self.summary_config.get("temperature",self.temperature),  # Use low temperature for consistent summaries
+                max_tokens=self.summary_config.get("max_tokens",8000)   # Reasonable limit for summary length
+            )
+            
+            # Extract the summary from the response
+            summary = response.choices[0].message.content
+            return summary
+            
+        except Exception as e:
+            self.logger.error(f"Error generating conversation summary: {str(e)}")
+            return f"Failed to generate summary: {str(e)}"
+    
+    async def compact(self) -> bool:
+        """
+        Compact the conversation history by replacing it with a summary.
+        
+        This method:
+        1. Generates a summary of the current conversation
+        2. If successful, replaces the conversation with just [system, user] messages
+           where the user message contains the summary
+        3. Returns True if compaction was successful, False otherwise
+        
+        Returns:
+            Boolean indicating whether the compaction was successful
+        """
+        # Skip if there are no messages or just the system message
+        if len(self.messages) <= 1:
+            self.logger.info("No conversation to compact.")
+            return False
+        
+        # Generate the summary
+        summary = await self.summarize()
+        
+        # Check if the summary generation was successful
+        if summary.startswith("Failed to generate summary:") or summary == "No conversation to summarize.":
+            self.logger.error(f"Compaction failed: {summary}")
+            return False
+        
+        # Save the system message
+        system_message = self.messages[0]
+        
+        
+        # Create a new user message with the summary
+        summary_message = {
+            "role": "user",
+            "content": f"This session is being continued from a previous conversation that ran out of context. The conversation is summarized below:\n{summary}",
+            "created_at": int(time.time())
+        }
+        
+        # Replace the conversation with just [system, user] messages
+        self.messages = [system_message, summary_message]
+        
+        # Notify about the compaction
+        self.logger.info("🤐Conversation successfully compacted.")
+        await self._run_callbacks("message_add", message=summary_message)
+        
+        return True
+    
+    def _format_conversation_for_summary(self) -> str:
+        """
+        Format the conversation history into a string for summarization.
+        
+        Returns:
+            A string representing the conversation in the format:
+            user: content
+            assistant: content
+            tool_call: tool name and args
+            tool_response: response content
+            ...
+        """
+        formatted_lines = []
+        
+        # Skip the system message (index 0)
+        for message in self.messages[1:]:
+            role = message.get("role", "unknown")
+            
+            if role == "user":
+                formatted_lines.append(f"user: {message.get('content', '')}")
+            
+            elif role == "assistant":
+                content = message.get("content", "")
+                tool_calls = message.get("tool_calls", [])
+                
+                # Add assistant message content if present
+                if content:
+                    formatted_lines.append(f"assistant: {content}")
+                
+                # Add tool calls if present
+                for tool_call in tool_calls:
+                    function_info = tool_call.get("function", {})
+                    tool_name = function_info.get("name", "unknown_tool")
+                    arguments = function_info.get("arguments", "{}")
+                    
+                    formatted_lines.append(f"tool_call: {tool_name} with args {arguments}")
+            
+            elif role == "tool":
+                tool_name = message.get("name", "unknown_tool")
+                content = message.get("content", "")
+                formatted_lines.append(f"tool_response: {content}")
+            
+            else:
+                # Handle any other message types
+                formatted_lines.append(f"{role}: {message.get('content', '')}")
+        
+        return [{'type': 'text', 'text': f"{x}"} for x in formatted_lines]
+        #return "\n".join(formatted_lines)
+
 async def run_example():
     """Example usage of TinyAgent with proper logging."""
     import os
@@ -994,7 +1397,13 @@ async def run_example():
     agent_logger.info(f"Running agent with input: {user_input}")
     result = await agent.run(user_input)
     
-    agent_logger.info(f"Final result: {result}")
+    agent_logger.info(f"Initial result: {result}")
+    
+    # Now demonstrate the resume functionality
+    agent_logger.info("Resuming the conversation without new user input")
+    resume_result = await agent.resume(max_turns=3)
+    
+    agent_logger.info(f"Resume result: {resume_result}")
     
     # Clean up
     await agent.close()

{tinyagent_py-0.0.13.dist-info → tinyagent_py-0.0.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tinyagent-py
-Version: 0.0.13
+Version: 0.0.15
 Summary: TinyAgent with MCP Client, Code Agent (Thinking, Planning, and Executing in Python), and Extendable Hooks, Tiny but powerful
 Author-email: Mahdi Golchin <golchin@askdev.ai>
 Project-URL: Homepage, https://github.com/askbudi/tinyagent

{tinyagent_py-0.0.13.dist-info → tinyagent_py-0.0.15.dist-info}/RECORD

@@ -1,33 +1,36 @@
 tinyagent/__init__.py,sha256=-3ZN8unMZDrA366BET1HKp-fnFCyXCAD1fPVbHkJSsY,172
 tinyagent/mcp_client.py,sha256=9dmLtJ8CTwKWKTH6K9z8CaCQuaicOH9ifAuNyX7Kdo0,6030
 tinyagent/memory_manager.py,sha256=tAaZZdxBJ235wJIyr04n3f2Damok4s2UXunTtur_p-4,44916
-tinyagent/tiny_agent.py,sha256=X-rh8gCxeVSNS4RJ9vdtqTKf8ksDGrXsV1jwprW6Fj8,41049
+tinyagent/tiny_agent.py,sha256=RHeqjGWWXOfhuQTfEbPp6rcwQmpk23FrY-gSNOyb3y8,61127
 tinyagent/code_agent/__init__.py,sha256=YSOblSwRS1QcAYUu--GvF4fKeQX1KRTj9P8CWySY3pY,327
 tinyagent/code_agent/example.py,sha256=qC6i3auUT1YwXS9WK1Ovq-9oDOUgzRxDegYdlVcVcfA,5861
-tinyagent/code_agent/helper.py,sha256=oZnpo-_H3cB12LxNN7Ztd-31EiUcuI2UpWP69xuF8oE,7205
-tinyagent/code_agent/modal_sandbox.py,sha256=RcQ5a-UFyqV7xSHnttpgAQQ-mNWk-9Z0tb836ua7C0E,16381
-tinyagent/code_agent/safety.py,sha256=WHad2ypzfsdKnXG6FcgXcgGiMC-H4KTmOzhP9S9i3Zw,22209
-tinyagent/code_agent/tiny_code_agent.py,sha256=UrNjmJSrDC493bXGARrt0tDd1Bn56FgNlxuQSu4J614,28194
-tinyagent/code_agent/utils.py,sha256=FxHnpb06S2o2-xPRHgf9zAnzbXvGWs5QApNI4DEH__U,7870
+tinyagent/code_agent/helper.py,sha256=Z_89CtEiyURW_zFwlbsAk_DApNlCycVsScpWcygk5l0,7217
+tinyagent/code_agent/modal_sandbox.py,sha256=4HLcbf53eQm7oGidOTNFd12DL4FsGPue7tj8mHndll4,16398
+tinyagent/code_agent/safety.py,sha256=RF93d6oYiVjdm5nU5jKbnRVtnPmC93AOy8Hg1LrBGtA,22494
+tinyagent/code_agent/tiny_code_agent.py,sha256=gYRRJCk_0hpRS3YSnJxaeZCCzoJeCKtvY6EhKfeu38M,42691
+tinyagent/code_agent/utils.py,sha256=jBoVMqox9HG5fWzCsu9gxiwI1oEk64dPKnDfTtw0nkw,11474
 tinyagent/code_agent/providers/__init__.py,sha256=myfy9qsBDjNOhcgXJ2E9jO1q5eo6jHp43I2k0k8esLY,136
-tinyagent/code_agent/providers/base.py,sha256=LfmahpulNbnivn5m91GTAo6ityjidq05dC3qx9EtJ80,8203
-tinyagent/code_agent/providers/modal_provider.py,sha256=R0qt8XlTMFMbznMHN32pQxupDE9KR18NpQ3l1wJJP0w,10799
+tinyagent/code_agent/providers/base.py,sha256=ai-AfgbctLsx6QyVIE0rSmp-02j0HiHR1Fd-E8C5GcY,15040
+tinyagent/code_agent/providers/modal_provider.py,sha256=lzMFJUU3MArxPv9brpNNDpU032kJpqt7RU3h2M8ctN0,15599
 tinyagent/code_agent/tools/__init__.py,sha256=0XtrgYBgBayOffW50KyrlmrXXs9iu6z1DHu7-D8WGqY,94
 tinyagent/code_agent/tools/example_tools.py,sha256=YbXb7PKuvvxh-LV12Y4n_Ez3RyLA95gWOcZrKsa7UHg,1203
-tinyagent/hooks/__init__.py,sha256=RZow2r0XHLJ3-tnmecScdc0_wrEdmOy5dtXqoiRME5Y,254
+tinyagent/hooks/__init__.py,sha256=dva7ZeghQ7BorIcYCI1rpg0MiN61O90CPy1Uc-aWamk,383
 tinyagent/hooks/gradio_callback.py,sha256=78x2x9AbYoLV-qwCxn2sH4s39DLlhNCzL7qCkVR-vy4,56911
+tinyagent/hooks/jupyter_notebook_callback.py,sha256=XjzX0EJXLbGYYZVqeqnWnVZ4KRj_uX5cUQ6oBsmCcus,65787
 tinyagent/hooks/logging_manager.py,sha256=UpdmpQ7HRPyer-jrmQSXcBwi409tV9LnGvXSHjTcYTI,7935
 tinyagent/hooks/rich_code_ui_callback.py,sha256=PLcu5MOSoP4oZR3BtvcV9DquxcIT_d0WzSlkvaDcGOk,19820
 tinyagent/hooks/rich_ui_callback.py,sha256=5iCNOiJmhc1lOL7ZjaOt5Sk3rompko4zu_pAxfTVgJQ,22897
+tinyagent/hooks/token_tracker.py,sha256=t5BfDE1fFrDYzIAnaxLxSyCAmWlsHeEIjZSkrxbTcWI,23133
 tinyagent/prompts/code_agent.yaml,sha256=xkHhR75t6N_O0VbOpXWLVjg37XHNvfOIDCmfEeUBgU4,16516
+tinyagent/prompts/summarize.yaml,sha256=-Omdjq0hDjwJPKLE75UlU2Pbgmr7qV14XKtkaQNNhgA,6344
 tinyagent/storage/__init__.py,sha256=7qwfdD4smCl891xaRuiReSUgfOJFy7jJZsN0ul1iQdY,173
 tinyagent/storage/base.py,sha256=GGAMvOoslmm1INLFG_jtwOkRk2Qg39QXx-1LnN7fxDI,1474
 tinyagent/storage/json_file_storage.py,sha256=SYD8lvTHu2-FEHm1tZmsrcgEOirBrlUsUM186X-UPgI,1114
 tinyagent/storage/postgres_storage.py,sha256=IGwan8UXHNnTZFK1F8x4kvMDex3GAAGWUg9ePx_5IF4,9018
 tinyagent/storage/redis_storage.py,sha256=hu3y7wHi49HkpiR-AW7cWVQuTVOUk1WaB8TEPGUKVJ8,1742
 tinyagent/storage/sqlite_storage.py,sha256=ZyOYe0d_oHO1wOIT8FxKIbc67tP_0e_8FnM2Zq8Pwj8,5915
-tinyagent_py-0.0.13.dist-info/licenses/LICENSE,sha256=YIogcVQnknaaE4K-oaQylFWo8JGRBWnwmGb3fWB_Pww,1064
-tinyagent_py-0.0.13.dist-info/METADATA,sha256=qr6akWcOHEZNUtQ34H_XalRWtJD-mK6WLiwmlcTH_N0,13848
-tinyagent_py-0.0.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tinyagent_py-0.0.13.dist-info/top_level.txt,sha256=Ny8aJNchZpc2Vvhp3306L5vjceJakvFxBk-UjjVeA_I,10
-tinyagent_py-0.0.13.dist-info/RECORD,,
+tinyagent_py-0.0.15.dist-info/licenses/LICENSE,sha256=YIogcVQnknaaE4K-oaQylFWo8JGRBWnwmGb3fWB_Pww,1064
+tinyagent_py-0.0.15.dist-info/METADATA,sha256=dLpzqjyzmYLqPX6wX54zJF5PuXs4z4KVA8oNFvhK_rM,13848
+tinyagent_py-0.0.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tinyagent_py-0.0.15.dist-info/top_level.txt,sha256=Ny8aJNchZpc2Vvhp3306L5vjceJakvFxBk-UjjVeA_I,10
+tinyagent_py-0.0.15.dist-info/RECORD,,