lm-deluge 0.0.74__py3-none-any.whl → 0.0.76__py3-none-any.whl

lm_deluge/api_requests/anthropic.py

@@ -12,6 +12,10 @@ from lm_deluge.prompt import (
 from lm_deluge.request_context import RequestContext
 from lm_deluge.tool import MCPServer, Tool
 from lm_deluge.usage import Usage
+from lm_deluge.util.schema import (
+    prepare_output_schema,
+    transform_schema_for_anthropic,
+)
 
 from ..models import APIModel
 from .base import APIRequestBase, APIResponse
@@ -87,10 +91,15 @@ def _build_anthropic_request(
     # Handle structured outputs (output_format)
     if context.output_schema:
         if model.supports_json:
+            base_schema = prepare_output_schema(context.output_schema)
+
+            # Apply Anthropic-specific transformations (move unsupported constraints to description)
+            transformed_schema = transform_schema_for_anthropic(base_schema)
+
             _add_beta(base_headers, "structured-outputs-2025-11-13")
             request_json["output_format"] = {
                 "type": "json_schema",
-                "schema": context.output_schema,
+                "schema": transformed_schema,
             }
         else:
             print(

lm_deluge/api_requests/bedrock.py

@@ -197,9 +197,7 @@ async def _build_openai_bedrock_request(
         request_tools = []
         for tool in tools:
             if isinstance(tool, Tool):
-                request_tools.append(
-                    tool.dump_for("openai-completions", strict=False)
-                )
+                request_tools.append(tool.dump_for("openai-completions", strict=False))
             elif isinstance(tool, MCPServer):
                 as_tools = await tool.to_tools()
                 request_tools.extend(

lm_deluge/api_requests/openai.py

@@ -9,6 +9,10 @@ from aiohttp import ClientResponse
 from lm_deluge.request_context import RequestContext
 from lm_deluge.tool import MCPServer, Tool
 from lm_deluge.warnings import maybe_warn
+from lm_deluge.util.schema import (
+    prepare_output_schema,
+    transform_schema_for_openai,
+)
 
 from ..config import SamplingParams
 from ..models import APIModel
@@ -87,11 +91,16 @@ async def _build_oa_chat_request(
     # Handle structured outputs (output_schema takes precedence over json_mode)
     if context.output_schema:
         if model.supports_json:
+            base_schema = prepare_output_schema(context.output_schema)
+
+            # Apply OpenAI-specific transformations (currently passthrough with copy)
+            transformed_schema = transform_schema_for_openai(base_schema)
+
             request_json["response_format"] = {
                 "type": "json_schema",
                 "json_schema": {
                     "name": "response",
-                    "schema": context.output_schema,
+                    "schema": transformed_schema,
                     "strict": True,
                 },
             }
@@ -326,11 +335,16 @@ async def _build_oa_responses_request(
     # Handle structured outputs (output_schema takes precedence over json_mode)
     if context.output_schema:
         if model.supports_json:
+            base_schema = prepare_output_schema(context.output_schema)
+
+            # Apply OpenAI-specific transformations (currently passthrough with copy)
+            transformed_schema = transform_schema_for_openai(base_schema)
+
             request_json["text"] = {
                 "format": {
                     "type": "json_schema",
                     "name": "response",
-                    "schema": context.output_schema,
+                    "schema": transformed_schema,
                     "strict": True,
                 }
             }

lm_deluge/client.py

@@ -1,4 +1,5 @@
 import asyncio
+from dataclasses import dataclass
 from typing import (
     Any,
     AsyncGenerator,
@@ -37,6 +38,14 @@ from .request_context import RequestContext
 from .tracker import StatusTracker
 
 
+@dataclass
+class AgentLoopResponse:
+    """Wrapper for agent loop results to distinguish from single request results."""
+
+    conversation: Conversation
+    final_response: APIResponse
+
+
 # TODO: add optional max_input_tokens to client so we can reject long prompts to prevent abuse
 class _LLMClient(BaseModel):
     """
@@ -88,7 +97,9 @@ class _LLMClient(BaseModel):
     # Internal state for async task handling
     _next_task_id: int = PrivateAttr(default=0)
     _tasks: dict[int, asyncio.Task] = PrivateAttr(default_factory=dict)
-    _results: dict[int, APIResponse] = PrivateAttr(default_factory=dict)
+    _results: dict[int, APIResponse | AgentLoopResponse] = PrivateAttr(
+        default_factory=dict
+    )
     _tracker: StatusTracker | None = PrivateAttr(default=None)
     _capacity_lock: asyncio.Lock = PrivateAttr(default_factory=asyncio.Lock)
 
@@ -561,7 +572,7 @@ class _LLMClient(BaseModel):
         return_completions_only: Literal[True],
         show_progress: bool = ...,
         tools: list[Tool | dict | MCPServer] | None = ...,
-        output_schema: dict | None = ...,
+        output_schema: type[BaseModel] | dict | None = ...,
         cache: CachePattern | None = ...,
         service_tier: Literal["auto", "default", "flex", "priority"] | None = ...,
     ) -> list[str | None]: ...
@@ -574,7 +585,7 @@ class _LLMClient(BaseModel):
         return_completions_only: Literal[False] = ...,
         show_progress: bool = ...,
         tools: list[Tool | dict | MCPServer] | None = ...,
-        output_schema: dict | None = ...,
+        output_schema: type[BaseModel] | dict | None = ...,
         cache: CachePattern | None = ...,
         service_tier: Literal["auto", "default", "flex", "priority"] | None = ...,
     ) -> list[APIResponse]: ...
@@ -586,7 +597,7 @@ class _LLMClient(BaseModel):
         return_completions_only: bool = False,
         show_progress: bool = True,
         tools: list[Tool | dict | MCPServer] | None = None,
-        output_schema: dict | None = None,
+        output_schema: type[BaseModel] | dict | None = None,
         cache: CachePattern | None = None,
         service_tier: Literal["auto", "default", "flex", "priority"] | None = None,
     ) -> list[APIResponse] | list[str | None] | dict[str, int]:
@@ -661,7 +672,7 @@ class _LLMClient(BaseModel):
         return_completions_only: bool = False,
         show_progress=True,
         tools: list[Tool | dict | MCPServer] | None = None,
-        output_schema: dict | None = None,
+        output_schema: type[BaseModel] | dict | None = None,
         cache: CachePattern | None = None,
     ):
         return asyncio.run(
@@ -694,7 +705,7 @@ class _LLMClient(BaseModel):
         prompt: Prompt,
         *,
         tools: list[Tool | dict | MCPServer] | None = None,
-        output_schema: dict | None = None,
+        output_schema: type[BaseModel] | dict | None = None,
         cache: CachePattern | None = None,
         service_tier: Literal["auto", "default", "flex", "priority"] | None = None,
     ) -> int:
@@ -731,7 +742,7 @@ class _LLMClient(BaseModel):
         prompt: Prompt,
         *,
         tools: list[Tool | dict | MCPServer] | None = None,
-        output_schema: dict | None = None,
+        output_schema: type[BaseModel] | dict | None = None,
         cache: CachePattern | None = None,
         service_tier: Literal["auto", "default", "flex", "priority"] | None = None,
     ) -> APIResponse:
@@ -747,11 +758,11 @@ class _LLMClient(BaseModel):
     async def wait_for(self, task_id: int) -> APIResponse:
         task = self._tasks.get(task_id)
         if task:
-            return await task
-        res = self._results.get(task_id)
-        if res:
-            return res
+            result = await task
         else:
+            result = self._results.get(task_id)
+
+        if result is None:
             return APIResponse(
                 id=-1,
                 model_internal="",
@@ -762,6 +773,11 @@ class _LLMClient(BaseModel):
                 error_message="Task not found",
             )
 
+        assert isinstance(
+            result, APIResponse
+        ), f"Expected APIResponse, got {type(result)}. Use wait_for_agent_loop for agent loop tasks."
+        return result
+
     async def wait_for_all(
         self, task_ids: Sequence[int] | None = None
     ) -> list[APIResponse]:
@@ -797,6 +813,9 @@ class _LLMClient(BaseModel):
                 tid = tasks_map.pop(task)
                 task_result = self._results.get(tid, await task)
                 assert task_result
+                assert isinstance(
+                    task_result, APIResponse
+                ), f"Expected APIResponse, got {type(task_result)}. as_completed() only works with single requests, not agent loops."
                 yield tid, task_result
 
         while tasks_map:
@@ -807,6 +826,9 @@ class _LLMClient(BaseModel):
                 tid = tasks_map.pop(task)
                 task_result = self._results.get(tid, await task)
                 assert task_result
+                assert isinstance(
+                    task_result, APIResponse
+                ), f"Expected APIResponse, got {type(task_result)}. as_completed() only works with single requests, not agent loops."
                 yield tid, task_result
 
     async def stream(
@@ -828,24 +850,15 @@ class _LLMClient(BaseModel):
                     return self.postprocess(item)
                 return item
 
-    async def run_agent_loop(
+    async def _run_agent_loop_internal(
         self,
-        conversation: Prompt,
+        task_id: int,
+        conversation: Conversation,
         *,
         tools: list[Tool | dict | MCPServer] | None = None,
         max_rounds: int = 5,
-        show_progress: bool = False,
-    ) -> tuple[Conversation, APIResponse]:
-        """Run a simple agent loop until no more tool calls are returned.
-
-        The provided ``conversation`` will be mutated and returned alongside the
-        final ``APIResponse`` from the model. ``tools`` may include ``Tool``
-        instances or built‑in tool dictionaries.
-        """
-
-        if not isinstance(conversation, Conversation):
-            conversation = prompts_to_conversations([conversation])[0]
-            assert isinstance(conversation, Conversation)
+    ) -> AgentLoopResponse:
+        """Internal method to run agent loop and return wrapped result."""
 
         # Expand MCPServer objects to their constituent tools for tool execution
         expanded_tools: list[Tool] = []
@@ -898,7 +911,75 @@ class _LLMClient(BaseModel):
         if response is None:
             raise RuntimeError("model did not return a response")
 
-        return conversation, response
+        result = AgentLoopResponse(conversation=conversation, final_response=response)
+        self._results[task_id] = result
+        return result
+
+    def start_agent_loop_nowait(
+        self,
+        conversation: Prompt,
+        *,
+        tools: list[Tool | dict | MCPServer] | None = None,
+        max_rounds: int = 5,
+    ) -> int:
+        """Start an agent loop without waiting for it to complete.
+
+        Returns a task_id that can be used with wait_for_agent_loop().
+        """
+        if not isinstance(conversation, Conversation):
+            conversation = prompts_to_conversations([conversation])[0]
+            assert isinstance(conversation, Conversation)
+
+        task_id = self._next_task_id
+        self._next_task_id += 1
+
+        task = asyncio.create_task(
+            self._run_agent_loop_internal(
+                task_id, conversation, tools=tools, max_rounds=max_rounds
+            )
+        )
+        self._tasks[task_id] = task
+        return task_id
+
+    async def wait_for_agent_loop(
+        self, task_id: int
+    ) -> tuple[Conversation, APIResponse]:
+        """Wait for an agent loop task to complete.
+
+        Returns the conversation and final response from the agent loop.
+        """
+        task = self._tasks.get(task_id)
+        if task:
+            result = await task
+        else:
+            result = self._results.get(task_id)
+
+        if result is None:
+            raise RuntimeError(f"Agent loop task {task_id} not found")
+
+        assert isinstance(
+            result, AgentLoopResponse
+        ), f"Expected AgentLoopResponse, got {type(result)}"
+        return result.conversation, result.final_response
+
+    async def run_agent_loop(
+        self,
+        conversation: Prompt,
+        *,
+        tools: list[Tool | dict | MCPServer] | None = None,
+        max_rounds: int = 5,
+        show_progress: bool = False,
+    ) -> tuple[Conversation, APIResponse]:
+        """Run a simple agent loop until no more tool calls are returned.
+
+        The provided ``conversation`` will be mutated and returned alongside the
+        final ``APIResponse`` from the model. ``tools`` may include ``Tool``
+        instances or built‑in tool dictionaries.
+        """
+        task_id = self.start_agent_loop_nowait(
+            conversation, tools=tools, max_rounds=max_rounds
+        )
+        return await self.wait_for_agent_loop(task_id)
 
     def run_agent_loop_sync(
         self,

lm_deluge/llm_tools/__init__.py

@@ -1,11 +1,18 @@
 from .extract import extract, extract_async
-from .translate import translate, translate_async
 from .score import score_llm
+from .subagents import SubAgentManager
+from .todos import TodoItem, TodoManager, TodoPriority, TodoStatus
+from .translate import translate, translate_async
 
 __all__ = [
     "extract",
     "extract_async",
+    "TodoItem",
+    "TodoManager",
+    "TodoPriority",
+    "TodoStatus",
     "translate",
     "translate_async",
     "score_llm",
+    "SubAgentManager",
 ]

lm_deluge/llm_tools/subagents.py

@@ -0,0 +1,233 @@
+from lm_deluge.api_requests.base import APIResponse
+from lm_deluge.client import AgentLoopResponse, _LLMClient
+from lm_deluge.prompt import Conversation, prompts_to_conversations
+from lm_deluge.tool import Tool
+
+
+class SubAgentManager:
+    """Manages subagent tasks that can be spawned by a main LLM via tool calls.
+
+    The SubAgentManager exposes tools that allow a main LLM to delegate subtasks
+    to specialized or cheaper subagent models, saving context and improving efficiency.
+
+    Example:
+        >>> manager = SubAgentManager(
+        ...     client=LLMClient("gpt-4o-mini"),  # Subagent model
+        ...     tools=[search_tool, calculator_tool]  # Tools available to subagents
+        ... )
+        >>> main_client = LLMClient("gpt-4o")  # More expensive main model
+        >>> conv = Conversation.user("Research AI and calculate market size")
+        >>> # Main model can now call manager tools to spawn subagents
+        >>> conv, resp = await main_client.run_agent_loop(
+        ...     conv,
+        ...     tools=manager.get_tools()
+        ... )
+    """
+
+    def __init__(
+        self,
+        client: _LLMClient,
+        tools: list[Tool] | None = None,
+        max_rounds: int = 5,
+    ):
+        """Initialize the SubAgentManager.
+
+        Args:
+            client: LLMClient to use for subagent tasks
+            tools: Tools available to subagents (optional)
+            max_rounds: Maximum rounds for each subagent's agent loop
+        """
+        self.client = client
+        self.tools = tools or []
+        self.max_rounds = max_rounds
+        self.subagents: dict[int, dict] = {}
+
+    async def _start_subagent(self, task: str) -> int:
+        """Start a subagent with the given task.
+
+        Args:
+            task: The task description for the subagent
+
+        Returns:
+            Subagent task ID
+        """
+        conversation = prompts_to_conversations([task])[0]
+        assert isinstance(conversation, Conversation)
+
+        # Use agent loop nowait API to start the subagent
+        task_id = self.client.start_agent_loop_nowait(
+            conversation,
+            tools=self.tools,  # type: ignore
+            max_rounds=self.max_rounds,
+        )
+
+        # Track the subagent
+        self.subagents[task_id] = {
+            "status": "running",
+            "conversation": None,
+            "response": None,
+            "error": None,
+        }
+
+        return task_id
+
+    def _finalize_subagent_result(
+        self, agent_id: int, result: AgentLoopResponse
+    ) -> str:
+        """Update subagent tracking state from a finished agent loop."""
+        agent = self.subagents[agent_id]
+        agent["conversation"] = result.conversation
+        agent["response"] = result.final_response
+
+        if result.final_response.is_error:
+            agent["status"] = "error"
+            agent["error"] = result.final_response.error_message
+            return f"Error: {agent['error']}"
+
+        agent["status"] = "finished"
+        return result.final_response.completion or "Subagent finished with no output"
+
+    async def _check_subagent(self, agent_id: int) -> str:
+        """Check the status of a subagent.
+
+        Args:
+            agent_id: The subagent task ID
+
+        Returns:
+            Status string describing the subagent's state
+        """
+        if agent_id not in self.subagents:
+            return f"Error: Subagent {agent_id} not found"
+
+        agent = self.subagents[agent_id]
+        status = agent["status"]
+
+        if status == "finished":
+            response: APIResponse = agent["response"]
+            return response.completion or "Subagent finished with no output"
+        elif status == "error":
+            return f"Error: {agent['error']}"
+        else:
+            # Try to check if it's done
+            try:
+                # Check if the task exists in client's results
+                stored_result = self.client._results.get(agent_id)
+                if isinstance(stored_result, AgentLoopResponse):
+                    return self._finalize_subagent_result(agent_id, stored_result)
+
+                task = self.client._tasks.get(agent_id)
+                if task and task.done():
+                    try:
+                        task_result = task.result()
+                    except Exception as e:
+                        agent["status"] = "error"
+                        agent["error"] = str(e)
+                        return f"Error: {agent['error']}"
+
+                    if isinstance(task_result, AgentLoopResponse):
+                        return self._finalize_subagent_result(agent_id, task_result)
+
+                    agent["status"] = "error"
+                    agent["error"] = (
+                        f"Unexpected task result type: {type(task_result).__name__}"
+                    )
+                    return f"Error: {agent['error']}"
+
+                # Still running
+                return f"Subagent {agent_id} is still running. Call this tool again to check status."
+            except Exception as e:
+                agent["status"] = "error"
+                agent["error"] = str(e)
+                return f"Error checking subagent: {e}"
+
+    async def _wait_for_subagent(self, agent_id: int) -> str:
+        """Wait for a subagent to complete and return its output.
+
+        Args:
+            agent_id: The subagent task ID
+
+        Returns:
+            The subagent's final output
+        """
+        if agent_id not in self.subagents:
+            return f"Error: Subagent {agent_id} not found"
+
+        try:
+            # Use the wait_for_agent_loop API
+            conversation, response = await self.client.wait_for_agent_loop(agent_id)
+
+            agent = self.subagents[agent_id]
+            agent["conversation"] = conversation
+            agent["response"] = response
+
+            if response.is_error:
+                agent["status"] = "error"
+                agent["error"] = response.error_message
+                return f"Error: {response.error_message}"
+            else:
+                agent["status"] = "finished"
+                return response.completion or "Subagent finished with no output"
+        except Exception as e:
+            agent = self.subagents[agent_id]
+            agent["status"] = "error"
+            agent["error"] = str(e)
+            return f"Error waiting for subagent: {e}"
+
+    def get_tools(self) -> list[Tool]:
+        """Get the tools that allow a main LLM to control subagents.
+
+        Returns:
+            List of Tool objects for starting, checking, and waiting for subagents
+        """
+        start_tool = Tool(
+            name="start_subagent",
+            description=(
+                "Start a subagent to work on a subtask independently. "
+                "Use this to delegate complex subtasks or when you need to save context. "
+                "Returns the subagent's task ID which can be used to check its status."
+            ),
+            run=self._start_subagent,
+            parameters={
+                "task": {
+                    "type": "string",
+                    "description": "The task description for the subagent to work on",
+                }
+            },
+            required=["task"],
+        )
+
+        check_tool = Tool(
+            name="check_subagent",
+            description=(
+                "Check the status and output of a running subagent. "
+                "If the subagent is still running, you'll be told to check again later. "
+                "If finished, returns the subagent's final output."
+            ),
+            run=self._check_subagent,
+            parameters={
+                "agent_id": {
+                    "type": "integer",
+                    "description": "The task ID of the subagent to check",
+                }
+            },
+            required=["agent_id"],
+        )
+
+        wait_tool = Tool(
+            name="wait_for_subagent",
+            description=(
+                "Wait for a subagent to complete and return its output. "
+                "This will block until the subagent finishes. "
+                "Use check_subagent if you want to do other work while waiting."
+            ),
+            run=self._wait_for_subagent,
+            parameters={
+                "agent_id": {
+                    "type": "integer",
+                    "description": "The task ID of the subagent to wait for",
+                }
+            },
+            required=["agent_id"],
+        )
+
+        return [start_tool, check_tool, wait_tool]