custom think tool added

ui/inference/completion.py

@@ -16,7 +16,7 @@ def complete_turn(
     temperature: float,
     top_p: float,
     tools: list[dict[str, Any]] | None,
-    tool_choice: str = "auto",
+    tool_choice: Any = "auto",
 ) -> tuple[str, str, list[dict[str, Any]] | None]:
     """Run one model turn, preferring streaming and falling back to a single request."""
     content = ""

ui/inference/config.py

@@ -2,8 +2,10 @@
 from __future__ import annotations
 
 from .tool_schemas import TOOL_SCHEMAS
+from .tool_schemas import think as THINK_SCHEMA
 
 MODEL_ID = "Qwen/Qwen3.6-27B"
 MAX_TOOL_ROUNDS = 5
 
 TOOLS = TOOL_SCHEMAS
+THINK_TOOLS = [THINK_SCHEMA]

ui/inference/respond.py

@@ -1,6 +1,8 @@
 # ui/inference/respond.py
 from __future__ import annotations
 
+import json
+import uuid
 from typing import Any
 
 import gradio as gr
@@ -8,7 +10,7 @@ from gradio import ChatMessage
 from huggingface_hub import InferenceClient
 
 from .completion import complete_turn
-from .config import MAX_TOOL_ROUNDS, MODEL_ID, TOOLS
+from .config import MAX_TOOL_ROUNDS, MODEL_ID, THINK_TOOLS, TOOLS
 from .messages import history_to_api_messages, multimodal_input_to_api_content
 from .streaming import yield_response
 from .tools import execute_tool_calls
@@ -46,6 +48,38 @@ def respond(
     ui_messages: list[ChatMessage] = []
 
     try:
+        content, reasoning, tool_calls = complete_turn(
+            client,
+            api_messages,
+            max_tokens=max_tokens,
+            temperature=temperature,
+            top_p=top_p,
+            tools=THINK_TOOLS,
+            tool_choice="required",
+        )
+        if not tool_calls:
+            thought = content or reasoning or "Plan the response before taking action."
+            tool_calls = [
+                {
+                    "id": f"call_{uuid.uuid4().hex}",
+                    "type": "function",
+                    "function": {
+                        "name": "think",
+                        "arguments": json.dumps({"thought": thought}),
+                    },
+                }
+            ]
+            content = ""
+
+        for ui_msg, globe_state in execute_tool_calls(
+            api_messages,
+            ui_messages,
+            tool_calls,
+            content,
+            globe_state,
+        ):
+            yield ui_msg, globe_state
+
         for _ in range(MAX_TOOL_ROUNDS):
             content, reasoning, tool_calls = complete_turn(
                 client,

ui/inference/tool_schemas/__init__.py

@@ -8,9 +8,11 @@ from .get_passport_stats import SCHEMA as get_passport_stats
 from .get_visa_requirement import SCHEMA as get_visa_requirement
 from .scrape_web_page import SCHEMA as scrape_web_page
 from .search_immigration_info import SCHEMA as search_immigration_info
+from .think import SCHEMA as think
 from .update_globe import SCHEMA as update_globe
 
 TOOL_SCHEMAS: list[dict[str, Any]] = [
+    think,
     get_economic_indicator,
     get_visa_requirement,
     get_passport_stats,

ui/inference/tool_schemas/think.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+SCHEMA: dict[str, Any] = {
+    "type": "function",
+    "function": {
+        "name": "think",
+        "description": (
+            "Use this tool as a private scratchpad to reason step by step before "
+            "taking other actions. Record hypotheses, summarize evidence, plan "
+            "next steps, or note uncertainties. Do not use it for final "
+            "user-facing output."
+        ),
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "thought": {
+                    "type": "string",
+                    "description": (
+                        "Internal reasoning notes, intermediate analysis, "
+                        "assumptions, and next-step planning."
+                    ),
+                },
+            },
+            "required": ["thought"],
+        },
+    },
+}

ui/inference/tools.py

@@ -42,6 +42,8 @@ def _run_tool(
     *,
     globe_state: dict[str, Any] | None = None,
 ) -> tuple[Any, dict[str, Any] | None]:
+    if name == "think":
+        return {"ok": True}, globe_state
     if name == "get_economic_indicator":
         return (
             get_indicator_series(
@@ -110,6 +112,65 @@ def execute_tool_calls(
         tool_args = tool_call["function"]["arguments"]
         started = time.monotonic()
 
+        if tool_name == "think":
+            try:
+                args = json.loads(tool_args or "{}")
+            except json.JSONDecodeError:
+                args = {}
+            thought = str(args.get("thought") or "").strip()
+
+            ui_messages.append(
+                ChatMessage(
+                    role="assistant",
+                    content="Thinking…",
+                    metadata={
+                        "title": "Thinking",
+                        "status": "pending",
+                    },
+                )
+            )
+            yield ui_messages, globe_state
+
+            if thought:
+                prefix = "Thinking:\n\n"
+                for index in range(len(thought)):
+                    ui_messages[-1] = ChatMessage(
+                        role="assistant",
+                        content=f"{prefix}{thought[: index + 1]}",
+                        metadata={
+                            "title": "Thinking",
+                            "status": "pending",
+                        },
+                    )
+                    yield ui_messages, globe_state
+
+            result, globe_state = run_tool(
+                tool_name,
+                tool_args,
+                globe_state=globe_state,
+            )
+            duration = time.monotonic() - started
+            ui_messages[-1] = ChatMessage(
+                role="assistant",
+                content=f"Thinking:\n\n{thought}" if thought else "Thinking complete.",
+                metadata={
+                    "title": "Thinking",
+                    "status": "done",
+                    "duration": duration,
+                },
+            )
+            yield ui_messages, globe_state
+
+            api_messages.append(
+                {
+                    "role": "tool",
+                    "tool_call_id": tool_call["id"],
+                    "name": tool_name,
+                    "content": result,
+                }
+            )
+            continue
+
         ui_messages.append(
             ChatMessage(
                 role="assistant",