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

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

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

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

@@ -1,3 +1,42 @@
+## 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)
+
+### :sparkles: Features
+
+- **examples**: add basic and llm config usage examples - By [Jannchie](mailto:jannchie@gmail.com) in [ea4112f](https://github.com/Jannchie/lite-agent/commit/ea4112f)
+- **streaming**: add unified streaming and non-streaming response handling - By [Jannchie](mailto:jannchie@gmail.com) in [53daf42](https://github.com/Jannchie/lite-agent/commit/53daf42)
+
 ## v0.5.0
 
 [v0.4.1...v0.5.0](https://github.com/Jannchie/lite-agent/compare/v0.4.1...v0.5.0)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lite-agent
-Version: 0.5.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.8.0/examples/basic.py

@@ -0,0 +1,43 @@
+import asyncio
+import logging
+
+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_temperature(city: str) -> str:
+    """Get the temperature for a city."""
+    return f"The temperature in {city} is 25°C."
+
+
+agent = Agent(
+    model="gpt-4.1-nano",
+    name="Weather Assistant",
+    instructions="You are a helpful weather assistant. Before using tools, briefly explain what you are going to do. Provide friendly and informative responses.",
+    tools=[get_temperature],
+)
+
+
+async def main():
+    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"],
+    )
+    print(resp[0])
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

lite_agent-0.5.0/examples/basic.py → lite_agent-0.8.0/examples/basic_model.py

@@ -5,6 +5,7 @@ from rich.logging import RichHandler
 
 from lite_agent.agent import Agent
 from lite_agent.chat_display import display_messages
+from lite_agent.client import LiteLLMClient
 from lite_agent.runner import Runner
 
 logging.basicConfig(
@@ -24,7 +25,12 @@ async def get_temperature(city: str) -> str:
 
 
 agent = Agent(
-    model="gpt-4.1-nano",
+    model=LiteLLMClient(
+        model="gpt-4o-mini",
+        temperature=0.7,
+        max_tokens=150,
+        top_p=0.9,
+    ),
     name="Weather Assistant",
     instructions="You are a helpful weather assistant. Before using tools, briefly explain what you are going to do. Provide friendly and informative responses.",
     tools=[get_temperature],

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.5.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.8.0/examples/debug_non_streaming.py

@@ -0,0 +1,57 @@
+"""
+Debug example to investigate non-streaming mode issues.
+"""
+
+import asyncio
+import logging
+
+from lite_agent import Agent, Runner
+
+# Enable debug logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger("lite_agent")
+logger.setLevel(logging.DEBUG)
+
+
+async def main():
+    # Create an agent
+    agent = Agent(
+        name="DebugAgent",
+        model="gpt-4o-mini",
+        instructions="You are a helpful assistant.",
+    )
+
+    print("=== Debug Non-Streaming Mode ===")
+
+    # Test with streaming=False
+    runner = Runner(agent, streaming=False)
+
+    print("Running in non-streaming mode...")
+    chunks = []
+
+    async for chunk in runner.run("Hello, please say hi back."):
+        print(f"Received chunk: {chunk}")
+        print(f"Chunk type: {chunk.type}")
+        if hasattr(chunk, "message"):
+            print(f"Chunk message: {chunk.message}")
+        if hasattr(chunk, "content"):
+            print(f"Chunk content: {chunk.content}")
+        chunks.append(chunk)
+
+    print(f"\nTotal chunks received: {len(chunks)}")
+
+    # Compare with streaming mode
+    print("\n=== Compare with Streaming Mode ===")
+    runner_streaming = Runner(agent, streaming=True)
+
+    streaming_chunks = []
+    async for chunk in runner_streaming.run("Hello, please say hi back too."):
+        streaming_chunks.append(chunk)
+        if chunk.type == "content_delta":
+            print(chunk.delta, end="", flush=True)
+
+    print(f"\nStreaming chunks received: {len(streaming_chunks)}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

lite_agent-0.8.0/examples/debug_with_logging.py

@@ -0,0 +1,39 @@
+"""
+Debug with full logging enabled.
+"""
+
+import asyncio
+import logging
+
+from lite_agent import Agent, Runner
+
+# Configure logging
+logging.basicConfig(
+    level=logging.DEBUG,
+    format="%(name)s - %(levelname)s - %(message)s",
+)
+
+# Enable specific loggers
+logging.getLogger("lite_agent").setLevel(logging.DEBUG)
+
+
+async def main():
+    agent = Agent(
+        name="TestAgent",
+        model="gpt-4o-mini",
+        instructions="You are helpful.",
+    )
+
+    print("=== Testing Non-Streaming ===")
+    runner = Runner(agent, streaming=False)
+
+    chunks = []
+    async for chunk in runner.run("Hello"):
+        chunks.append(chunk)
+        print(f"Got chunk: {chunk.type}")
+
+    print(f"Total chunks: {len(chunks)}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{lite_agent-0.5.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.8.0/examples/llm_config_demo.py

@@ -0,0 +1,90 @@
+import asyncio
+import logging
+
+from rich.logging import RichHandler
+
+from lite_agent.agent import Agent
+from lite_agent.chat_display import display_messages
+from lite_agent.client import LiteLLMClient, LLMConfig
+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 current weather for a city."""
+    return f"The weather in {city} is sunny, 25°C."
+
+
+# Method 1: Using individual parameters
+agent1 = Agent(
+    model=LiteLLMClient(
+        model="gpt-4o-mini",
+        temperature=0.3,
+        max_tokens=100,
+        top_p=0.8,
+        frequency_penalty=0.1,
+        presence_penalty=0.1,
+        stop=["END"],
+    ),
+    name="Weather Bot (Individual Params)",
+    instructions="You are a weather assistant. Keep responses brief and factual.",
+    tools=[get_weather],
+)
+
+# Method 2: Using LLMConfig object
+llm_config = LLMConfig(
+    temperature=0.8,
+    max_tokens=200,
+    top_p=0.9,
+    frequency_penalty=0.0,
+    presence_penalty=0.0,
+)
+
+agent2 = Agent(
+    model=LiteLLMClient(
+        model="gpt-4o-mini",
+        llm_config=llm_config,
+    ),
+    name="Weather Bot (LLMConfig)",
+    instructions="You are a creative weather assistant. Add some personality to your responses.",
+    tools=[get_weather],
+)
+
+
+async def main():
+    # Test agent with conservative settings (low temperature, short responses)
+    print("=== Testing Agent 1 (Conservative Settings) ===")
+    runner1 = Runner(agent1)
+    resp1 = runner1.run(
+        "What's the weather like in Tokyo?",
+        includes=["assistant_message"],
+    )
+    async for chunk in resp1:
+        logger.info(chunk)
+    display_messages(runner1.messages)
+
+    print("\n" + "=" * 50 + "\n")
+
+    # Test agent with creative settings (high temperature, longer responses)
+    print("=== Testing Agent 2 (Creative Settings) ===")
+    runner2 = Runner(agent2)
+    resp2 = runner2.run(
+        "What's the weather like in Tokyo?",
+        includes=["assistant_message"],
+    )
+    async for chunk in resp2:
+        logger.info(chunk)
+    display_messages(runner2.messages)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())