lm-deluge 0.0.67__py3-none-any.whl → 0.0.88__py3-none-any.whl

lm_deluge/pipelines/gepa/util.py

@@ -0,0 +1,165 @@
+"""
+Utility functions for GEPA.
+
+Includes conversation formatting and text extraction helpers.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from lm_deluge.prompt import Conversation
+
+
+def format_conversation_compact(conversation: Conversation) -> str:
+    """
+    Format a Conversation for showing to the proposer LLM.
+
+    Goals:
+    - Show full user and assistant message content
+    - Show tool calls with their arguments
+    - Abbreviate tool results (just show placeholder, not full content)
+    - No decorative separators, keep it compact
+
+    Args:
+        conversation: The conversation to format
+
+    Returns:
+        A string representation suitable for including in a prompt
+    """
+    lines: list[str] = []
+
+    # Check for system message (first message with role="system")
+    for msg in conversation.messages:
+        if msg.role == "system":
+            lines.append(f"[system]\n{msg.completion}")
+            lines.append("")
+            break
+
+    for msg in conversation.messages:
+        role = msg.role
+
+        if role == "system":
+            # Already handled above
+            continue
+
+        if role == "user":
+            text_content = msg.completion or ""
+            lines.append(f"[user]\n{text_content}")
+
+        elif role == "assistant":
+            # Handle text content
+            text_content = msg.completion or ""
+            if text_content:
+                lines.append(f"[assistant]\n{text_content}")
+
+            # Handle tool calls
+            if msg.tool_calls:
+                for tc in msg.tool_calls:
+                    tool_name = tc.name
+                    # Format arguments compactly
+                    args_str = _format_tool_args(tc.arguments)
+                    lines.append(f"[tool_call: {tool_name}]\n{args_str}")
+
+        elif role == "tool":
+            # Just show placeholder for tool results - content can be huge
+            # Try to get tool names from tool_results
+            if msg.tool_results:
+                for tr in msg.tool_results:
+                    tool_id = getattr(tr, "tool_call_id", "unknown")
+                    lines.append(f"[tool_result: {tool_id}] (content omitted)")
+            else:
+                lines.append("[tool_result] (content omitted)")
+
+        lines.append("")
+
+    return "\n".join(lines).strip()
+
+
+def _format_tool_args(arguments: dict[str, Any] | str | None) -> str:
+    """Format tool call arguments compactly."""
+    if arguments is None:
+        return "(no arguments)"
+
+    if isinstance(arguments, str):
+        # Already a string (might be JSON string)
+        return arguments[:500] + "..." if len(arguments) > 500 else arguments
+
+    if isinstance(arguments, dict):
+        # Format as key=value pairs
+        parts = []
+        for key, value in arguments.items():
+            value_str = str(value)
+            # Truncate long values
+            if len(value_str) > 200:
+                value_str = value_str[:200] + "..."
+            parts.append(f"  {key}: {value_str}")
+        return "\n".join(parts) if parts else "(no arguments)"
+
+    return str(arguments)
+
+
+def extract_text_from_response(response: str) -> str:
+    """
+    Extract text from between ``` blocks in LLM response.
+
+    Handles various formats:
+    - ```text``` or ```language\ntext```
+    - Incomplete blocks
+    - No blocks (returns trimmed response)
+    """
+    # Find content between first and last ```
+    start = response.find("```")
+    if start == -1:
+        return response.strip()
+
+    start += 3
+    end = response.rfind("```")
+
+    if end <= start:
+        # Handle incomplete blocks
+        stripped = response.strip()
+        if stripped.startswith("```"):
+            match = re.match(r"^```\S*\n?", response)
+            if match:
+                return response[match.end() :].strip()
+        elif stripped.endswith("```"):
+            return stripped[:-3].strip()
+        return stripped
+
+    # Skip language specifier (e.g., ```python\n)
+    content = response[start:end]
+    match = re.match(r"^\S*\n", content)
+    if match:
+        content = content[match.end() :]
+
+    return content.strip()
+
+
+def format_components_for_prompt(
+    component_values: dict[str, str],
+    component_descriptions: dict[str, str],
+) -> str:
+    """
+    Format components for showing to the proposer.
+
+    Args:
+        component_values: Current text value for each component
+        component_descriptions: Description of what each component does
+
+    Returns:
+        Formatted string listing all components
+    """
+    lines = []
+    for name, value in component_values.items():
+        description = component_descriptions.get(name, "")
+        lines.append(f"### {name}")
+        if description:
+            lines.append(f"*{description}*")
+        lines.append("```")
+        lines.append(value)
+        lines.append("```")
+        lines.append("")
+
+    return "\n".join(lines)

lm_deluge/{llm_tools → pipelines}/score.py

@@ -1,4 +1,4 @@
-from ..client import LLMClient, APIResponse
+from ..client import _LLMClient, APIResponse
 from ..util.logprobs import extract_prob
 
 # def extract_prob_yes(logprobs: list[dict]):
@@ -24,7 +24,7 @@ from ..util.logprobs import extract_prob
 def score_llm(
     scoring_prompt_template: str,
     inputs: list[tuple | list | dict],  # to format the template
-    scoring_model: LLMClient,
+    scoring_model: _LLMClient,
     return_probabilities: bool,
     yes_token: str = "yes",
 ) -> list[bool | None] | list[float | None]:

lm_deluge/{llm_tools → pipelines}/translate.py

@@ -1,5 +1,5 @@
 import asyncio
-from ..client import LLMClient
+from ..client import _LLMClient
 
 translation_prompt = (
     "Translate the following text (enclosed in ```) into English. "
@@ -20,7 +20,9 @@ def is_english(text: str, low_memory: bool = True):
     return True
 
 
-async def translate_async(texts: list[str], client: LLMClient, low_memory: bool = True):
+async def translate_async(
+    texts: list[str], client: _LLMClient, low_memory: bool = True
+):
     to_translate_idxs = [
         i for i, text in enumerate(texts) if not is_english(text, low_memory=low_memory)
     ]
@@ -40,5 +42,5 @@ async def translate_async(texts: list[str], client: LLMClient, low_memory: bool
     return texts
 
 
-def translate(texts: list[str], client: LLMClient, low_memory: bool = True):
+def translate(texts: list[str], client: _LLMClient, low_memory: bool = True):
     return asyncio.run(translate_async(texts, client, low_memory))

lm_deluge/prompt.py

@@ -61,6 +61,8 @@ class ToolCall:
     built_in: bool = False
     built_in_type: str | None = None
     extra_body: dict | None = None
+    # for gemini 3 - thought signatures to maintain reasoning context
+    thought_signature: str | None = None
 
     @property
     def fingerprint(self) -> str:
@@ -93,7 +95,10 @@ class ToolCall:
         }
 
     def gemini(self) -> dict:
-        return {"functionCall": {"name": self.name, "args": self.arguments}}
+        result = {"functionCall": {"name": self.name, "args": self.arguments}}
+        if self.thought_signature is not None:
+            result["thoughtSignature"] = self.thought_signature  # type: ignore
+        return result
 
     def mistral(self) -> dict:
         return {
@@ -198,6 +203,8 @@ class ToolResult:
                 "call_id": self.tool_call_id,
             }
             if self.built_in_type == "computer_call":
+                # OpenAI expects "computer_call_output" for the result type
+                result["type"] = "computer_call_output"
                 result["output"] = output_data.get("output", {})
                 if "acknowledged_safety_checks" in output_data:
                     result["acknowledged_safety_checks"] = output_data[
@@ -230,15 +237,41 @@ class ToolResult:
             raise ValueError("unsupported self.result type")
 
     def gemini(self) -> dict:
-        if not isinstance(self.result, str):
-            raise ValueError("can't handle content blocks for gemini yet")
-        return {
-            "functionResponse": {
-                "name": self.tool_call_id,  # Gemini uses name field for ID
-                "response": {"result": self.result},
-            }
+        # Build the function response
+        func_response: dict = {
+            "name": self.tool_call_id,  # Gemini uses name field for ID
         }
 
+        # Handle different result types
+        if isinstance(self.result, str):
+            func_response["response"] = {"result": self.result}
+        elif isinstance(self.result, dict):
+            # Check for Gemini computer use format with inline screenshot
+            if self.built_in_type == "gemini_computer_use":
+                # Gemini CU expects response dict with optional inline_data parts
+                func_response["response"] = self.result.get("response", {})
+                # Include inline data (screenshot) if present
+                if "inline_data" in self.result:
+                    func_response["parts"] = [
+                        {
+                            "inlineData": {
+                                "mimeType": self.result["inline_data"].get(
+                                    "mime_type", "image/png"
+                                ),
+                                "data": self.result["inline_data"]["data"],
+                            }
+                        }
+                    ]
+            else:
+                func_response["response"] = self.result
+        elif isinstance(self.result, list):
+            # Handle content blocks (images, etc.) - not yet implemented
+            raise ValueError("can't handle content blocks for gemini yet")
+        else:
+            func_response["response"] = {"result": str(self.result)}
+
+        return {"functionResponse": func_response}
+
     def mistral(self) -> dict:
         return {
             "type": "tool_result",
@@ -253,6 +286,8 @@ class Thinking:
     type: str = field(init=False, default="thinking")
     # for openai - to keep conversation chain
     raw_payload: dict | None = None
+    # for gemini 3 - thought signatures to maintain reasoning context
+    thought_signature: str | None = None
 
     @property
     def fingerprint(self) -> str:
@@ -270,7 +305,10 @@ class Thinking:
         return {"type": "thinking", "thinking": self.content}
 
     def gemini(self) -> dict:
-        return {"text": f"[Thinking: {self.content}]"}
+        result = {"text": f"[Thinking: {self.content}]"}
+        if self.thought_signature is not None:
+            result["thoughtSignature"] = self.thought_signature
+        return result
 
     def mistral(self) -> dict:
         return {"type": "text", "text": f"[Thinking: {self.content}]"}
@@ -374,14 +412,15 @@ class Message:
                 size = p.size
                 content_blocks.append({"type": "file", "tag": f"<File ({size} bytes)>"})
             elif isinstance(p, ToolCall):
-                content_blocks.append(
-                    {
-                        "type": "tool_call",
-                        "id": p.id,
-                        "name": p.name,
-                        "arguments": _json_safe(p.arguments),
-                    }
-                )
+                tool_call_block = {
+                    "type": "tool_call",
+                    "id": p.id,
+                    "name": p.name,
+                    "arguments": _json_safe(p.arguments),
+                }
+                if p.thought_signature is not None:
+                    tool_call_block["thought_signature"] = p.thought_signature
+                content_blocks.append(tool_call_block)
             elif isinstance(p, ToolResult):
                 content_blocks.append(
                     {
@@ -391,7 +430,10 @@ class Message:
                     }
                 )
             elif isinstance(p, Thinking):
-                content_blocks.append({"type": "thinking", "content": p.content})
+                thinking_block = {"type": "thinking", "content": p.content}
+                if p.thought_signature is not None:
+                    thinking_block["thought_signature"] = p.thought_signature
+                content_blocks.append(thinking_block)
 
         return {"role": self.role, "content": content_blocks}
 
@@ -415,14 +457,24 @@ class Message:
                 parts.append(Text(p["tag"]))
             elif p["type"] == "tool_call":
                 parts.append(
-                    ToolCall(id=p["id"], name=p["name"], arguments=p["arguments"])
+                    ToolCall(
+                        id=p["id"],
+                        name=p["name"],
+                        arguments=p["arguments"],
+                        thought_signature=p.get("thought_signature"),
+                    )
                 )
             elif p["type"] == "tool_result":
                 parts.append(
                     ToolResult(tool_call_id=p["tool_call_id"], result=p["result"])
                 )
             elif p["type"] == "thinking":
-                parts.append(Thinking(content=p["content"]))
+                parts.append(
+                    Thinking(
+                        content=p["content"],
+                        thought_signature=p.get("thought_signature"),
+                    )
+                )
             else:
                 raise ValueError(f"Unknown part type {p['type']!r}")
 
@@ -848,14 +900,16 @@ class Conversation:
             if content is None:
                 return parts
             if isinstance(content, str):
-                parts.append(Text(content))
+                if content.strip():
+                    parts.append(Text(content))
                 return parts
 
             for block in content:
                 block_type = block.get("type")
                 if block_type in text_types:
                     text_value = block.get("text") or block.get(block_type) or ""
-                    parts.append(Text(text_value))
+                    if text_value.strip():
+                        parts.append(Text(text_value))
                 elif block_type in image_types:
                     parts.append(_to_image_from_url(block))
                 elif block_type in file_types:
@@ -1001,7 +1055,8 @@ class Conversation:
                             )
                         )
 
-            conversation_messages.append(Message(mapped_role, parts))
+            if parts:
+                conversation_messages.append(Message(mapped_role, parts))
 
         return cls(conversation_messages)
 
@@ -1192,14 +1247,24 @@ class Conversation:
 
     @classmethod
     def from_unknown(
-        cls, messages: list[dict], *, system: str | list[dict] | None = None
+        cls, messages: list[dict] | dict, *, system: str | list[dict] | None = None
     ) -> tuple["Conversation", str]:
         """Attempt to convert provider-formatted messages without knowing the provider.
 
         Returns the parsed conversation together with the provider label that succeeded
-        ("openai" or "anthropic").
+        ("openai", "anthropic", or "log").
         """
 
+        # Check if input is in log format (output from to_log())
+        if isinstance(messages, dict) and "messages" in messages:
+            return cls.from_log(messages), "log"
+
+        # Ensure messages is a list for provider detection
+        if not isinstance(messages, list):
+            raise ValueError(
+                "messages must be a list of dicts or a dict with 'messages' key"
+            )
+
         def _detect_provider() -> str:
             has_openai_markers = False
             has_anthropic_markers = False
@@ -1330,14 +1395,14 @@ class Conversation:
                 # For assistant messages, extract computer calls as separate items
                 text_parts = []
                 for p in m.parts:
-                    if isinstance(p, ToolCall) and p.name.startswith("_computer_"):
+                    if isinstance(p, ToolCall) and p.built_in_type == "computer_call":
                         # Computer calls become separate items in the input array
-                        action_type = p.name.replace("_computer_", "")
+                        # p.arguments already contains the full action dict with "type"
                         input_items.append(
                             {
                                 "type": "computer_call",
                                 "call_id": p.id,
-                                "action": {"type": action_type, **p.arguments},
+                                "action": p.arguments,
                             }
                         )
                     elif isinstance(p, Text):
@@ -1533,14 +1598,15 @@ class Conversation:
                         {"type": "file", "tag": f"<File ({size} bytes)>"}
                     )
                 elif isinstance(p, ToolCall):
-                    content_blocks.append(
-                        {
-                            "type": "tool_call",
-                            "id": p.id,
-                            "name": p.name,
-                            "arguments": p.arguments,
-                        }
-                    )
+                    tool_call_block = {
+                        "type": "tool_call",
+                        "id": p.id,
+                        "name": p.name,
+                        "arguments": p.arguments,
+                    }
+                    if p.thought_signature is not None:
+                        tool_call_block["thought_signature"] = p.thought_signature
+                    content_blocks.append(tool_call_block)
                 elif isinstance(p, ToolResult):
                     content_blocks.append(
                         {
@@ -1552,11 +1618,119 @@ class Conversation:
                         }
                     )
                 elif isinstance(p, Thinking):
-                    content_blocks.append({"type": "thinking", "content": p.content})
+                    thinking_block = {"type": "thinking", "content": p.content}
+                    if p.thought_signature is not None:
+                        thinking_block["thought_signature"] = p.thought_signature
+                    content_blocks.append(thinking_block)
             serialized.append({"role": msg.role, "content": content_blocks})
 
         return {"messages": serialized}
 
+    def print(self, max_text_length: int = 500, indent: int = 2) -> None:
+        """Pretty-print the conversation to stdout.
+
+        Args:
+            max_text_length: Truncate text content longer than this (default 500 chars)
+            indent: JSON indentation for tool calls/results (default 2)
+        """
+        ROLE_COLORS = {
+            "system": "\033[95m",  # magenta
+            "user": "\033[94m",  # blue
+            "assistant": "\033[92m",  # green
+            "tool": "\033[93m",  # yellow
+        }
+        RESET = "\033[0m"
+        DIM = "\033[2m"
+        BOLD = "\033[1m"
+
+        def truncate(text: str, max_len: int) -> str:
+            if len(text) <= max_len:
+                return text
+            return (
+                text[:max_len] + f"{DIM}... [{len(text) - max_len} more chars]{RESET}"
+            )
+
+        def format_json(obj: dict | list, ind: int) -> str:
+            return json.dumps(obj, indent=ind, ensure_ascii=False)
+
+        print(f"\n{BOLD}{'=' * 60}{RESET}")
+        print(f"{BOLD}Conversation ({len(self.messages)} messages){RESET}")
+        print(f"{BOLD}{'=' * 60}{RESET}\n")
+
+        for i, msg in enumerate(self.messages):
+            role_color = ROLE_COLORS.get(msg.role, "")
+            print(f"{role_color}{BOLD}[{msg.role.upper()}]{RESET}")
+
+            for part in msg.parts:
+                if isinstance(part, Text):
+                    text = truncate(part.text, max_text_length)
+                    # Indent multiline text
+                    lines = text.split("\n")
+                    if len(lines) > 1:
+                        print("  " + "\n  ".join(lines))
+                    else:
+                        print(f"  {text}")
+
+                elif isinstance(part, Image):
+                    w, h = part.size
+                    print(f"  {DIM}<Image ({w}x{h})>{RESET}")
+
+                elif isinstance(part, File):
+                    size = part.size
+                    filename = getattr(part, "filename", None)
+                    if filename:
+                        print(f"  {DIM}<File: {filename} ({size} bytes)>{RESET}")
+                    else:
+                        print(f"  {DIM}<File ({size} bytes)>{RESET}")
+
+                elif isinstance(part, ToolCall):
+                    print(
+                        f"  {DIM}Tool Call:{RESET} {BOLD}{part.name}{RESET} (id: {part.id})"
+                    )
+                    if part.arguments:
+                        args_json = format_json(part.arguments, indent)
+                        # Indent the JSON
+                        indented = "\n".join(
+                            "    " + line for line in args_json.split("\n")
+                        )
+                        print(indented)
+
+                elif isinstance(part, ToolResult):
+                    print(f"  {DIM}Tool Result:{RESET} (call_id: {part.tool_call_id})")
+                    if isinstance(part.result, str):
+                        result_text = truncate(part.result, max_text_length)
+                        lines = result_text.split("\n")
+                        for line in lines:
+                            print(f"    {line}")
+                    elif isinstance(part.result, dict):
+                        result_json = format_json(part.result, indent)
+                        indented = "\n".join(
+                            "    " + line for line in result_json.split("\n")
+                        )
+                        print(indented)
+                    elif isinstance(part.result, list):
+                        print(f"    {DIM}<{len(part.result)} content blocks>{RESET}")
+                        for block in part.result:
+                            if isinstance(block, Text):
+                                block_text = truncate(block.text, max_text_length // 2)
+                                print(f"      [text] {block_text}")
+                            elif isinstance(block, Image):
+                                bw, bh = block.size
+                                print(f"      {DIM}<Image ({bw}x{bh})>{RESET}")
+
+                elif isinstance(part, Thinking):
+                    print(f"  {DIM}Thinking:{RESET}")
+                    thought = truncate(part.content, max_text_length)
+                    lines = thought.split("\n")
+                    for line in lines:
+                        print(f"    {DIM}{line}{RESET}")
+
+            # Separator between messages
+            if i < len(self.messages) - 1:
+                print(f"\n{'-' * 40}\n")
+
+        print(f"\n{BOLD}{'=' * 60}{RESET}\n")
+
     @classmethod
     def from_log(cls, payload: dict) -> "Conversation":
         """Re-hydrate a Conversation previously produced by `to_log()`."""
@@ -1577,14 +1751,24 @@ class Conversation:
                     parts.append(Text(p["tag"]))
                 elif p["type"] == "tool_call":
                     parts.append(
-                        ToolCall(id=p["id"], name=p["name"], arguments=p["arguments"])
+                        ToolCall(
+                            id=p["id"],
+                            name=p["name"],
+                            arguments=p["arguments"],
+                            thought_signature=p.get("thought_signature"),
+                        )
                     )
                 elif p["type"] == "tool_result":
                     parts.append(
                         ToolResult(tool_call_id=p["tool_call_id"], result=p["result"])
                     )
                 elif p["type"] == "thinking":
-                    parts.append(Thinking(content=p["content"]))
+                    parts.append(
+                        Thinking(
+                            content=p["content"],
+                            thought_signature=p.get("thought_signature"),
+                        )
+                    )
                 else:
                     raise ValueError(f"Unknown part type {p['type']!r}")
 
@@ -1596,7 +1780,7 @@ class Conversation:
 Prompt: TypeAlias = str | list[dict] | Message | Conversation
 
 
-def prompts_to_conversations(prompts: Sequence[Prompt]) -> Sequence[Prompt]:
+def prompts_to_conversations(prompts: Sequence[Prompt]) -> Sequence[Conversation]:
     converted = []
     for prompt in prompts:
         if isinstance(prompt, Conversation):

lm_deluge/request_context.py

@@ -1,11 +1,14 @@
 from dataclasses import dataclass, field
 from functools import cached_property
-from typing import Any, Callable
+from typing import Any, Callable, Sequence, TYPE_CHECKING
 
 from .config import SamplingParams
 from .prompt import CachePattern, Conversation
 from .tracker import StatusTracker
 
+if TYPE_CHECKING:
+    from pydantic import BaseModel
+
 
 @dataclass
 class RequestContext:
@@ -31,7 +34,8 @@ class RequestContext:
     callback: Callable | None = None
 
     # Optional features
-    tools: list | None = None
+    tools: Sequence[Any] | None = None
+    output_schema: "type[BaseModel] | dict | None" = None
     cache: CachePattern | None = None
     use_responses_api: bool = False
     background: bool = False
@@ -66,6 +70,7 @@ class RequestContext:
             "results_arr": self.results_arr,
             "callback": self.callback,
             "tools": self.tools,
+            "output_schema": self.output_schema,
             "cache": self.cache,
             "use_responses_api": self.use_responses_api,
             "background": self.background,