show thinking

Signed-off-by: Jintao Zhang <zhangjintao9020@gmail.com>

src/amcp/acp_agent.py

@@ -29,6 +29,7 @@ from acp import (
     start_tool_call,
     text_block,
     update_agent_message,
+    update_agent_thought,
     update_tool_call,
 )
 from acp.interfaces import Client
@@ -55,8 +56,8 @@ from acp.schema import (
 )
 
 from .agent_spec import ResolvedAgentSpec, get_default_agent_spec
-from .chat import _make_client, _resolve_api_key, _resolve_base_url
 from .config import load_config
+from .llm import create_llm_client
 from .mcp_client import call_mcp_tool, list_mcp_tools
 from .tools import ToolResult, get_tool_registry
 
@@ -473,10 +474,7 @@ class AMCPAgent(Agent):
     async def _process_prompt(self, session: ACPSession, user_text: str) -> str:
         """Process prompt with LLM and tools."""
         cfg = load_config()
-        base_url = _resolve_base_url(self.agent_spec.base_url or None, cfg.chat)
-        api_key = _resolve_api_key(None, cfg.chat)
-        client = _make_client(base_url, api_key)
-        model = cfg.chat.model if cfg.chat else "DeepSeek-V3.1-Terminus"
+        llm_client = create_llm_client(cfg.chat)
 
         system_prompt = self._get_system_prompt(session)
         messages = [{"role": "system", "content": system_prompt}]
@@ -490,19 +488,17 @@ class AMCPAgent(Agent):
             if session.session_id in self._cancelled_sessions:
                 raise asyncio.CancelledError()
 
-            resp = client.chat.completions.create(
-                model=model,
-                messages=messages,
-                tools=tools if tools else None,
-                tool_choice="auto" if tools else None,
-                stream=False,
-            )
+            resp = llm_client.chat(messages=messages, tools=tools if tools else None)
 
-            msg = resp.choices[0].message
-            tool_calls = getattr(msg, "tool_calls", None)
+            # Send thinking content if available
+            if resp.thinking and self._conn:
+                await self._conn.session_update(
+                    session_id=session.session_id,
+                    update=update_agent_thought(text_block(resp.thinking)),
+                )
 
-            if not tool_calls:
-                final_text = msg.content or ""
+            if not resp.tool_calls:
+                final_text = resp.content or ""
                 if self._conn:
                     await self._conn.session_update(
                         session_id=session.session_id,
@@ -510,9 +506,9 @@ class AMCPAgent(Agent):
                     )
                 return final_text
 
-            for tc in tool_calls:
-                tool_name = tc.function.name
-                args = json.loads(tc.function.arguments or "{}")
+            for tc in resp.tool_calls:
+                tool_name = tc["name"]
+                args = json.loads(tc["arguments"] or "{}")
                 tool_call_id = f"call_{uuid4().hex[:8]}"
 
                 # Request permission in "ask" mode for write operations
@@ -522,7 +518,7 @@ class AMCPAgent(Agent):
                         messages.append(
                             {
                                 "role": "tool",
-                                "tool_call_id": tc.id,
+                                "tool_call_id": tc["id"],
                                 "name": tool_name,
                                 "content": "Permission denied by user",
                             }
@@ -555,17 +551,17 @@ class AMCPAgent(Agent):
                 messages.append(
                     {
                         "role": "assistant",
-                        "content": msg.content or "",
+                        "content": resp.content or "",
                         "tool_calls": [
                             {
-                                "id": tc.id,
+                                "id": tc["id"],
                                 "type": "function",
-                                "function": {"name": tool_name, "arguments": tc.function.arguments or "{}"},
+                                "function": {"name": tool_name, "arguments": tc["arguments"] or "{}"},
                             }
                         ],
                     }
                 )
-                messages.append({"role": "tool", "tool_call_id": tc.id, "name": tool_name, "content": result[:8000]})
+                messages.append({"role": "tool", "tool_call_id": tc["id"], "name": tool_name, "content": result[:8000]})
 
         return "Maximum steps reached. Please try a simpler request."
 

src/amcp/llm.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import json
 import os
+import re
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from typing import Any
@@ -11,6 +12,17 @@ from typing import Any
 from .config import ChatConfig
 
 
+def _extract_think_tags(content: str) -> tuple[str | None, str]:
+    """Extract content from <think> tags and return (thinking, remaining_content)."""
+    pattern = r"<think>(.*?)</think>"
+    matches = re.findall(pattern, content, re.DOTALL)
+    if matches:
+        thinking = "\n".join(m.strip() for m in matches)
+        remaining = re.sub(pattern, "", content, flags=re.DOTALL).strip()
+        return thinking, remaining
+    return None, content
+
+
 @dataclass
 class LLMResponse:
     """Unified response from LLM."""
@@ -18,6 +30,7 @@ class LLMResponse:
     content: str | None
     tool_calls: list[dict[str, Any]] | None = None
     stop_reason: str | None = None
+    thinking: str | None = None  # Reasoning/thinking content from LLM
 
 
 class BaseLLMClient(ABC):
@@ -53,7 +66,20 @@ class OpenAIClient(BaseLLMClient):
                 {"id": tc.id, "name": tc.function.name, "arguments": tc.function.arguments} for tc in msg.tool_calls
             ]
 
-        return LLMResponse(content=msg.content, tool_calls=tool_calls, stop_reason=resp.choices[0].finish_reason)
+        # Extract thinking content
+        thinking = None
+        content = msg.content
+
+        # Check for reasoning_content field (DeepSeek, some OpenAI-compatible APIs)
+        if hasattr(msg, "reasoning_content") and msg.reasoning_content:
+            thinking = msg.reasoning_content
+        # Check for <think> tags in content
+        elif content:
+            thinking, content = _extract_think_tags(content)
+
+        return LLMResponse(
+            content=content, tool_calls=tool_calls, stop_reason=resp.choices[0].finish_reason, thinking=thinking
+        )
 
 
 class OpenAIResponsesClient(BaseLLMClient):
@@ -181,10 +207,14 @@ class AnthropicClient(BaseLLMClient):
 
         content_parts = []
         tool_calls = []
+        thinking_parts = []
 
         for block in resp.content:
             if block.type == "text":
                 content_parts.append(block.text)
+            elif block.type == "thinking":
+                # Anthropic extended thinking block
+                thinking_parts.append(getattr(block, "thinking", ""))
             elif block.type == "tool_use":
                 tool_calls.append({"id": block.id, "name": block.name, "arguments": json.dumps(block.input)})
 
@@ -192,6 +222,7 @@ class AnthropicClient(BaseLLMClient):
             content="\n".join(content_parts) if content_parts else None,
             tool_calls=tool_calls if tool_calls else None,
             stop_reason=resp.stop_reason,
+            thinking="\n".join(thinking_parts) if thinking_parts else None,
         )