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

emdash_core/agent/providers/openai_provider.py

@@ -30,6 +30,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):
     """
@@ -131,6 +134,8 @@ 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"))
 
         self.client = OpenAI(
             api_key=api_key,
@@ -191,6 +196,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 +207,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 +219,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 = {
@@ -229,6 +238,22 @@ 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 images if provided (vision support)
         if images:
             log.info(
@@ -322,8 +347,32 @@ 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
 
         # Extract tool calls
         tool_calls = []
@@ -338,17 +387,32 @@ 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
+            # Anthropic returns thinking tokens in cache_creation_input_tokens or similar
+            # For now, estimate from the thinking content length
+            if thinking:
+                thinking_tokens = len(thinking) // 4  # Rough estimate
+
+        if thinking:
+            log.info(
+                "Extended thinking captured provider={} model={} thinking_len={}",
+                self._provider,
+                self.model,
+                len(thinking),
+            )
 
         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 +437,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.