lite-agent 0.9.0__py3-none-any.whl → 0.11.0__py3-none-any.whl

lite_agent/utils/message_converter.py

@@ -0,0 +1,232 @@
+"""Message format converters for API compatibility."""
+
+from typing import Any
+
+from lite_agent.loggers import logger
+from lite_agent.types import (
+    AssistantTextContent,
+    AssistantToolCall,
+    AssistantToolCallResult,
+    NewAssistantMessage,
+    NewSystemMessage,
+    NewUserMessage,
+    RunnerMessages,
+    message_to_llm_dict,
+)
+
+
+class MessageFormatConverter:
+    """Converter for different message API formats."""
+
+    @staticmethod
+    def to_completion_format(messages: RunnerMessages) -> list[dict]:
+        """Convert messages to completion API format.
+
+        This method replaces the complex _convert_responses_to_completions_format
+        with a cleaner, more maintainable implementation.
+        """
+        logger.debug(f"Converting {len(messages)} messages to completion format")
+        converted_messages = []
+
+        for message in messages:
+            if isinstance(message, (NewUserMessage, NewSystemMessage)):
+                # Handle user and system messages directly
+                converted_msg = message_to_llm_dict(message)
+                if isinstance(message, NewUserMessage):
+                    converted_msg = MessageFormatConverter._convert_user_content(converted_msg)
+                converted_messages.append(converted_msg)
+
+            elif isinstance(message, NewAssistantMessage):
+                # Handle assistant messages with tool calls
+                assistant_msg, tool_results = MessageFormatConverter._process_assistant_message(message)
+                converted_messages.append(assistant_msg)
+                converted_messages.extend(tool_results)
+
+            elif isinstance(message, dict):
+                converted_msg = MessageFormatConverter._handle_legacy_dict_message(message)
+                if converted_msg:
+                    converted_messages.extend(converted_msg if isinstance(converted_msg, list) else [converted_msg])
+
+        logger.debug(f"Completed conversion: {len(messages)} -> {len(converted_messages)} messages")
+        return converted_messages
+
+    @staticmethod
+    def _process_assistant_message(message: NewAssistantMessage) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+        """Process assistant message and extract tool calls/results."""
+        text_parts = []
+        tool_calls = []
+        tool_results = []
+
+        for content_item in message.content:
+            if content_item.type == "text":
+                text_parts.append(content_item.text)
+            elif content_item.type == "tool_call":
+                tool_calls.append({
+                    "id": content_item.call_id,
+                    "type": "function",
+                    "function": {
+                        "name": content_item.name,
+                        "arguments": content_item.arguments if isinstance(content_item.arguments, str) else str(content_item.arguments),
+                    },
+                    "index": len(tool_calls),
+                })
+            elif content_item.type == "tool_call_result":
+                tool_results.append({
+                    "role": "tool",
+                    "tool_call_id": content_item.call_id,
+                    "content": content_item.output,
+                })
+
+        # Create assistant message
+        assistant_msg = {
+            "role": "assistant",
+            "content": " ".join(text_parts) if text_parts else None,
+        }
+
+        if tool_calls:
+            assistant_msg["tool_calls"] = tool_calls
+
+        return assistant_msg, tool_results
+
+    @staticmethod
+    def _convert_user_content(message_dict: dict[str, Any]) -> dict[str, Any]:
+        """Convert user message content for completion API."""
+        content = message_dict.get("content")
+        if not isinstance(content, list):
+            return message_dict
+
+        converted_content = []
+        for item in content:
+            # Handle both Pydantic objects and dicts
+            if hasattr(item, "model_dump"):
+                item_dict = item.model_dump()
+            elif isinstance(item, dict):
+                item_dict = item
+            else:
+                converted_content.append(item)
+                continue
+
+            item_type = item_dict.get("type")
+            if item_type in ["input_text", "text"]:
+                converted_content.append({
+                    "type": "text",
+                    "text": item_dict["text"],
+                })
+            elif item_type in ["input_image", "image"]:
+                if item_dict.get("file_id"):
+                    logger.warning("File ID input not supported for Completion API, skipping")
+                    continue
+
+                if not item_dict.get("image_url"):
+                    logger.warning("Image content missing image_url, skipping")
+                    continue
+
+                image_data = {"url": item_dict["image_url"]}
+                detail = item_dict.get("detail", "auto")
+                if detail:
+                    image_data["detail"] = detail
+
+                converted_content.append({
+                    "type": "image_url",
+                    "image_url": image_data,
+                })
+            else:
+                # Keep other formats as-is
+                converted_content.append(item_dict)
+
+        result = message_dict.copy()
+        result["content"] = converted_content
+        return result
+
+    @staticmethod
+    def _handle_legacy_dict_message(message: dict) -> dict | list[dict] | None:
+        """Handle legacy dict message formats with simplified logic."""
+        message_type = message.get("type")
+        role = message.get("role")
+
+        if message_type == "function_call_output":
+            return {
+                "role": "tool",
+                "tool_call_id": message.get("call_id", ""),
+                "content": message.get("output", ""),
+            }
+        if message_type == "function_call":
+            # Function calls should be handled as part of assistant messages
+            logger.debug("Standalone function_call message encountered, may be processed with assistant message")
+            return None
+        if role in ["user", "system", "assistant"]:
+            # Standard message, convert content if needed
+            converted_msg = message.copy()
+            if role == "user" and isinstance(message.get("content"), list):
+                converted_msg = MessageFormatConverter._convert_user_content(converted_msg)
+            return converted_msg
+        logger.warning(f"Unknown message format: {message}")
+        return None
+
+
+class ResponsesFormatConverter:
+    """Converter for responses API format."""
+
+    @staticmethod
+    def to_responses_format(messages: RunnerMessages) -> list[dict[str, Any]]:
+        """Convert messages to responses API format."""
+        result = []
+
+        for message in messages:
+            if isinstance(message, NewAssistantMessage):
+                # Convert assistant message content directly
+                contents = []
+                for item in message.content:
+                    if isinstance(item, AssistantTextContent):
+                        contents.append({
+                            "role": "assistant",
+                            "content": item.text,
+                        })
+                    elif isinstance(item, AssistantToolCall):
+                        contents.append({
+                            "type": "function_call",
+                            "call_id": item.call_id,
+                            "name": item.name,
+                            "arguments": item.arguments,
+                        })
+                    elif isinstance(item, AssistantToolCallResult):
+                        contents.append({
+                            "type": "function_call_output",
+                            "call_id": item.call_id,
+                            "output": item.output,
+                        })
+                result.extend(contents)
+
+            elif isinstance(message, NewUserMessage):
+                contents = []
+                for item in message.content:
+                    match item.type:
+                        case "text":
+                            contents.append({
+                                "type": "input_text",
+                                "text": item.text,
+                            })
+                        case "image":
+                            contents.append({
+                                "type": "input_image",
+                                "image_url": item.image_url,
+                            })
+                        case "file":
+                            contents.append({
+                                "type": "input_file",
+                                "file_id": item.file_id,
+                                "file_name": item.file_name,
+                            })
+
+                result.append({
+                    "role": message.role,
+                    "content": contents,
+                })
+
+            elif isinstance(message, NewSystemMessage):
+                result.append({
+                    "role": "system",
+                    "content": message.content,
+                })
+
+        return result

lite_agent/utils/message_state_manager.py

@@ -0,0 +1,152 @@
+"""Message state management utilities to prevent race conditions."""
+
+import asyncio
+from typing import Any
+
+from lite_agent.loggers import logger
+from lite_agent.types import (
+    AssistantMessageMeta,
+    AssistantTextContent,
+    AssistantToolCall,
+    AssistantToolCallResult,
+    NewAssistantMessage,
+)
+
+
+class MessageStateManager:
+    """Thread-safe manager for assistant message state during streaming."""
+
+    def __init__(self):
+        self._current_message: NewAssistantMessage | None = None
+        self._lock = asyncio.Lock()
+        self._finalized = False
+
+    async def start_message(self, content: str = "", meta: AssistantMessageMeta | None = None) -> None:
+        """Start a new assistant message safely."""
+        async with self._lock:
+            if self._current_message is not None:
+                logger.warning("Starting new message while previous message not finalized")
+
+            if meta is None:
+                meta = AssistantMessageMeta()
+
+            self._current_message = NewAssistantMessage(
+                content=[AssistantTextContent(text=content)] if content else [],
+                meta=meta,
+            )
+            self._finalized = False
+            logger.debug("Started new assistant message")
+
+    async def ensure_message_exists(self) -> NewAssistantMessage:
+        """Ensure current message exists, create if necessary."""
+        async with self._lock:
+            if self._current_message is None:
+                await self._start_message_internal()
+            if self._current_message is None:
+                msg = "Failed to create current assistant message"
+                raise RuntimeError(msg)
+            return self._current_message
+
+    async def _start_message_internal(self) -> None:
+        """Internal method to start message without lock (already locked)."""
+        meta = AssistantMessageMeta()
+        self._current_message = NewAssistantMessage(
+            content=[],
+            meta=meta,
+        )
+        self._finalized = False
+
+    async def add_text_delta(self, delta: str) -> None:
+        """Add text delta to current message safely."""
+        if not delta:
+            return
+
+        async with self._lock:
+            if self._current_message is None:
+                logger.debug("Creating new message for text delta")
+                await self._start_message_internal()
+
+            if self._current_message is None:
+                msg = "Failed to ensure current message exists"
+                raise RuntimeError(msg)
+
+            # Find existing text content or create new one
+            for item in self._current_message.content:
+                if item.type == "text":
+                    logger.debug(f"Appending text delta (length: {len(delta)})")
+                    item.text += delta
+                    return
+
+            # No text content found, add new one
+            logger.debug(f"Adding new text content with delta (length: {len(delta)})")
+            self._current_message.content.append(AssistantTextContent(text=delta))
+
+    async def add_tool_call(self, tool_call: AssistantToolCall) -> None:
+        """Add tool call to current message safely."""
+        async with self._lock:
+            if self._current_message is None:
+                await self._start_message_internal()
+
+            if self._current_message is None:
+                msg = "Failed to ensure current message exists"
+                raise RuntimeError(msg)
+
+            self._current_message.content.append(tool_call)
+            logger.debug(f"Added tool call: {tool_call.name}")
+
+    async def add_tool_result(self, result: AssistantToolCallResult) -> None:
+        """Add tool call result to current message safely."""
+        async with self._lock:
+            if self._current_message is None:
+                await self._start_message_internal()
+
+            if self._current_message is None:
+                msg = "Failed to ensure current message exists"
+                raise RuntimeError(msg)
+
+            self._current_message.content.append(result)
+            logger.debug(f"Added tool result for call: {result.call_id}")
+
+    async def update_meta(self, **kwargs: Any) -> None:  # noqa: ANN401
+        """Update message metadata safely."""
+        async with self._lock:
+            if self._current_message is None:
+                return
+
+            for key, value in kwargs.items():
+                if hasattr(self._current_message.meta, key):
+                    setattr(self._current_message.meta, key, value)
+
+    async def get_current_message(self) -> NewAssistantMessage | None:
+        """Get current message safely."""
+        async with self._lock:
+            return self._current_message
+
+    async def finalize_message(self) -> NewAssistantMessage | None:
+        """Finalize and return current message, reset state."""
+        async with self._lock:
+            if self._current_message is None or self._finalized:
+                return None
+
+            finalized_message = self._current_message
+            self._current_message = None
+            self._finalized = True
+            logger.debug("Finalized assistant message")
+            return finalized_message
+
+    async def reset(self) -> None:
+        """Reset state manager."""
+        async with self._lock:
+            self._current_message = None
+            self._finalized = False
+            logger.debug("Reset message state manager")
+
+    @property
+    def has_current_message(self) -> bool:
+        """Check if there's a current message (non-blocking check)."""
+        return self._current_message is not None
+
+    @property
+    def is_finalized(self) -> bool:
+        """Check if current message is finalized (non-blocking check)."""
+        return self._finalized

{lite_agent-0.9.0.dist-info → lite_agent-0.11.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lite-agent
-Version: 0.9.0
+Version: 0.11.0
 Summary: A lightweight, extensible framework for building AI agent.
 Author-email: Jianqi Pan <jannchie@gmail.com>
 License: MIT
@@ -13,6 +13,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Communications :: Chat
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules

{lite_agent-0.9.0.dist-info → lite_agent-0.11.0.dist-info}/RECORD

@@ -1,12 +1,12 @@
 lite_agent/__init__.py,sha256=Swuefee0etSiaDnn30K2hBNV9UI3hIValW3A-pRE7e0,338
-lite_agent/agent.py,sha256=Jls9fwGgMLpFunT8Tr3Cp8P9AyeuvrHklWyFD3mhvtM,32061
-lite_agent/chat_display.py,sha256=IG2oM3FtpcfcduG7b6yt2mLFpG-Z6zHxXUN_J1XNVp8,40563
-lite_agent/client.py,sha256=PTsic12TVYklUKJzb9gk8-FWl2yhNkSYRS_Cs5dosEU,8677
+lite_agent/agent.py,sha256=UXmQY8vhi_2DIPcWkji0B_pCGlBvZLfx6YoNaUJO6Wc,18028
+lite_agent/chat_display.py,sha256=6gPgutMj7hCUOH6QBcC2f4Bhc93Gdq4vBa_1y6QKt2g,40793
+lite_agent/client.py,sha256=-9BXLhAp3bGJsdKJ02lLpPJeHQKyHKQwhebZ6WCYh_k,9988
 lite_agent/constants.py,sha256=_xIDdQwaJrWk8N_62o-KYEo3jj1waPJ0ZOd3hHybKNo,718
 lite_agent/loggers.py,sha256=XkNkdqwD_nQGfhQJ-bBWT7koci_mMkNw3aBpyMhOICw,57
 lite_agent/message_transfers.py,sha256=N9ViK7Gxqqa1sd3V_hkNuQ9fUipg7M95l-sVBBG2Id4,5357
 lite_agent/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lite_agent/runner.py,sha256=iv4xqRJKH9PXyg7goQIBd6IfNODUo5GfjBdlZdxv3kw,45150
+lite_agent/runner.py,sha256=qcKS12JRnzwdBDzOlxn8TNJU9nf4Dz2ZzLvD_7yUt2s,43819
 lite_agent/processors/__init__.py,sha256=ybpAzpMBIE9v5I24wIBZRXeaOaPNTmoKH13aofgNI6Q,234
 lite_agent/processors/completion_event_processor.py,sha256=zoWvs8dfrIkCSITGtS-4Hpve3WFCA0UUsMvYifL2fw0,13010
 lite_agent/processors/response_event_processor.py,sha256=Jr3cj1ItJ8aq9UBhEEjDwWDnPNOZ2ZXjWJ3-g4ghkhM,8514
@@ -19,13 +19,16 @@ lite_agent/stream_handlers/litellm.py,sha256=3D0u7R2ADA8kDwpFImZlw20o-CsmFXVLvq4
 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=Zk7Uf1ScOJ5IGfeiJ3PM2FzPD4wmiq-9jzQzLpPpecI,3147
+lite_agent/types/__init__.py,sha256=S28EuUSqvZh18cD0SconkGQpGLPz7l61ZHDwGgTR9vI,3130
 lite_agent/types/events.py,sha256=mFMqV55WWJbPDyb_P61nd3qMLpEnwZgVY6NTKFkINkg,2389
-lite_agent/types/messages.py,sha256=QjWL2McEWckVy7AIogl2HQkUy-XXdNAAcB0oCNnojbg,9922
+lite_agent/types/messages.py,sha256=aq36BOLktd6rwxknqVXOLK7pLlwYktaBFn0Sp71l6nw,9993
 lite_agent/types/tool_calls.py,sha256=Xnut8-2-Ld9vgA2GKJY6BbFlBaAv_n4W7vo7Jx21A-E,260
 lite_agent/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lite_agent/utils/message_builder.py,sha256=L15e4-qSlCYUNNtJ1zB-EPviuoxH9bTEVNlkvaH0q3U,8142
+lite_agent/utils/advanced_message_builder.py,sha256=3U1PQrbdYQuIkv3j83TggDu3TmFN57TPZU32GTyPe4E,10196
+lite_agent/utils/message_builder.py,sha256=J-yycL9pXSO9MbgC5NEGqvoP1LC2Nxe9r2YRWXoaIAQ,8126
+lite_agent/utils/message_converter.py,sha256=5HmNncTl71TD2M_6Ezz1Tnfavzna8DQYb4-D47Du7mA,9165
+lite_agent/utils/message_state_manager.py,sha256=rFUyqyd_7NdJRtyqsAWGcfwrDIlD6gK2dBDSDx1eGBs,5766
 lite_agent/utils/metrics.py,sha256=RzOEhCWxbLmmIEkzaxOJ6tAdthI8dv2Foc98Lq8afOQ,1915
-lite_agent-0.9.0.dist-info/METADATA,sha256=e1eaVu37mmGYrHI_KofiLTOHCerY6fXY5BPZoIXbTO4,3486
-lite_agent-0.9.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lite_agent-0.9.0.dist-info/RECORD,,
+lite_agent-0.11.0.dist-info/METADATA,sha256=WRwZ5xKujQt0pJdWvIBvhYQsnedrsW9WUqOseXQiVhU,3538
+lite_agent-0.11.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lite_agent-0.11.0.dist-info/RECORD,,