lite-agent 0.5.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

lite_agent/agent.py

@@ -5,11 +5,10 @@ from typing import Any, Optional
 
 from funcall import Funcall
 from jinja2 import Environment, FileSystemLoader
-from litellm import CustomStreamWrapper
 
 from lite_agent.client import BaseLLMClient, LiteLLMClient, ReasoningConfig
 from lite_agent.loggers import logger
-from lite_agent.stream_handlers import litellm_completion_stream_handler, litellm_response_stream_handler
+from lite_agent.response_handlers import CompletionResponseHandler, ResponsesAPIHandler
 from lite_agent.types import AgentChunk, FunctionCallEvent, FunctionCallOutputEvent, RunnerMessages, ToolCall, message_to_llm_dict, system_message_to_llm_dict
 from lite_agent.types.messages import NewAssistantMessage, NewSystemMessage, NewUserMessage
 
@@ -22,7 +21,7 @@ WAIT_FOR_USER_INSTRUCTIONS_TEMPLATE = jinja_env.get_template("wait_for_user_inst
 
 
 class Agent:
-    def __init__(  # noqa: PLR0913
+    def __init__(
         self,
         *,
         model: str | BaseLLMClient,
@@ -280,6 +279,7 @@ class Agent:
         messages: RunnerMessages,
         record_to_file: Path | None = None,
         reasoning: ReasoningConfig = None,
+        streaming: bool = True,
     ) -> AsyncGenerator[AgentChunk, None]:
         # Apply message transfer callback if provided - always use legacy format for LLM compatibility
         processed_messages = messages
@@ -296,19 +296,19 @@ class Agent:
             tools=tools,
             tool_choice="auto",  # TODO: make this configurable
             reasoning=reasoning,
+            streaming=streaming,
         )
 
-        # Ensure resp is a CustomStreamWrapper
-        if isinstance(resp, CustomStreamWrapper):
-            return litellm_completion_stream_handler(resp, record_to=record_to_file)
-        msg = "Response is not a CustomStreamWrapper, cannot stream chunks."
-        raise TypeError(msg)
+        # Use response handler for unified processing
+        handler = CompletionResponseHandler()
+        return handler.handle(resp, streaming, record_to_file)
 
     async def responses(
         self,
         messages: RunnerMessages,
         record_to_file: Path | None = None,
         reasoning: ReasoningConfig = None,
+        streaming: bool = True,
     ) -> AsyncGenerator[AgentChunk, None]:
         # Apply message transfer callback if provided - always use legacy format for LLM compatibility
         processed_messages = messages
@@ -324,8 +324,11 @@ class Agent:
             tools=tools,
             tool_choice="auto",  # TODO: make this configurable
             reasoning=reasoning,
+            streaming=streaming,
         )
-        return litellm_response_stream_handler(resp, record_to=record_to_file)
+        # Use response handler for unified processing
+        handler = ResponsesAPIHandler()
+        return handler.handle(resp, streaming, record_to_file)
 
     async def list_require_confirm_tools(self, tool_calls: Sequence[ToolCall] | None) -> Sequence[ToolCall]:
         if not tool_calls:
@@ -539,3 +542,4 @@ class Agent:
             required=[],
             handler=wait_for_user_handler,
         )
+

lite_agent/chat_display.py

@@ -437,7 +437,7 @@ def display_messages(
         )
 
 
-def _display_single_message_compact(  # noqa: PLR0913
+def _display_single_message_compact(
     message: FlexibleRunnerMessage,
     *,
     index: int | None = None,

lite_agent/client.py

@@ -5,6 +5,7 @@ from typing import Any, Literal
 import litellm
 from openai.types.chat import ChatCompletionToolParam
 from openai.types.responses import FunctionToolParam
+from pydantic import BaseModel
 
 ReasoningEffort = Literal["minimal", "low", "medium", "high"]
 ThinkingConfig = dict[str, Any] | None
@@ -18,6 +19,17 @@ ReasoningConfig = (
 )
 
 
+class LLMConfig(BaseModel):
+    """LLM generation parameters configuration."""
+
+    temperature: float | None = None
+    max_tokens: int | None = None
+    top_p: float | None = None
+    frequency_penalty: float | None = None
+    presence_penalty: float | None = None
+    stop: list[str] | str | None = None
+
+
 def parse_reasoning_config(reasoning: ReasoningConfig) -> tuple[ReasoningEffort | None, ThinkingConfig]:
     """
     解析统一的推理配置，返回 reasoning_effort 和 thinking_config。
@@ -36,7 +48,10 @@ def parse_reasoning_config(reasoning: ReasoningConfig) -> tuple[ReasoningEffort
         return None, None
     if isinstance(reasoning, str):
         # 字符串类型，使用 reasoning_effort
-        return reasoning, None
+        # 确保字符串是有效的 ReasoningEffort 值
+        if reasoning in ("minimal", "low", "medium", "high"):
+            return reasoning, None  # type: ignore[return-value]
+        return None, None
     if isinstance(reasoning, dict):
         # 字典类型，使用 thinking_config
         return None, reasoning
@@ -58,13 +73,24 @@ class BaseLLMClient(abc.ABC):
         api_base: str | None = None,
         api_version: str | None = None,
         reasoning: ReasoningConfig = None,
+        llm_config: LLMConfig | None = None,
+        **llm_params: Any,  # noqa: ANN401
     ):
         self.model = model
         self.api_key = api_key
         self.api_base = api_base
         self.api_version = api_version
 
+        # 处理 LLM 生成参数
+        if llm_config is not None:
+            self.llm_config = llm_config
+        else:
+            # 从 **llm_params 创建配置
+            self.llm_config = LLMConfig(**llm_params)
+
         # 处理推理配置
+        self.reasoning_effort: ReasoningEffort | None
+        self.thinking_config: ThinkingConfig
         self.reasoning_effort, self.thinking_config = parse_reasoning_config(reasoning)
 
     @abc.abstractmethod
@@ -74,6 +100,7 @@ class BaseLLMClient(abc.ABC):
         tools: list[ChatCompletionToolParam] | None = None,
         tool_choice: str = "auto",
         reasoning: ReasoningConfig = None,
+        streaming: bool = True,
         **kwargs: Any,  # noqa: ANN401
     ) -> Any:  # noqa: ANN401
         """Perform a completion request to the LLM."""
@@ -85,6 +112,7 @@ class BaseLLMClient(abc.ABC):
         tools: list[FunctionToolParam] | None = None,
         tool_choice: Literal["none", "auto", "required"] = "auto",
         reasoning: ReasoningConfig = None,
+        streaming: bool = True,
         **kwargs: Any,  # noqa: ANN401
     ) -> Any:  # noqa: ANN401
         """Perform a response request to the LLM."""
@@ -108,6 +136,7 @@ class LiteLLMClient(BaseLLMClient):
         tools: list[ChatCompletionToolParam] | None = None,
         tool_choice: str = "auto",
         reasoning: ReasoningConfig = None,
+        streaming: bool = True,
         **kwargs: Any,  # noqa: ANN401
     ) -> Any:  # noqa: ANN401
         """Perform a completion request to the Litellm API."""
@@ -126,10 +155,24 @@ class LiteLLMClient(BaseLLMClient):
             "api_version": self.api_version,
             "api_key": self.api_key,
             "api_base": self.api_base,
-            "stream": True,
+            "stream": streaming,
             **kwargs,
         }
 
+        # Add LLM generation parameters if specified
+        if self.llm_config.temperature is not None:
+            completion_params["temperature"] = self.llm_config.temperature
+        if self.llm_config.max_tokens is not None:
+            completion_params["max_tokens"] = self.llm_config.max_tokens
+        if self.llm_config.top_p is not None:
+            completion_params["top_p"] = self.llm_config.top_p
+        if self.llm_config.frequency_penalty is not None:
+            completion_params["frequency_penalty"] = self.llm_config.frequency_penalty
+        if self.llm_config.presence_penalty is not None:
+            completion_params["presence_penalty"] = self.llm_config.presence_penalty
+        if self.llm_config.stop is not None:
+            completion_params["stop"] = self.llm_config.stop
+
         # Add reasoning parameters if specified
         if final_reasoning_effort is not None:
             completion_params["reasoning_effort"] = final_reasoning_effort
@@ -144,6 +187,7 @@ class LiteLLMClient(BaseLLMClient):
         tools: list[FunctionToolParam] | None = None,
         tool_choice: Literal["none", "auto", "required"] = "auto",
         reasoning: ReasoningConfig = None,
+        streaming: bool = True,
         **kwargs: Any,  # noqa: ANN401
     ) -> Any:  # type: ignore[return]  # noqa: ANN401
         """Perform a response request to the Litellm API."""
@@ -164,11 +208,25 @@ class LiteLLMClient(BaseLLMClient):
             "api_version": self.api_version,
             "api_key": self.api_key,
             "api_base": self.api_base,
-            "stream": True,
+            "stream": streaming,
             "store": False,
             **kwargs,
         }
 
+        # Add LLM generation parameters if specified
+        if self.llm_config.temperature is not None:
+            response_params["temperature"] = self.llm_config.temperature
+        if self.llm_config.max_tokens is not None:
+            response_params["max_tokens"] = self.llm_config.max_tokens
+        if self.llm_config.top_p is not None:
+            response_params["top_p"] = self.llm_config.top_p
+        if self.llm_config.frequency_penalty is not None:
+            response_params["frequency_penalty"] = self.llm_config.frequency_penalty
+        if self.llm_config.presence_penalty is not None:
+            response_params["presence_penalty"] = self.llm_config.presence_penalty
+        if self.llm_config.stop is not None:
+            response_params["stop"] = self.llm_config.stop
+
         # Add reasoning parameters if specified
         if final_reasoning_effort is not None:
             response_params["reasoning_effort"] = final_reasoning_effort

lite_agent/response_handlers/__init__.py

@@ -0,0 +1,10 @@
+"""Response handlers for unified streaming and non-streaming processing."""
+from lite_agent.response_handlers.base import ResponseHandler
+from lite_agent.response_handlers.completion import CompletionResponseHandler
+from lite_agent.response_handlers.responses import ResponsesAPIHandler
+
+__all__ = [
+    "CompletionResponseHandler",
+    "ResponseHandler",
+    "ResponsesAPIHandler",
+]

lite_agent/response_handlers/base.py

@@ -0,0 +1,46 @@
+"""Base response handler for unified streaming and non-streaming response processing."""
+from abc import ABC, abstractmethod
+from collections.abc import AsyncGenerator
+from pathlib import Path
+from typing import Any
+
+from lite_agent.types import AgentChunk
+
+
+class ResponseHandler(ABC):
+    """Base class for handling both streaming and non-streaming responses."""
+
+    async def handle(
+        self,
+        response: Any,
+        streaming: bool,
+        record_to: Path | None = None,
+    ) -> AsyncGenerator[AgentChunk, None]:
+        """Handle a response in either streaming or non-streaming mode.
+        
+        Args:
+            response: The LLM response object
+            streaming: Whether to process as streaming or non-streaming
+            record_to: Optional file path to record the conversation
+            
+        Yields:
+            AgentChunk: Processed chunks from the response
+        """
+        if streaming:
+            async for chunk in self._handle_streaming(response, record_to):
+                yield chunk
+        else:
+            async for chunk in self._handle_non_streaming(response, record_to):
+                yield chunk
+
+    @abstractmethod
+    async def _handle_streaming(
+        self, response: Any, record_to: Path | None = None,
+    ) -> AsyncGenerator[AgentChunk, None]:
+        """Handle streaming response."""
+
+    @abstractmethod
+    async def _handle_non_streaming(
+        self, response: Any, record_to: Path | None = None,
+    ) -> AsyncGenerator[AgentChunk, None]:
+        """Handle non-streaming response."""

lite_agent/response_handlers/completion.py

@@ -0,0 +1,50 @@
+"""Completion API response handler."""
+from collections.abc import AsyncGenerator
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from litellm import CustomStreamWrapper
+
+from lite_agent.response_handlers.base import ResponseHandler
+from lite_agent.stream_handlers import litellm_completion_stream_handler
+from lite_agent.types import AgentChunk
+from lite_agent.types.events import AssistantMessageEvent
+from lite_agent.types.messages import AssistantMessageMeta, AssistantTextContent, NewAssistantMessage
+
+
+class CompletionResponseHandler(ResponseHandler):
+    """Handler for Completion API responses."""
+
+    async def _handle_streaming(
+        self, response: Any, record_to: Path | None = None,
+    ) -> AsyncGenerator[AgentChunk, None]:
+        """Handle streaming completion response."""
+        if isinstance(response, CustomStreamWrapper):
+            async for chunk in litellm_completion_stream_handler(response, record_to):
+                yield chunk
+        else:
+            msg = "Response is not a CustomStreamWrapper, cannot stream chunks."
+            raise TypeError(msg)
+
+    async def _handle_non_streaming(
+        self, response: Any, record_to: Path | None = None,
+    ) -> AsyncGenerator[AgentChunk, None]:
+        """Handle non-streaming completion response."""
+        # Convert completion response to chunks
+        if hasattr(response, "choices") and response.choices:
+            choice = response.choices[0]
+            content_items = []
+
+            # Add text content
+            if choice.message and choice.message.content:
+                content_items.append(AssistantTextContent(text=choice.message.content))
+
+            # TODO: Handle tool calls in the future
+
+            if content_items:
+                message = NewAssistantMessage(
+                    content=content_items,
+                    meta=AssistantMessageMeta(sent_at=datetime.now(timezone.utc)),
+                )
+                yield AssistantMessageEvent(message=message)

lite_agent/response_handlers/responses.py

@@ -0,0 +1,42 @@
+"""Responses API response handler."""
+from collections.abc import AsyncGenerator
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from lite_agent.response_handlers.base import ResponseHandler
+from lite_agent.stream_handlers import litellm_response_stream_handler
+from lite_agent.types import AgentChunk
+from lite_agent.types.events import AssistantMessageEvent
+from lite_agent.types.messages import AssistantMessageMeta, AssistantTextContent, NewAssistantMessage
+
+
+class ResponsesAPIHandler(ResponseHandler):
+    """Handler for Responses API responses."""
+
+    async def _handle_streaming(
+        self, response: Any, record_to: Path | None = None,
+    ) -> AsyncGenerator[AgentChunk, None]:
+        """Handle streaming responses API response."""
+        async for chunk in litellm_response_stream_handler(response, record_to):
+            yield chunk
+
+    async def _handle_non_streaming(
+        self, response: Any, record_to: Path | None = None,
+    ) -> AsyncGenerator[AgentChunk, None]:
+        """Handle non-streaming responses API response."""
+        # Convert ResponsesAPIResponse to chunks
+        if hasattr(response, "output") and response.output:
+            for output_message in response.output:
+                if hasattr(output_message, "content") and output_message.content:
+                    content_text = ""
+                    for content_item in output_message.content:
+                        if hasattr(content_item, "text"):
+                            content_text += content_item.text
+
+                    if content_text:
+                        message = NewAssistantMessage(
+                            content=[AssistantTextContent(text=content_text)],
+                            meta=AssistantMessageMeta(sent_at=datetime.now(timezone.utc)),
+                        )
+                        yield AssistantMessageEvent(message=message)

lite_agent/runner.py

@@ -44,10 +44,11 @@ DEFAULT_INCLUDES: tuple[AgentChunkType, ...] = (
 
 
 class Runner:
-    def __init__(self, agent: Agent, api: Literal["completion", "responses"] = "responses") -> None:
+    def __init__(self, agent: Agent, api: Literal["completion", "responses"] = "responses", streaming: bool = True) -> None:
         self.agent = agent
         self.messages: list[NewMessage] = []
         self.api = api
+        self.streaming = streaming
         self._current_assistant_message: NewAssistantMessage | None = None
 
     @property
@@ -168,7 +169,7 @@ class Runner:
         """Collect all chunks from an async generator into a list."""
         return [chunk async for chunk in stream]
 
-    def run(  # noqa: PLR0913
+    def run(
         self,
         user_input: UserInput,
         max_steps: int = 20,
@@ -178,6 +179,7 @@ class Runner:
         agent_kwargs: dict[str, Any] | None = None,
     ) -> AsyncGenerator[AgentChunk, None]:
         """Run the agent and return a RunResponse object that can be asynchronously iterated for each chunk."""
+        logger.debug(f"Runner.run called with streaming={self.streaming}, api={self.api}")
         includes = self._normalize_includes(includes)
         match user_input:
             case str():
@@ -189,6 +191,7 @@ class Runner:
             case _:
                 # Handle single message (BaseModel, TypedDict, or dict)
                 self.append_message(user_input)  # type: ignore[arg-type]
+        logger.debug("Messages prepared, calling _run")
         return self._run(max_steps, includes, self._normalize_record_path(record_to), context=context, agent_kwargs=agent_kwargs)
 
     async def _run(
@@ -226,22 +229,28 @@ class Runner:
             if agent_kwargs:
                 reasoning = agent_kwargs.get("reasoning")
 
+            logger.debug(f"Using API: {self.api}, streaming: {self.streaming}")
             match self.api:
                 case "completion":
+                    logger.debug("Calling agent.completion")
                     resp = await self.agent.completion(
                         self.messages,
                         record_to_file=record_to,
                         reasoning=reasoning,
+                        streaming=self.streaming,
                     )
                 case "responses":
+                    logger.debug("Calling agent.responses")
                     resp = await self.agent.responses(
                         self.messages,
                         record_to_file=record_to,
                         reasoning=reasoning,
+                        streaming=self.streaming,
                     )
                 case _:
                     msg = f"Unknown API type: {self.api}"
                     raise ValueError(msg)
+            logger.debug(f"Received response from agent: {type(resp)}")
             async for chunk in resp:
                 match chunk.type:
                     case "assistant_message":

{lite_agent-0.5.0.dist-info → lite_agent-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lite-agent
-Version: 0.5.0
+Version: 0.6.0
 Summary: A lightweight, extensible framework for building AI agent.
 Author-email: Jianqi Pan <jannchie@gmail.com>
 License: MIT

{lite_agent-0.5.0.dist-info → lite_agent-0.6.0.dist-info}/RECORD

@@ -1,14 +1,18 @@
 lite_agent/__init__.py,sha256=Swuefee0etSiaDnn30K2hBNV9UI3hIValW3A-pRE7e0,338
-lite_agent/agent.py,sha256=M0U59KpMy6OGFje6yZuQCYVGr4oBboRwbtImPF59o2w,23314
-lite_agent/chat_display.py,sha256=b0sUH3fkutc4e_KAKH7AtPu2msyLloNIAiWqCNavdds,30533
-lite_agent/client.py,sha256=HG-NbTIUSFAUAPjRow3TFYJxvTc6Y4bdT2oJWIJNEEk,5963
+lite_agent/agent.py,sha256=9stxur0iqdG9NUDXdk1ElxenjYsRsurt36hGhZcz_-c,23323
+lite_agent/chat_display.py,sha256=Pfg6ZgTeIuzRZMVxOUzlwZU18rfOLD9-8I1lqUd_fXc,30516
+lite_agent/client.py,sha256=QhtZZGX54ha9-HKHcbx0qUsaAUi4-TAO-YckCH_itQY,8633
 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=U7eVNAJ_VLwgbPPpn-vggSgvBmFl8wMMFWn3mWCsDow,40423
+lite_agent/runner.py,sha256=B0KYE0Wfta4X85kPm_hMMGrLz8o1-TmGUnOG1cUZeBM,40985
 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/response_handlers/__init__.py,sha256=2xe8YngMpjdp1B5tE8C3IiimYI30TnqQHj9KTtg6wCI,385
+lite_agent/response_handlers/base.py,sha256=amQSnhUdoMyaacL7BlGfIUJDYDgqH6seYlfOl6loy-w,1566
+lite_agent/response_handlers/completion.py,sha256=X-sBM-ZBxodppcCXAwoN8Lslda5QYSoK7DdKEdgaYnM,2026
+lite_agent/response_handlers/responses.py,sha256=KEKnnsel8HLiF2Ob8TzVSXuRjudCpvyZ_GMrg3ME2g0,1915
 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
@@ -18,6 +22,6 @@ lite_agent/types/__init__.py,sha256=QKuhjFWRcpAlsBK9JYgoCABpoQExwhuyGudJoiiqQfs,
 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.5.0.dist-info/METADATA,sha256=20K2Xirnyawl1uN_I8TLcuGlgRjNhs04hz2BtDDRnbM,3456
-lite_agent-0.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lite_agent-0.5.0.dist-info/RECORD,,
+lite_agent-0.6.0.dist-info/METADATA,sha256=_gfjiwA85XKoQdB9TCJx3BI2D21gNkw-C5pL3CaiZz8,3456
+lite_agent-0.6.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lite_agent-0.6.0.dist-info/RECORD,,