emdash-core 0.1.7__py3-none-any.whl → 0.1.33__py3-none-any.whl

emdash_core/agent/providers/openai_provider.py

@@ -2,6 +2,7 @@
 
 import os
 import base64
+import time
 from typing import Optional, Union
 
 from openai import OpenAI
@@ -30,6 +31,9 @@ PROVIDER_CONFIG = {
 # Providers that support the reasoning parameter via extra_body
 REASONING_SUPPORTED_PROVIDERS = {"openai"}
 
+# Providers that support extended thinking
+THINKING_SUPPORTED_PROVIDERS = {"anthropic"}
+
 
 class OpenAIProvider(LLMProvider):
     """
@@ -66,9 +70,9 @@ class OpenAIProvider(LLMProvider):
                 self._context_limit = 128000
                 self._provider = self._infer_provider(model)
 
-        # Override provider if OPENAI_BASE_URL is set (custom OpenAI-compatible API)
-        if os.environ.get("OPENAI_BASE_URL"):
-            self._provider = "openai"
+        # Note: We no longer override provider based on OPENAI_BASE_URL
+        # Each provider (fireworks, anthropic) uses its own base_url
+        # OPENAI_BASE_URL only applies to "openai" provider
 
         # Create OpenAI client with provider-specific configuration
         config = PROVIDER_CONFIG.get(self._provider, PROVIDER_CONFIG["openai"])
@@ -131,10 +135,26 @@ class OpenAIProvider(LLMProvider):
             )
 
         self._reasoning_override = self._parse_bool_env("EMDASH_LLM_REASONING")
+        self._thinking_override = self._parse_bool_env("EMDASH_LLM_THINKING")
+        self._thinking_budget = int(os.environ.get("EMDASH_THINKING_BUDGET", "10000"))
+        # Reasoning effort for Fireworks thinking models: none, low, medium, high
+        self._reasoning_effort = os.environ.get("EMDASH_REASONING_EFFORT", "medium")
+
+        # Use OPENAI_BASE_URL env var only for OpenAI provider, otherwise use provider config
+        if self._provider == "openai":
+            base_url = os.environ.get("OPENAI_BASE_URL") or config["base_url"]
+        else:
+            base_url = config["base_url"]
+
+        # Configure timeout from environment (default 300 seconds / 5 minutes)
+        # LLM calls can take a while with large contexts, so we use a generous default
+        timeout_seconds = int(os.environ.get("EMDASH_LLM_TIMEOUT", "300"))
+        self._timeout = timeout_seconds
 
         self.client = OpenAI(
             api_key=api_key,
-            base_url=config["base_url"],
+            base_url=base_url,
+            timeout=timeout_seconds,
         )
 
     @staticmethod
@@ -170,13 +190,10 @@ class OpenAIProvider(LLMProvider):
     def _infer_provider(self, model: str) -> str:
         """Infer provider from model string.
 
-        If OPENAI_BASE_URL is set, always returns 'openai' to use the custom
-        OpenAI-compatible API endpoint with OPENAI_API_KEY.
+        Returns the appropriate provider based on model name.
+        OPENAI_BASE_URL only affects the openai provider's base URL,
+        not provider selection.
         """
-        # If custom base URL is set, use openai provider (uses OPENAI_API_KEY)
-        if os.environ.get("OPENAI_BASE_URL"):
-            return "openai"
-
         model_lower = model.lower()
         if "claude" in model_lower or "anthropic" in model_lower:
             return "anthropic"
@@ -191,6 +208,7 @@ class OpenAIProvider(LLMProvider):
         tools: Optional[list[dict]] = None,
         system: Optional[str] = None,
         reasoning: bool = False,
+        thinking: bool = False,
         images: Optional[list[ImageContent]] = None,
     ) -> LLMResponse:
         """
@@ -201,6 +219,7 @@ class OpenAIProvider(LLMProvider):
             tools: Optional list of tool schemas (OpenAI format)
             system: Optional system prompt
             reasoning: Enable reasoning mode (for models that support it)
+            thinking: Enable extended thinking (for Anthropic models)
             images: Optional list of images for vision-capable models
 
         Returns:
@@ -212,6 +231,8 @@ class OpenAIProvider(LLMProvider):
 
         if self._reasoning_override is not None:
             reasoning = self._reasoning_override
+        if self._thinking_override is not None:
+            thinking = self._thinking_override
 
         # Build completion kwargs
         kwargs = {
@@ -222,6 +243,7 @@ class OpenAIProvider(LLMProvider):
         # Add tools if provided
         if tools:
             kwargs["tools"] = tools
+            kwargs["tool_choice"] = "auto"
 
         # Add reasoning support via extra_body for providers that support it
         # Skip reasoning for custom base URLs (they may not support it)
@@ -229,6 +251,33 @@ class OpenAIProvider(LLMProvider):
         if reasoning and self._provider in REASONING_SUPPORTED_PROVIDERS and not is_custom_api:
             kwargs["extra_body"] = {"reasoning": {"enabled": True}}
 
+        # Add extended thinking for Anthropic models
+        # This uses Anthropic's native thinking parameter
+        if thinking and self._provider in THINKING_SUPPORTED_PROVIDERS and not is_custom_api:
+            extra_body = kwargs.get("extra_body", {})
+            extra_body["thinking"] = {
+                "type": "enabled",
+                "budget_tokens": self._thinking_budget,
+            }
+            kwargs["extra_body"] = extra_body
+            log.info(
+                "Extended thinking enabled provider={} model={} budget={}",
+                self._provider,
+                self.model,
+                self._thinking_budget,
+            )
+
+        # Add reasoning_effort for Fireworks thinking models
+        # This controls the depth of reasoning: none, low, medium, high
+        if thinking and self._provider == "fireworks" and self._reasoning_effort != "none":
+            kwargs["reasoning_effort"] = self._reasoning_effort
+            log.info(
+                "Reasoning effort enabled provider={} model={} effort={}",
+                self._provider,
+                self.model,
+                self._reasoning_effort,
+            )
+
         # Add images if provided (vision support)
         if images:
             log.info(
@@ -287,21 +336,32 @@ class OpenAIProvider(LLMProvider):
             )
 
         # Call OpenAI SDK
+        start_time = time.time()
         try:
             response = self.client.chat.completions.create(**kwargs)
         except Exception as exc:  # pragma: no cover - defensive logging
+            elapsed = time.time() - start_time
             status = getattr(exc, "status_code", None)
             code = getattr(exc, "code", None)
             log.exception(
-                "LLM request failed provider={} model={} status={} code={} error={}",
+                "LLM request failed provider={} model={} status={} code={} elapsed={:.1f}s error={}",
                 self._provider,
                 self.model,
                 status,
                 code,
+                elapsed,
                 exc,
             )
             raise
 
+        elapsed = time.time() - start_time
+        log.info(
+            "LLM request completed provider={} model={} elapsed={:.1f}s",
+            self._provider,
+            self.model,
+            elapsed,
+        )
+
         return self._to_llm_response(response)
 
     def _to_llm_response(self, response) -> LLMResponse:
@@ -322,8 +382,42 @@ class OpenAIProvider(LLMProvider):
         choice = response.choices[0]
         message = choice.message
 
-        # Extract content
-        content = message.content
+        # Extract content and thinking
+        content = None
+        thinking = None
+
+        # Check if content is a list of content blocks (Anthropic extended thinking)
+        raw_content = message.content
+        if isinstance(raw_content, list):
+            # Content blocks format (Anthropic with extended thinking)
+            text_parts = []
+            thinking_parts = []
+            for block in raw_content:
+                if hasattr(block, "type"):
+                    if block.type == "thinking":
+                        thinking_parts.append(getattr(block, "thinking", ""))
+                    elif block.type == "text":
+                        text_parts.append(getattr(block, "text", ""))
+                elif isinstance(block, dict):
+                    if block.get("type") == "thinking":
+                        thinking_parts.append(block.get("thinking", ""))
+                    elif block.get("type") == "text":
+                        text_parts.append(block.get("text", ""))
+            content = "\n".join(text_parts) if text_parts else None
+            thinking = "\n".join(thinking_parts) if thinking_parts else None
+        else:
+            # Simple string content
+            content = raw_content
+
+        # Check for reasoning_content field (Fireworks/OpenAI thinking models)
+        # This is separate from Anthropic's content blocks format
+        if not thinking and hasattr(message, "reasoning_content") and message.reasoning_content:
+            thinking = message.reasoning_content
+            log.debug(
+                "Reasoning content extracted from message.reasoning_content provider={} len={}",
+                self._provider,
+                len(thinking),
+            )
 
         # Extract tool calls
         tool_calls = []
@@ -338,17 +432,39 @@ class OpenAIProvider(LLMProvider):
         # Extract token usage if available
         input_tokens = 0
         output_tokens = 0
+        thinking_tokens = 0
         if hasattr(response, "usage") and response.usage:
             input_tokens = getattr(response.usage, "prompt_tokens", 0) or 0
             output_tokens = getattr(response.usage, "completion_tokens", 0) or 0
+            # Try to get reasoning/thinking tokens from the API response
+            # Different providers use different field names
+            thinking_tokens = (
+                getattr(response.usage, "reasoning_tokens", 0)
+                or getattr(response.usage, "thinking_tokens", 0)
+                or 0
+            )
+            # If no explicit thinking tokens but we have thinking content, estimate
+            if not thinking_tokens and thinking:
+                thinking_tokens = len(thinking) // 4  # Rough estimate
+
+        if thinking:
+            log.info(
+                "Extended thinking captured provider={} model={} thinking_len={} thinking_tokens={}",
+                self._provider,
+                self.model,
+                len(thinking),
+                thinking_tokens,
+            )
 
         return LLMResponse(
             content=content,
+            thinking=thinking,
             tool_calls=tool_calls,
             raw=response,
             stop_reason=choice.finish_reason,
             input_tokens=input_tokens,
             output_tokens=output_tokens,
+            thinking_tokens=thinking_tokens,
         )
 
     def get_context_limit(self) -> int:
@@ -373,6 +489,14 @@ class OpenAIProvider(LLMProvider):
         # For unknown models, assume no vision support
         return False
 
+    def supports_thinking(self) -> bool:
+        """Check if this model supports extended thinking."""
+        if self.chat_model:
+            return self.chat_model.spec.supports_thinking
+
+        # For unknown models, check if provider supports thinking
+        return self._provider in THINKING_SUPPORTED_PROVIDERS
+
     def _format_image_for_api(self, image: ImageContent) -> dict:
         """Format an image for OpenAI/Anthropic API.
 

emdash_core/agent/runner/__init__.py

@@ -0,0 +1,49 @@
+"""Agent runner module for LLM-powered exploration.
+
+This module provides the AgentRunner class and related utilities for running
+LLM agents with tool access for code exploration.
+
+The module is organized as follows:
+- agent_runner.py: Main AgentRunner class
+- context.py: Context estimation, compaction, and management
+- plan.py: Plan approval/rejection functionality
+- utils.py: JSON encoding and utility functions
+"""
+
+from .agent_runner import AgentRunner
+from .sdk_runner import SDKAgentRunner, is_claude_model
+from .factory import get_runner, create_hybrid_runner
+from .utils import SafeJSONEncoder, summarize_tool_result
+from .context import (
+    estimate_context_tokens,
+    get_context_breakdown,
+    maybe_compact_context,
+    compact_messages_with_llm,
+    format_messages_for_summary,
+    get_reranked_context,
+    emit_context_frame,
+)
+from .plan import PlanMixin
+
+__all__ = [
+    # Main classes
+    "AgentRunner",
+    "SDKAgentRunner",
+    # Factory functions
+    "get_runner",
+    "create_hybrid_runner",
+    "is_claude_model",
+    # Utils
+    "SafeJSONEncoder",
+    "summarize_tool_result",
+    # Context functions
+    "estimate_context_tokens",
+    "get_context_breakdown",
+    "maybe_compact_context",
+    "compact_messages_with_llm",
+    "format_messages_for_summary",
+    "get_reranked_context",
+    "emit_context_frame",
+    # Plan management
+    "PlanMixin",
+]