lite-agent 0.6.0__tar.gz → 0.8.0__tar.gz

{lite_agent-0.6.0 → lite_agent-0.8.0}/.claude/settings.local.json

@@ -15,7 +15,10 @@
       "Bash(timeout:*)",
       "Bash(pyright:*)",
       "Bash(rg:*)",
-      "Bash(uv run:*)"
+      "Bash(uv run:*)",
+      "Bash(mkdir:*)",
+      "Bash(sed:*)",
+      "Bash(mv:*)"
     ],
     "deny": []
   }

{lite_agent-0.6.0 → lite_agent-0.8.0}/CHANGELOG.md

@@ -1,3 +1,33 @@
+## v0.8.0
+
+[v0.7.0...v0.8.0](https://github.com/Jannchie/lite-agent/compare/v0.7.0...v0.8.0)
+
+### :rocket: Breaking Changes
+
+- **runner**: remove dict-format and legacy support from message history and enforce newmessage format - By [Jannchie](mailto:jannchie@gmail.com) in [44b435c](https://github.com/Jannchie/lite-agent/commit/44b435c)
+
+### :sparkles: Features
+
+- **agent**: add dynamic stop-before-functions support - By [Jannchie](mailto:jannchie@gmail.com) in [e7de181](https://github.com/Jannchie/lite-agent/commit/e7de181)
+- **agent**: improve tool call extraction and meta preservation - By [Jannchie](mailto:jannchie@gmail.com) in [1b10296](https://github.com/Jannchie/lite-agent/commit/1b10296)
+- **runner**: add cancellation events for pending tool calls and implement function_call_output for agent transfers - By [Jannchie](mailto:jannchie@gmail.com) in [4c298b7](https://github.com/Jannchie/lite-agent/commit/4c298b7)
+- **runner**: preserve original dict message structure in chat history - By [Jannchie](mailto:jannchie@gmail.com) in [da4ad59](https://github.com/Jannchie/lite-agent/commit/da4ad59)
+
+## v0.7.0
+
+[v0.6.0...v0.7.0](https://github.com/Jannchie/lite-agent/compare/v0.6.0...v0.7.0)
+
+### :sparkles: Features
+
+- **assistant-meta**: add model and usage support to assistant message meta and refactor token accounting - By [Jannchie](mailto:jannchie@gmail.com) in [b50ed0e](https://github.com/Jannchie/lite-agent/commit/b50ed0e)
+- **message-builder**: support array content in assistant messages - By [Jannchie](mailto:jannchie@gmail.com) in [1b7a790](https://github.com/Jannchie/lite-agent/commit/1b7a790)
+- **runner**: add tool call handling and usage events for completion and responses api - By [Jannchie](mailto:jannchie@gmail.com) in [1a82a18](https://github.com/Jannchie/lite-agent/commit/1a82a18)
+
+### :art: Refactors
+
+- **messages**: replace type checks with isinstance for assistant content - By [Jannchie](mailto:jannchie@gmail.com) in [ec506a8](https://github.com/Jannchie/lite-agent/commit/ec506a8)
+- **utils**: extract constants and message utilities && centralize timing metrics - By [Jannchie](mailto:jannchie@gmail.com) in [d928637](https://github.com/Jannchie/lite-agent/commit/d928637)
+
 ## v0.6.0
 
 [v0.5.0...v0.6.0](https://github.com/Jannchie/lite-agent/compare/v0.5.0...v0.6.0)

{lite_agent-0.6.0 → lite_agent-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lite-agent
-Version: 0.6.0
+Version: 0.8.0
 Summary: A lightweight, extensible framework for building AI agent.
 Author-email: Jianqi Pan <jannchie@gmail.com>
 License: MIT
@@ -19,6 +19,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Requires-Dist: aiofiles>=24.1.0
 Requires-Dist: funcall>=0.10.0
+Requires-Dist: openai<=1.99.5
 Requires-Dist: prompt-toolkit>=3.0.51
 Requires-Dist: rich>=14.0.0
 Description-Content-Type: text/markdown

{lite_agent-0.6.0 → lite_agent-0.8.0}/examples/basic.py

@@ -4,7 +4,6 @@ import logging
 from rich.logging import RichHandler
 
 from lite_agent.agent import Agent
-from lite_agent.chat_display import display_messages
 from lite_agent.runner import Runner
 
 logging.basicConfig(
@@ -32,15 +31,12 @@ agent = Agent(
 
 
 async def main():
-    runner = Runner(agent)
-    resp = runner.run(
+    runner = Runner(agent, streaming=False, api="completion")
+    resp = await runner.run_until_complete(
         "What is the temperature in New York?",
         includes=["usage", "assistant_message", "function_call", "function_call_output", "timing"],
     )
-    async for chunk in resp:
-        logger.info(chunk)
-    display_messages(runner.messages)
-    print(runner.messages)
+    print(resp[0])
 
 
 if __name__ == "__main__":

lite_agent-0.8.0/examples/cancel_and_transfer_demo.py

@@ -0,0 +1,299 @@
+#!/usr/bin/env python3
+"""
+Demo showing two new features:
+1. Cancellation of pending tool calls when user provides new input
+2. function_call_output events for transfer_to_agent and transfer_to_parent
+"""
+
+import asyncio
+import logging
+
+from funcall.decorators import tool
+from rich.logging import RichHandler
+
+from lite_agent.agent import Agent
+from lite_agent.runner import Runner
+from lite_agent.types import AssistantTextContent, AssistantToolCall, NewAssistantMessage
+
+logging.basicConfig(
+    level=logging.WARNING,
+    format="%(message)s",
+    datefmt="[%X]",
+    handlers=[RichHandler(rich_tracebacks=True)],
+)
+
+logger = logging.getLogger("lite_agent")
+logger.setLevel(logging.DEBUG)
+
+
+@tool
+async def get_weather(city: str) -> str:
+    """Get the weather for a city."""
+    await asyncio.sleep(2)  # Simulate long operation
+    return f"The weather in {city} is sunny with a few clouds."
+
+
+@tool
+async def get_temperature(city: str) -> str:
+    """Get the temperature for a city."""
+    await asyncio.sleep(2)  # Simulate long operation
+    return f"The temperature in {city} is 25°C."
+
+
+@tool
+async def book_flight(destination: str, date: str) -> str:
+    """Book a flight to a destination."""
+    await asyncio.sleep(3)  # Simulate very long operation
+    return f"Flight booked to {destination} on {date}"
+
+
+async def demo_1_cancel_pending_tools():
+    """Demo 1: Cancellation of pending tool calls"""
+    print("=== Demo 1: Cancellation of Pending Tool Calls ===\n")
+
+    agent = Agent(
+        model="gpt-4.1-nano",
+        name="WeatherBot",
+        instructions="You are a helpful weather assistant.",
+        tools=[get_weather, get_temperature, book_flight],
+    )
+
+    runner = Runner(agent)
+
+    # Simulate a scenario where the agent made tool calls but user interrupts
+    print("1. Simulating assistant making tool calls...")
+    assistant_message = NewAssistantMessage(
+        content=[
+            AssistantTextContent(text="I'll check the weather and temperature for you, and also help you book that flight."),
+            AssistantToolCall(
+                call_id="weather_call",
+                name="get_weather",
+                arguments='{"city": "Tokyo"}',
+            ),
+            AssistantToolCall(
+                call_id="temp_call",
+                name="get_temperature",
+                arguments='{"city": "Tokyo"}',
+            ),
+            AssistantToolCall(
+                call_id="flight_call",
+                name="book_flight",
+                arguments='{"destination": "Paris", "date": "2024-12-25"}',
+            ),
+        ],
+    )
+
+    runner.messages.append(assistant_message)
+
+    # Check pending calls
+    pending_calls = runner._find_pending_tool_calls()
+    print(f"Pending tool calls: {len(pending_calls)}")
+    for call in pending_calls:
+        print(f"  - {call.name} (call_id: {call.call_id})")
+
+    print(f"Total messages before cancellation: {len(runner.messages)}")
+    print(f"Content items in assistant message: {len(assistant_message.content)}")
+
+    # User provides new input - this should cancel pending calls and generate events
+    print("\n2. User provides new input: 'Actually, never mind about the weather. What's the capital of Japan?'")
+
+    print("\n2a. Testing via run() method (integrated flow with event yielding):")
+    # Test the integrated flow - collect cancellation events from run()
+    # This will automatically call _cancel_pending_tool_calls() and yield events
+    chunks = []
+    try:
+        async for chunk in runner.run("What's the capital of Japan?", includes=["function_call_output"]):
+            chunks.append(chunk)
+            if len(chunks) >= 3:  # Stop after getting cancellation events
+                break
+    except Exception:
+        # Expected - no real LLM configured
+        pass
+
+    print(f"Events from run() method: {len(chunks)}")
+    for i, chunk in enumerate(chunks):
+        if chunk.type == "function_call_output":
+            print(f"  - Chunk {i + 1}: {chunk.type} for {chunk.tool_call_id}")
+            print(f"    Tool: {chunk.name}")
+            print(f"    Content: {chunk.content}")
+
+    # Now demonstrate the direct method on fresh data
+    print("\n2b. Testing direct cancellation method (returns events):")
+    # Create a new runner with fresh pending calls
+    runner2 = Runner(agent)
+    runner2.messages.append(
+        NewAssistantMessage(
+            content=[
+                AssistantTextContent(text="Let me help with a different task."),
+                AssistantToolCall(
+                    call_id="new_call_1",
+                    name="get_weather",
+                    arguments='{"city": "London"}',
+                ),
+                AssistantToolCall(
+                    call_id="new_call_2",
+                    name="get_temperature",
+                    arguments='{"city": "London"}',
+                ),
+            ],
+        ),
+    )
+
+    cancellation_events = runner2._cancel_pending_tool_calls()
+    print(f"Cancellation events generated: {len(cancellation_events)}")
+    for event in cancellation_events:
+        print(f"  - Event: {event.type} for {event.tool_call_id} ({event.name})")
+        print(f"    Content: {event.content}")
+        print(f"    Execution time: {event.execution_time_ms}ms")
+
+    print("\n3. After cancellation:")
+    pending_calls_after = runner._find_pending_tool_calls()
+    print(f"Pending tool calls: {len(pending_calls_after)}")
+
+    print(f"Total messages after cancellation: {len(runner.messages)}")
+    if runner.messages:
+        assistant_msg = runner.messages[0]
+        print(f"Content items in assistant message: {len(assistant_msg.content)}")
+
+        # Show the cancellation results
+        cancellation_results = [item for item in assistant_msg.content if item.type == "tool_call_result"]
+        print(f"Cancellation results added: {len(cancellation_results)}")
+        for result in cancellation_results:
+            print(f"  - {result.call_id}: {result.output}")
+
+
+async def demo_2_transfer_events():
+    """Demo 2: function_call_output events for agent transfers"""
+    print("\n\n=== Demo 2: Transfer Events ===\n")
+
+    # Create agents with handoff relationships
+    weather_agent = Agent(
+        model="gpt-4",
+        name="WeatherAgent",
+        instructions="You specialize in weather information.",
+        tools=[get_weather, get_temperature],
+    )
+
+    travel_agent = Agent(
+        model="gpt-4",
+        name="TravelAgent",
+        instructions="You specialize in travel bookings.",
+        tools=[book_flight],
+    )
+
+    main_agent = Agent(
+        model="gpt-4",
+        name="MainAgent",
+        instructions="You are the main agent that coordinates with specialists.",
+        handoffs=[weather_agent, travel_agent],
+    )
+
+    runner = Runner(main_agent)
+
+    print("1. Testing transfer_to_agent with function_call_output events:")
+    print(f"Current agent: {runner.agent.name}")
+
+    # Simulate transfer_to_agent call
+    import json
+
+    from lite_agent.types import ToolCall, ToolCallFunction
+
+    transfer_call = ToolCall(
+        type="function",
+        id="transfer_001",
+        function=ToolCallFunction(
+            name="transfer_to_agent",
+            arguments=json.dumps({"name": "WeatherAgent"}),
+        ),
+        index=0,
+    )
+
+    # Handle transfer and collect events
+    chunks = []
+    async for chunk in runner._handle_tool_calls([transfer_call], ["function_call_output"]):
+        chunks.append(chunk)
+
+    print(f"Events generated: {len(chunks)}")
+    for i, chunk in enumerate(chunks):
+        print(f"  Event {i + 1}: {chunk.type} - {chunk.content}")
+
+    print(f"Agent after transfer: {runner.agent.name}")
+
+    print("\n2. Testing transfer_to_parent with function_call_output events:")
+
+    parent_transfer_call = ToolCall(
+        type="function",
+        id="transfer_002",
+        function=ToolCallFunction(
+            name="transfer_to_parent",
+            arguments="{}",
+        ),
+        index=0,
+    )
+
+    # Handle parent transfer and collect events
+    chunks = []
+    async for chunk in runner._handle_tool_calls([parent_transfer_call], ["function_call_output"]):
+        chunks.append(chunk)
+
+    print(f"Events generated: {len(chunks)}")
+    for i, chunk in enumerate(chunks):
+        print(f"  Event {i + 1}: {chunk.type} - {chunk.content}")
+
+    print(f"Agent after parent transfer: {runner.agent.name}")
+
+    print("\n3. Testing multiple transfers (only first executes):")
+
+    # Multiple transfer calls
+    transfer_call_1 = ToolCall(
+        type="function",
+        id="multi_001",
+        function=ToolCallFunction(
+            name="transfer_to_agent",
+            arguments=json.dumps({"name": "TravelAgent"}),
+        ),
+        index=0,
+    )
+
+    transfer_call_2 = ToolCall(
+        type="function",
+        id="multi_002",
+        function=ToolCallFunction(
+            name="transfer_to_agent",
+            arguments=json.dumps({"name": "WeatherAgent"}),
+        ),
+        index=1,
+    )
+
+    chunks = []
+    async for chunk in runner._handle_tool_calls([transfer_call_1, transfer_call_2], ["function_call_output"]):
+        chunks.append(chunk)
+
+    print(f"Events generated: {len(chunks)}")
+    for i, chunk in enumerate(chunks):
+        print(f"  Event {i + 1}: {chunk.content}")
+
+    print(f"Final agent: {runner.agent.name}")
+
+
+async def main():
+    """Run both demos"""
+    print("🚀 Demo: New LiteAgent Features\n")
+
+    # Demo 1: Cancellation of pending tools
+    await demo_1_cancel_pending_tools()
+
+    # Demo 2: Transfer events
+    await demo_2_transfer_events()
+
+    print("\n✅ All demos completed!")
+    print("\nKey takeaways:")
+    print("1. Pending tool calls are automatically cancelled when user provides new input")
+    print("2. Cancellation now generates function_call_output events (not just history records)")
+    print("3. Transfer operations generate function_call_output events like regular tools")
+    print("4. Multiple transfers in one call: only the first executes, others get 'already executed' message")
+    print("5. Both cancellation and transfer events are yielded through the run() method")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{lite_agent-0.6.0 → lite_agent-0.8.0}/examples/confirm_and_continue.py

@@ -48,7 +48,7 @@ async def main():
     )
     async for chunk in resp:
         logger.info(chunk)
-    resp = runner.run_continue_stream(
+    resp = runner.run(
         includes=["usage", "assistant_message", "function_call", "function_call_output"],
         record_to="tests/mocks/confirm_and_continue/2.jsonl",
     )

{lite_agent-0.6.0 → lite_agent-0.8.0}/examples/debug_non_streaming.py

@@ -1,6 +1,7 @@
 """
 Debug example to investigate non-streaming mode issues.
 """
+
 import asyncio
 import logging
 

{lite_agent-0.6.0 → lite_agent-0.8.0}/examples/debug_with_logging.py

@@ -1,6 +1,7 @@
 """
 Debug with full logging enabled.
 """
+
 import asyncio
 import logging
 

{lite_agent-0.6.0 → lite_agent-0.8.0}/examples/handoffs.py

@@ -70,7 +70,7 @@ async def main():
     )
     async for message in resp:
         logger.info(message)
-    print(f"{runner.get_messages_dict()}")
+    print(f"{runner.get_messages()}")
     logger.info(runner.agent.name)
 
 

{lite_agent-0.6.0 → lite_agent-0.8.0}/examples/llm_config_demo.py

@@ -72,7 +72,7 @@ async def main():
         logger.info(chunk)
     display_messages(runner1.messages)
 
-    print("\n" + "="*50 + "\n")
+    print("\n" + "=" * 50 + "\n")
 
     # Test agent with creative settings (high temperature, longer responses)
     print("=== Testing Agent 2 (Creative Settings) ===")

{lite_agent-0.6.0 → lite_agent-0.8.0}/examples/non_streaming.py

@@ -1,6 +1,7 @@
 """
 Simple example demonstrating non-streaming mode in LiteAgent.
 """
+
 import asyncio
 
 from lite_agent import Agent, Runner
@@ -33,6 +34,7 @@ async def main():
     def get_time() -> str:
         """Get the current time."""
         from datetime import datetime
+
         return f"Current time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
 
     agent_with_tools = Agent(

{lite_agent-0.6.0 → lite_agent-0.8.0}/examples/reasoning_example.py

@@ -75,9 +75,9 @@ async def main():
     """主演示函数。"""
     await demo_reasoning_configurations()
 
-    print("\n" + "="*60)
+    print("\n" + "=" * 60)
     print("推理配置使用说明:")
-    print("="*60)
+    print("=" * 60)
     print("""
 1. reasoning_effort 参数 (OpenAI兼容):
    - "minimal": 最小推理，快速响应

{lite_agent-0.6.0 → lite_agent-0.8.0}/examples/response_api_example.py

@@ -9,6 +9,8 @@ to the legacy Completion API format when making actual LLM calls.
 
 import asyncio
 
+from pydantic import BaseModel
+
 from lite_agent import Agent, Runner
 from lite_agent.types import ResponseInputImage, ResponseInputText
 
@@ -96,7 +98,7 @@ async def main():
     print("\n=== Internal message representation ===")
     for i, message in enumerate(runner.messages):
         print(f"Message {i + 1}:")
-        if hasattr(message, "model_dump"):
+        if isinstance(message, BaseModel):
             print(f"  {message.model_dump()}")
         else:
             print(f"  {message}")

{lite_agent-0.6.0 → lite_agent-0.8.0}/examples/simple_debug.py

@@ -1,6 +1,7 @@
 """
 Simple debug to check non-streaming response.
 """
+
 import asyncio
 
 from lite_agent import Agent, Runner
@@ -29,6 +30,7 @@ async def main():
     except Exception as e:
         print(f"Error: {e}")
         import traceback
+
         traceback.print_exc()
 
 

{lite_agent-0.6.0 → lite_agent-0.8.0}/examples/simple_debug2.py

@@ -1,6 +1,7 @@
 """
 Simple debug to check which API is being used.
 """
+
 import asyncio
 
 from lite_agent import Agent, Runner

lite_agent-0.8.0/examples/stop_before_functions.py

@@ -0,0 +1,114 @@
+import asyncio
+import logging
+
+from funcall.decorators import tool
+from rich.logging import RichHandler
+
+from lite_agent.agent import Agent
+from lite_agent.runner import Runner
+
+logging.basicConfig(
+    level=logging.WARNING,
+    format="%(message)s",
+    datefmt="[%X]",
+    handlers=[RichHandler(rich_tracebacks=True)],
+)
+
+logger = logging.getLogger("lite_agent")
+logger.setLevel(logging.DEBUG)
+
+
+async def get_weather(city: str) -> str:
+    """Get the weather for a city."""
+    await asyncio.sleep(1)
+    return f"The weather in {city} is sunny with a few clouds."
+
+
+async def get_temperature(city: str) -> str:
+    """Get the temperature for a city."""
+    await asyncio.sleep(1)
+    return f"The temperature in {city} is 25°C."
+
+
+@tool(require_confirmation=True)
+async def send_email(to: str, subject: str) -> str:
+    """Send an email (decorated with require_confirmation=True)."""
+    await asyncio.sleep(1)
+    return f"Email sent to {to} with subject: {subject}"
+
+
+async def main():
+    # Create agent with stop_before_functions parameter (using callable)
+    agent = Agent(
+        model="gpt-4.1-nano",
+        name="Weather Assistant",
+        instructions="You are a helpful weather assistant. Provide friendly and informative responses.",
+        tools=[get_weather, get_temperature, send_email],
+        stop_before_tools=[get_temperature],  # Stop before calling get_temperature (using callable)
+    )
+
+    runner = Runner(agent)
+
+    print("=== Test 1: stop_before_functions in constructor ===")
+    resp = runner.run(
+        "What is the weather in New York? And what is the temperature there?",
+        includes=["usage", "assistant_message", "function_call", "function_call_output"],
+    )
+    async for chunk in resp:
+        logger.info(chunk)
+
+    print(f"\nHas require confirm tools: {await runner.has_require_confirm_tools()}")
+
+    # Continue execution
+    resp = runner.run_continue_stream(
+        includes=["usage", "assistant_message", "function_call", "function_call_output"],
+    )
+    async for chunk in resp:
+        logger.info(chunk)
+
+    print("\n=== Test 2: Dynamic function addition (using callable) ===")
+    # Add another function dynamically using callable
+    agent.add_stop_before_function(get_weather)
+    print(f"Stop before functions: {agent.get_stop_before_functions()}")
+
+    runner2 = Runner(agent)
+    resp = runner2.run(
+        "What is the weather in Tokyo?",
+        includes=["usage", "assistant_message", "function_call", "function_call_output"],
+    )
+    async for chunk in resp:
+        logger.info(chunk)
+
+    print(f"\nHas require confirm tools: {await runner2.has_require_confirm_tools()}")
+
+    # Continue execution
+    resp = runner2.run_continue_stream(
+        includes=["usage", "assistant_message", "function_call", "function_call_output"],
+    )
+    async for chunk in resp:
+        logger.info(chunk)
+
+    print("\n=== Test 3: Decorator-based require_confirmation still works ===")
+    agent.clear_stop_before_functions()
+    print(f"Stop before functions cleared: {agent.get_stop_before_functions()}")
+
+    runner3 = Runner(agent)
+    resp = runner3.run(
+        "Send an email to john@example.com with subject 'Weather Update'",
+        includes=["usage", "assistant_message", "function_call", "function_call_output"],
+    )
+    async for chunk in resp:
+        logger.info(chunk)
+
+    print(f"\nHas require confirm tools (decorator): {await runner3.has_require_confirm_tools()}")
+
+    # Continue execution
+    resp = runner3.run_continue_stream(
+        includes=["usage", "assistant_message", "function_call", "function_call_output"],
+    )
+    async for chunk in resp:
+        logger.info(chunk)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{lite_agent-0.6.0 → lite_agent-0.8.0}/examples/streaming_demo.py

@@ -1,6 +1,7 @@
 """
 Demo script showing streaming vs non-streaming configuration in LiteAgent.
 """
+
 import asyncio
 import time
 

{lite_agent-0.6.0 → lite_agent-0.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lite-agent"
-version = "0.6.0"
+version = "0.8.0"
 description = "A lightweight, extensible framework for building AI agent."
 readme = "README.md"
 authors = [{ name = "Jianqi Pan", email = "jannchie@gmail.com" }]
@@ -10,6 +10,7 @@ dependencies = [
     "funcall>=0.10.0",
     "prompt-toolkit>=3.0.51",
     "rich>=14.0.0",
+    "openai<=1.99.5",
 ]
 keywords = [
     "function call",
@@ -89,6 +90,7 @@ ignore = [
     "ARG002",
 ]
 
+
 [tool.uv]
 upgrade = true
 package = true