feat: DeepSeek V4 Pro integration + thinking block round-trip

- deepseek-v4-pro[1m] registered as ANTHROPIC provider
- Auto-detects ANTHROPIC_BASE_URL + ANTHROPIC_AUTH_TOKEN from env
- Model name + baseUrl + authToken auto-populated in runtime
- thinking block capture + replay for DeepSeek extended thinking mode
- Full agent flow verified: memory injection → tool calls → response

737 passed, 2 skipped

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: QUSETIONS

minicode/anthropic_adapter.py

@@ -137,6 +137,7 @@ def __init__(self, runtime: dict[str, Any], tools) -> None:
         # Cache the serialized tool list — tools rarely change within a session
         self._cached_tools_json: list[dict[str, Any]] | None = None
         self._tools_cache_key: int = 0  # hash of tool list for invalidation
+        self._thinking_blocks: list[dict[str, Any]] = []  # Preserve thinking blocks for round-trip
 
     def _get_serialized_tools(self) -> list[dict[str, Any]]:
         """Get serialized tool list with caching."""
@@ -156,6 +157,18 @@ def _get_serialized_tools(self) -> list[dict[str, Any]]:
 
     def next(self, messages: list[dict[str, Any]], on_stream_chunk: Callable[[str], None] | None = None, store: Store[AppState] | None = None) -> AgentStep:
         system_message, converted_messages = _to_anthropic_messages(messages)
+
+        # Inject stored thinking blocks into the last assistant message
+        if self._thinking_blocks:
+            for i in range(len(converted_messages) - 1, -1, -1):
+                if converted_messages[i].get("role") == "assistant":
+                    existing = converted_messages[i].get("content", [])
+                    if isinstance(existing, list):
+                        converted_messages[i] = dict(converted_messages[i])
+                        converted_messages[i]["content"] = list(self._thinking_blocks) + existing
+                    break
+            self._thinking_blocks = []
+
         request_body = {
             "model": self.runtime["model"],
             "system": system_message,
@@ -251,6 +264,8 @@ def next(self, messages: list[dict[str, Any]], on_stream_chunk: Callable[[str],
                     text_parts.append(block["text"])
                 elif block_type == "tool_use" and isinstance(block.get("id"), str) and isinstance(block.get("name"), str):
                     tool_calls.append({"id": block["id"], "toolName": block["name"], "input": block.get("input")})
+                elif block_type == "thinking":
+                    self._thinking_blocks.append(block)  # Preserve for round-trip
                 else:
                     ignored_block_types.append(str(block_type))
 
@@ -277,6 +292,7 @@ def next(self, messages: list[dict[str, Any]], on_stream_chunk: Callable[[str],
         block_types = []
         ignored_block_types = []
         active_tool_call = None
+        active_thinking_block = None
         stop_reason = None
 
         # Streaming cost tracking
@@ -315,6 +331,8 @@ def next(self, messages: list[dict[str, Any]], on_stream_chunk: Callable[[str],
                         "name": cb.get("name"),
                         "input_json": ""
                     }
+                elif c_type == "thinking":
+                    active_thinking_block = {"type": "thinking", "thinking": ""}
             elif etype == "content_block_delta":
                 delta = event.get("delta", {})
                 d_type = delta.get("type")
@@ -325,6 +343,12 @@ def next(self, messages: list[dict[str, Any]], on_stream_chunk: Callable[[str],
                 elif d_type == "input_json_delta":
                     if active_tool_call:
                         active_tool_call["input_json"] += delta.get("partial_json", "")
+                elif d_type == "thinking_delta":
+                    if active_thinking_block:
+                        active_thinking_block["thinking"] += delta.get("thinking", "")
+                elif d_type == "signature_delta":
+                    if active_thinking_block:
+                        active_thinking_block["signature"] = active_thinking_block.get("signature", "") + delta.get("signature", "")
             elif etype == "content_block_stop":
                 if active_tool_call:
                     try:
@@ -337,6 +361,9 @@ def next(self, messages: list[dict[str, Any]], on_stream_chunk: Callable[[str],
                         "input": parsed_input
                     })
                     active_tool_call = None
+                if active_thinking_block:
+                    self._thinking_blocks.append(active_thinking_block)
+                    active_thinking_block = None
             elif etype == "message_delta":
                 delta = event.get("delta", {})
                 if "stop_reason" in delta:

minicode/model_registry.py

@@ -296,7 +296,7 @@ def _aliases(name: str) -> list[str]:
 _register(ModelInfo("deepseek/deepseek-chat", Provider.OPENROUTER,
     context_window=128_000, max_output_tokens=8_192,
     pricing_input=0.14, pricing_output=0.28))
-_register(ModelInfo("deepseek-v4-pro[1m]", Provider.CUSTOM,
+_register(ModelInfo("deepseek-v4-pro[1m]", Provider.ANTHROPIC,
     display_name="DeepSeek V4 Pro",
     context_window=128_000, max_output_tokens=8_192,
     pricing_input=0.10, pricing_output=0.40))
@@ -562,7 +562,16 @@ def create_model_adapter(
 
     # Anthropic
     from minicode.anthropic_adapter import AnthropicModelAdapter
-    return AnthropicModelAdapter(runtime or {}, tools)
+    enriched = dict(runtime or {})
+    if "model" not in enriched:
+        enriched["model"] = model
+    if "baseUrl" not in enriched:
+        enriched["baseUrl"] = os.environ.get("ANTHROPIC_BASE_URL", "https://api.anthropic.com")
+    if "authToken" not in enriched and "apiKey" not in enriched:
+        token = os.environ.get("ANTHROPIC_AUTH_TOKEN", "") or os.environ.get("ANTHROPIC_API_KEY", "")
+        if token:
+            enriched["authToken"] = token
+    return AnthropicModelAdapter(enriched, tools)
 
 
 # ---------------------------------------------------------------------------