lite-agent 0.3.0__py3-none-any.whl → 0.4.1__py3-none-any.whl

lite_agent/types/messages.py

@@ -1,9 +1,53 @@
 from collections.abc import Sequence
+from datetime import datetime, timezone
 from typing import Any, Literal, NotRequired, TypedDict
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field, model_validator
 
-from .tool_calls import ToolCall
+
+# Base metadata type
+class MessageMeta(BaseModel):
+    """Base metadata for all message types"""
+
+    sent_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+
+
+class BasicMessageMeta(MessageMeta):
+    """Basic metadata for user messages and function calls"""
+
+    execution_time_ms: int | None = None
+
+
+class LLMResponseMeta(MessageMeta):
+    """Metadata for LLM responses, includes performance metrics"""
+
+    latency_ms: int | None = None
+    output_time_ms: int | None = None
+    input_tokens: int | None = None
+    output_tokens: int | None = None
+
+
+# New unified metadata types
+
+
+class MessageUsage(BaseModel):
+    """Token usage statistics for messages"""
+
+    input_tokens: int | None = None
+    output_tokens: int | None = None
+    total_tokens: int | None = None
+
+
+class AssistantMessageMeta(MessageMeta):
+    """Enhanced metadata for assistant messages"""
+
+    model: str | None = None
+    usage: MessageUsage | None = None
+    total_time_ms: int | None = None
+    latency_ms: int | None = None
+    output_time_ms: int | None = None
+    input_tokens: int | None = None
+    output_tokens: int | None = None
 
 
 class ResponseInputImageDict(TypedDict):
@@ -36,7 +80,7 @@ class SystemMessageDict(TypedDict):
 
 class FunctionCallDict(TypedDict):
     type: Literal["function_call"]
-    function_call_id: str
+    call_id: str
     name: str
     arguments: str
     content: str
@@ -52,18 +96,107 @@ class FunctionCallOutputDict(TypedDict):
 MessageDict = UserMessageDict | AssistantMessageDict | SystemMessageDict | FunctionCallDict | FunctionCallOutputDict
 
 
+# New structured message content types
+class UserTextContent(BaseModel):
+    type: Literal["text"] = "text"
+    text: str
+
+
+class UserImageContent(BaseModel):
+    type: Literal["image"] = "image"
+    image_url: str | None = None
+    file_id: str | None = None
+    detail: Literal["low", "high", "auto"] = "auto"
+
+    @model_validator(mode="after")
+    def validate_image_source(self) -> "UserImageContent":
+        if not self.file_id and not self.image_url:
+            msg = "UserImageContent must have either file_id or image_url"
+            raise ValueError(msg)
+        return self
+
+
+class UserFileContent(BaseModel):
+    type: Literal["file"] = "file"
+    file_id: str
+    file_name: str | None = None
+
+
+UserMessageContent = UserTextContent | UserImageContent | UserFileContent
+
+
+class AssistantTextContent(BaseModel):
+    type: Literal["text"] = "text"
+    text: str
+
+
+class AssistantToolCall(BaseModel):
+    type: Literal["tool_call"] = "tool_call"
+    call_id: str
+    name: str
+    arguments: dict[str, Any] | str
+
+
+class AssistantToolCallResult(BaseModel):
+    type: Literal["tool_call_result"] = "tool_call_result"
+    call_id: str
+    output: str
+    execution_time_ms: int | None = None
+
+
+AssistantMessageContent = AssistantTextContent | AssistantToolCall | AssistantToolCallResult
+
+
+# New structured message types
+class NewUserMessage(BaseModel):
+    """User message with structured content support"""
+
+    role: Literal["user"] = "user"
+    content: list[UserMessageContent]
+    meta: MessageMeta = Field(default_factory=MessageMeta)
+
+
+class NewSystemMessage(BaseModel):
+    """System message"""
+
+    role: Literal["system"] = "system"
+    content: str
+    meta: MessageMeta = Field(default_factory=MessageMeta)
+
+
+class NewAssistantMessage(BaseModel):
+    """Assistant message with structured content and metadata"""
+
+    role: Literal["assistant"] = "assistant"
+    content: list[AssistantMessageContent]
+    meta: AssistantMessageMeta = Field(default_factory=AssistantMessageMeta)
+
+
+# Union type for new structured messages
+NewMessage = NewUserMessage | NewSystemMessage | NewAssistantMessage
+NewMessages = Sequence[NewMessage]
+
+
 # Response API format input types
 class ResponseInputText(BaseModel):
+    type: Literal["input_text"] = "input_text"
     text: str
-    type: Literal["input_text"]
 
 
 class ResponseInputImage(BaseModel):
     detail: Literal["low", "high", "auto"] = "auto"
-    type: Literal["input_image"]
+    type: Literal["input_image"] = "input_image"
     file_id: str | None = None
     image_url: str | None = None
 
+    @model_validator(mode="after")
+    def validate_image_source(self) -> "ResponseInputImage":
+        """Ensure at least one of file_id or image_url is provided."""
+        if not self.file_id and not self.image_url:
+            msg = "ResponseInputImage must have either file_id or image_url"
+            raise ValueError(msg)
+        return self
+
 
 # Compatibility types for old completion API format
 class UserMessageContentItemText(BaseModel):
@@ -80,56 +213,131 @@ class UserMessageContentItemImageURL(BaseModel):
     image_url: UserMessageContentItemImageURLImageURL
 
 
-# Legacy types - keeping for compatibility
+# Legacy compatibility wrapper classes
+class AgentUserMessage(NewUserMessage):
+    def __init__(
+        self,
+        content: str | list[UserMessageContent] | None = None,
+        *,
+        role: Literal["user"] = "user",
+        meta: MessageMeta | None = None,
+    ):
+        if isinstance(content, str):
+            content = [UserTextContent(text=content)]
+        elif content is None:
+            content = []
+        super().__init__(
+            role=role,
+            content=content,
+            meta=meta or MessageMeta(),
+        )
+
+
+class AgentAssistantMessage(NewAssistantMessage):
+    def __init__(
+        self,
+        content: str | list[AssistantMessageContent] | None = None,
+        *,
+        role: Literal["assistant"] = "assistant",
+        meta: AssistantMessageMeta | None = None,
+    ):
+        if isinstance(content, str):
+            content = [AssistantTextContent(text=content)]
+        elif content is None:
+            content = []
+        super().__init__(
+            role=role,
+            content=content,
+            meta=meta or AssistantMessageMeta(),
+        )
+
+
+AgentSystemMessage = NewSystemMessage
+RunnerMessage = NewMessage
+
+
+# Streaming processor types
 class AssistantMessage(BaseModel):
-    id: str
-    index: int
-    role: Literal["assistant"] = "assistant"
-    content: str = ""
-    tool_calls: list[ToolCall] | None = None
-
+    """
+    Temporary assistant message used during streaming processing.
 
-class Message(BaseModel):
-    role: str
-    content: str
-
-
-class AgentUserMessage(BaseModel):
-    role: Literal["user"]
-    content: str | Sequence[ResponseInputText | ResponseInputImage | UserMessageContentItemText | UserMessageContentItemImageURL]
-
-
-class AgentAssistantMessage(BaseModel):
-    role: Literal["assistant"]
-    content: str
-
-
-class AgentSystemMessage(BaseModel):
-    role: Literal["system"]
-    content: str
-
-
-class AgentFunctionToolCallMessage(BaseModel):
-    arguments: str
-    type: Literal["function_call"]
-    function_call_id: str
-    name: str
-    content: str
-
-
-class AgentFunctionCallOutput(BaseModel):
-    call_id: str
-    output: str
-    type: Literal["function_call_output"]
+    This is a simplified message format used internally by completion event processors
+    to accumulate streaming content before converting to the final NewAssistantMessage format.
+    """
 
+    role: Literal["assistant"] = "assistant"
+    id: str = ""
+    index: int | None = None
+    content: str = ""
+    tool_calls: list[Any] | None = None
 
-RunnerMessage = AgentUserMessage | AgentAssistantMessage | AgentSystemMessage | AgentFunctionToolCallMessage | AgentFunctionCallOutput
-AgentMessage = RunnerMessage | AgentSystemMessage
 
 # Enhanced type definitions for better type hints
-# Supports BaseModel instances, TypedDict, and plain dict
-FlexibleRunnerMessage = RunnerMessage | MessageDict | dict[str, Any]
+# Supports new message format, legacy messages, and dict (for backward compatibility)
+FlexibleRunnerMessage = NewMessage | AgentUserMessage | AgentAssistantMessage | dict[str, Any]
 RunnerMessages = Sequence[FlexibleRunnerMessage]
 
+
 # Type alias for user input - supports string, single message, or sequence of messages
 UserInput = str | FlexibleRunnerMessage | RunnerMessages
+
+
+def user_message_to_llm_dict(message: NewUserMessage) -> dict[str, Any]:
+    """Convert NewUserMessage to dict for LLM API"""
+    # Convert content to simplified format for LLM
+    content = message.content[0].text if len(message.content) == 1 and message.content[0].type == "text" else [item.model_dump() for item in message.content]
+    return {"role": message.role, "content": content}
+
+
+def system_message_to_llm_dict(message: NewSystemMessage) -> dict[str, Any]:
+    """Convert NewSystemMessage to dict for LLM API"""
+    return {"role": message.role, "content": message.content}
+
+
+def assistant_message_to_llm_dict(message: NewAssistantMessage) -> dict[str, Any]:
+    """Convert NewAssistantMessage to dict for LLM API"""
+    # Separate text content from tool calls
+    text_parts = []
+    tool_calls = []
+
+    for item in message.content:
+        if item.type == "text":
+            text_parts.append(item.text)
+        elif item.type == "tool_call":
+            tool_calls.append(
+                {
+                    "id": item.call_id,
+                    "type": "function",
+                    "function": {
+                        "name": item.name,
+                        "arguments": item.arguments if isinstance(item.arguments, str) else str(item.arguments),
+                    },
+                },
+            )
+
+    result = {
+        "role": message.role,
+        "content": " ".join(text_parts) if text_parts else None,
+    }
+
+    if tool_calls:
+        result["tool_calls"] = tool_calls
+
+    return result
+
+
+def message_to_llm_dict(message: NewMessage) -> dict[str, Any]:
+    """Convert any NewMessage to dict for LLM API"""
+    if isinstance(message, NewUserMessage):
+        return user_message_to_llm_dict(message)
+    if isinstance(message, NewSystemMessage):
+        return system_message_to_llm_dict(message)
+    if isinstance(message, NewAssistantMessage):
+        return assistant_message_to_llm_dict(message)
+    # Fallback
+    return message.model_dump(exclude={"meta"})
+
+
+def messages_to_llm_format(messages: Sequence[NewMessage]) -> list[dict[str, Any]]:
+    """Convert a sequence of NewMessage to LLM format, excluding meta data"""
+    return [message_to_llm_dict(message) for message in messages]

{lite_agent-0.3.0.dist-info → lite_agent-0.4.1.dist-info}/METADATA

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

lite_agent-0.4.1.dist-info/RECORD

@@ -0,0 +1,23 @@
+lite_agent/__init__.py,sha256=Swuefee0etSiaDnn30K2hBNV9UI3hIValW3A-pRE7e0,338
+lite_agent/agent.py,sha256=t4AYlw3aF2DCPXf2W3s7aow0ql1ON5O2Q8VVuyoN6UI,22936
+lite_agent/chat_display.py,sha256=b0sUH3fkutc4e_KAKH7AtPu2msyLloNIAiWqCNavdds,30533
+lite_agent/client.py,sha256=m2jfBPIsleMZ1QCczjyHND-PIF17kQh4RTuf5FaipGM,2571
+lite_agent/loggers.py,sha256=XkNkdqwD_nQGfhQJ-bBWT7koci_mMkNw3aBpyMhOICw,57
+lite_agent/message_transfers.py,sha256=9qucjc-uSIXvVfhcmVRC_0lp0Q8sWp99dV4ReCh6ZlI,4428
+lite_agent/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lite_agent/runner.py,sha256=ACZuFJ2dNpdg4Tzeg-bl4Th1X14uhHJdELcBWe5E_Us,40155
+lite_agent/processors/__init__.py,sha256=ybpAzpMBIE9v5I24wIBZRXeaOaPNTmoKH13aofgNI6Q,234
+lite_agent/processors/completion_event_processor.py,sha256=8fQYRofgBd8t0V3oUakTOmZdv5Q9tCuzADGCGvVgy0k,13442
+lite_agent/processors/response_event_processor.py,sha256=CElJMUzLs8mklVqJtoLiVu-NTq0Dz2NNd9YdAKpjgE0,8088
+lite_agent/stream_handlers/__init__.py,sha256=a5s1GZr42uvndtcQqEhK2cnjGkK8ZFTAZCj3J61Bb5E,209
+lite_agent/stream_handlers/litellm.py,sha256=3D0u7R2ADA8kDwpFImZlw20o-CsmFXVLvq4nvwwD0Rk,2922
+lite_agent/templates/handoffs_source_instructions.xml.j2,sha256=2XsXQlBzk38qbxGrfyt8y2b0KlZmsV_1xavLufcdkHc,428
+lite_agent/templates/handoffs_target_instructions.xml.j2,sha256=gSbWVYYcovPKbGpFc0kqGSJ5Y5UC3fOHyUmZfcrDgSE,356
+lite_agent/templates/wait_for_user_instructions.xml.j2,sha256=wXbcYD5Q1FaCGVBm3Hz_Cp7nnoK7KzloP0ao-jYMwPk,231
+lite_agent/types/__init__.py,sha256=QKuhjFWRcpAlsBK9JYgoCABpoQExwhuyGudJoiiqQfs,3093
+lite_agent/types/events.py,sha256=mFMqV55WWJbPDyb_P61nd3qMLpEnwZgVY6NTKFkINkg,2389
+lite_agent/types/messages.py,sha256=c7nTIWqXNo562het_vaWcZvsoy-adkARwAYn4JNqm0c,9897
+lite_agent/types/tool_calls.py,sha256=Xnut8-2-Ld9vgA2GKJY6BbFlBaAv_n4W7vo7Jx21A-E,260
+lite_agent-0.4.1.dist-info/METADATA,sha256=iQIr1OAdiVK5Ad6Uho65OpqS1u4YC9sOaoxKZ1FssOs,3456
+lite_agent-0.4.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lite_agent-0.4.1.dist-info/RECORD,,

lite_agent/processors/stream_chunk_processor.py

@@ -1,106 +0,0 @@
-import litellm
-from litellm.types.utils import ChatCompletionDeltaToolCall, ModelResponseStream, StreamingChoices
-
-from lite_agent.loggers import logger
-from lite_agent.types import AssistantMessage, ToolCall, ToolCallFunction
-
-
-class StreamChunkProcessor:
-    """Processor for handling streaming responses"""
-
-    def __init__(self) -> None:
-        self._current_message: AssistantMessage | None = None
-
-    def initialize_message(self, chunk: ModelResponseStream, choice: StreamingChoices) -> None:
-        """Initialize the message object"""
-        delta = choice.delta
-        if delta.role != "assistant":
-            logger.warning("Skipping chunk with role: %s", delta.role)
-            return
-        self._current_message = AssistantMessage(
-            id=chunk.id,
-            index=choice.index,
-            role=delta.role,
-            content="",
-        )
-        logger.debug('Initialized new message: "%s"', self._current_message.id)
-
-    def update_content(self, content: str) -> None:
-        """Update message content"""
-        if self._current_message and content:
-            self._current_message.content += content
-
-    def _initialize_tool_calls(self, tool_calls: list[litellm.ChatCompletionMessageToolCall]) -> None:
-        """Initialize tool calls"""
-        if not self._current_message:
-            return
-
-        self._current_message.tool_calls = []
-        for call in tool_calls:
-            logger.debug("Create new tool call: %s", call.id)
-
-    def _update_tool_calls(self, tool_calls: list[litellm.ChatCompletionMessageToolCall]) -> None:
-        """Update existing tool calls"""
-        if not self._current_message:
-            return
-        if not hasattr(self._current_message, "tool_calls"):
-            self._current_message.tool_calls = []
-        if not self._current_message.tool_calls:
-            return
-        if not tool_calls:
-            return
-        for current_call, new_call in zip(self._current_message.tool_calls, tool_calls, strict=False):
-            if new_call.function.arguments and current_call.function.arguments:
-                current_call.function.arguments += new_call.function.arguments
-            if new_call.type and new_call.type == "function":
-                current_call.type = new_call.type
-            elif new_call.type:
-                logger.warning("Unexpected tool call type: %s", new_call.type)
-
-    def update_tool_calls(self, tool_calls: list[ChatCompletionDeltaToolCall]) -> None:
-        """Handle tool call updates"""
-        if not tool_calls:
-            return
-        for call in tool_calls:
-            if call.id:
-                if call.type == "function":
-                    new_tool_call = ToolCall(
-                        id=call.id,
-                        type=call.type,
-                        function=ToolCallFunction(
-                            name=call.function.name or "",
-                            arguments=call.function.arguments,
-                        ),
-                        index=call.index,
-                    )
-                    if self._current_message is not None:
-                        if self._current_message.tool_calls is None:
-                            self._current_message.tool_calls = []
-                        self._current_message.tool_calls.append(new_tool_call)
-                else:
-                    logger.warning("Unexpected tool call type: %s", call.type)
-            elif self._current_message is not None and self._current_message.tool_calls is not None and call.index is not None and 0 <= call.index < len(self._current_message.tool_calls):
-                existing_call = self._current_message.tool_calls[call.index]
-                if call.function.arguments:
-                    if existing_call.function.arguments is None:
-                        existing_call.function.arguments = ""
-                    existing_call.function.arguments += call.function.arguments
-            else:
-                logger.warning("Cannot update tool call: current_message or tool_calls is None, or invalid index.")
-
-    def handle_usage_info(self, chunk: ModelResponseStream) -> litellm.Usage | None:
-        """Handle usage info, return whether this chunk should be skipped"""
-        return getattr(chunk, "usage", None)
-
-    @property
-    def is_initialized(self) -> bool:
-        """Check if the current message is initialized"""
-        return self._current_message is not None
-
-    @property
-    def current_message(self) -> AssistantMessage:
-        """Get the current message being processed"""
-        if not self._current_message:
-            msg = "No current message initialized. Call initialize_message first."
-            raise ValueError(msg)
-        return self._current_message