klaude-code 1.2.16__py3-none-any.whl → 1.2.17__py3-none-any.whl

klaude_code/cli/runtime.py

@@ -261,7 +261,15 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
     restore_sigint = install_sigint_double_press_exit(_show_toast_once, _hide_progress)
 
     try:
-        active_session_id = await initialize_session(components.executor, components.event_queue, session_id=session_id)
+        await initialize_session(components.executor, components.event_queue, session_id=session_id)
+
+        def _get_active_session_id() -> str | None:
+            """Get the current active session ID dynamically.
+
+            This is necessary because /clear command creates a new session with a different ID.
+            """
+            active_ids = components.executor.context.agent_manager.active_session_ids()
+            return active_ids[0] if active_ids else None
 
         # Input
         await input_provider.start()
@@ -272,6 +280,8 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
             elif user_input.text.strip() == "":
                 continue
             # Submit user input operation - directly use the payload from iter_inputs
+            # Use dynamic session_id lookup to handle /clear creating new sessions
+            active_session_id = _get_active_session_id()
             submission_id = await components.executor.submit(
                 op.UserInputOperation(input=user_input, session_id=active_session_id)
             )
@@ -282,7 +292,7 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
             else:
                 # Esc monitor for long-running, interruptible operations
                 async def _on_esc_interrupt() -> None:
-                    await components.executor.submit(op.InterruptOperation(target_session_id=active_session_id))
+                    await components.executor.submit(op.InterruptOperation(target_session_id=_get_active_session_id()))
 
                 stop_event, esc_task = start_esc_interrupt_monitor(_on_esc_interrupt)
                 # Wait for this specific task to complete before accepting next input

klaude_code/command/__init__.py

@@ -30,6 +30,7 @@ def ensure_commands_loaded() -> None:
     from .clear_cmd import ClearCommand
     from .diff_cmd import DiffCommand
     from .export_cmd import ExportCommand
+    from .export_online_cmd import ExportOnlineCommand
     from .help_cmd import HelpCommand
     from .model_cmd import ModelCommand
     from .refresh_cmd import RefreshTerminalCommand
@@ -40,6 +41,7 @@ def ensure_commands_loaded() -> None:
 
     # Register in desired display order
     register(ExportCommand())
+    register(ExportOnlineCommand())
     register(RefreshTerminalCommand())
     register(ThinkingCommand())
     register(ModelCommand())
@@ -60,6 +62,7 @@ def __getattr__(name: str) -> object:
         "ClearCommand": "clear_cmd",
         "DiffCommand": "diff_cmd",
         "ExportCommand": "export_cmd",
+        "ExportOnlineCommand": "export_online_cmd",
         "HelpCommand": "help_cmd",
         "ModelCommand": "model_cmd",
         "RefreshTerminalCommand": "refresh_cmd",

klaude_code/command/export_online_cmd.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import secrets
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from klaude_code.command.command_abc import CommandABC, CommandResult
+from klaude_code.protocol import commands, events, model
+from klaude_code.session.export import build_export_html
+
+if TYPE_CHECKING:
+    from klaude_code.core.agent import Agent
+
+
+class ExportOnlineCommand(CommandABC):
+    """Export and deploy the current session to surge.sh as a static webpage."""
+
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.EXPORT_ONLINE
+
+    @property
+    def summary(self) -> str:
+        return "Export and deploy session to surge.sh"
+
+    @property
+    def support_addition_params(self) -> bool:
+        return False
+
+    @property
+    def is_interactive(self) -> bool:
+        return False
+
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
+        # Check if npx or surge is available
+        surge_cmd = self._get_surge_command()
+        if not surge_cmd:
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content="surge.sh CLI not found. Install with: npm install -g surge",
+                    command_output=model.CommandOutput(command_name=self.name, is_error=True),
+                ),
+            )
+            return CommandResult(events=[event])
+
+        # Check if user is logged in to surge
+        if not self._is_surge_logged_in(surge_cmd):
+            login_cmd = " ".join([*surge_cmd, "login"])
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content=f"Not logged in to surge.sh. Please run: {login_cmd}",
+                    command_output=model.CommandOutput(command_name=self.name, is_error=True),
+                ),
+            )
+            return CommandResult(events=[event])
+
+        try:
+            html_doc = self._build_html(agent)
+            domain = self._generate_domain()
+            url = self._deploy_to_surge(surge_cmd, html_doc, domain)
+
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content=f"Session deployed to: {url}",
+                    command_output=model.CommandOutput(command_name=self.name),
+                ),
+            )
+            return CommandResult(events=[event])
+        except Exception as exc:
+            import traceback
+
+            event = events.DeveloperMessageEvent(
+                session_id=agent.session.id,
+                item=model.DeveloperMessageItem(
+                    content=f"Failed to deploy session: {exc}\n{traceback.format_exc()}",
+                    command_output=model.CommandOutput(command_name=self.name, is_error=True),
+                ),
+            )
+            return CommandResult(events=[event])
+
+    def _get_surge_command(self) -> list[str] | None:
+        """Check if surge CLI is available, prefer npx if available."""
+        # Check for npx first (more common)
+        if shutil.which("npx"):
+            return ["npx", "surge"]
+        # Check for globally installed surge
+        if shutil.which("surge"):
+            return ["surge"]
+        return None
+
+    def _is_surge_logged_in(self, surge_cmd: list[str]) -> bool:
+        """Check if user is logged in to surge.sh via 'surge whoami'."""
+        try:
+            cmd = [*surge_cmd, "whoami"]
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=30,
+            )
+            # If logged in, whoami returns 0 and prints the email
+            # If not logged in, it returns non-zero or prints "Not Authenticated"
+            if result.returncode != 0:
+                return False
+            output = (result.stdout + result.stderr).lower()
+            if "not authenticated" in output or "not logged in" in output:
+                return False
+            return bool(result.stdout.strip())
+        except (subprocess.TimeoutExpired, OSError):
+            return False
+
+    def _generate_domain(self) -> str:
+        """Generate a random subdomain for surge.sh."""
+        random_suffix = secrets.token_hex(4)
+        return f"klaude-session-{random_suffix}.surge.sh"
+
+    def _deploy_to_surge(self, surge_cmd: list[str], html_content: str, domain: str) -> str:
+        """Deploy HTML content to surge.sh and return the URL."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            html_path = Path(tmpdir) / "index.html"
+            html_path.write_text(html_content, encoding="utf-8")
+
+            # Run surge with --domain flag
+            cmd = [*surge_cmd, tmpdir, "--domain", domain]
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=60,
+            )
+
+            if result.returncode != 0:
+                error_msg = result.stderr or result.stdout or "Unknown error"
+                raise RuntimeError(f"Surge deployment failed: {error_msg}")
+
+            return f"https://{domain}"
+
+    def _build_html(self, agent: Agent) -> str:
+        profile = agent.profile
+        system_prompt = (profile.system_prompt if profile else "") or ""
+        tools = profile.tools if profile else []
+        model_name = profile.llm_client.model_name if profile else "unknown"
+        return build_export_html(agent.session, system_prompt, tools, model_name)

klaude_code/config/config.py

@@ -79,8 +79,8 @@ class Config(BaseModel):
 
 def get_example_config() -> Config:
     return Config(
-        main_model="gpt-5.1",
-        sub_agent_models={"explore": "haiku", "oracle": "gpt-5.1-high"},
+        main_model="opus",
+        sub_agent_models={"explore": "haiku", "oracle": "gpt-5.1", "webagent": "haiku", "task": "opus"},
         provider_list=[
             llm_param.LLMConfigProviderParameter(
                 provider_name="openai",
@@ -93,6 +93,11 @@ def get_example_config() -> Config:
                 protocol=llm_param.LLMClientProtocol.OPENROUTER,
                 api_key="your-openrouter-api-key",
             ),
+            llm_param.LLMConfigProviderParameter(
+                provider_name="anthropic",
+                protocol=llm_param.LLMClientProtocol.ANTHROPIC,
+                api_key="your-anthropic-api-key",
+            ),
         ],
         model_list=[
             ModelConfig(
@@ -100,31 +105,25 @@ def get_example_config() -> Config:
                 provider="openai",
                 model_params=llm_param.LLMConfigModelParameter(
                     model="gpt-5.1-2025-11-13",
-                    max_tokens=32000,
                     verbosity="medium",
                     thinking=llm_param.Thinking(
-                        reasoning_effort="medium",
+                        reasoning_effort="high",
                         reasoning_summary="auto",
-                        type="enabled",
-                        budget_tokens=None,
                     ),
-                    context_limit=368000,
+                    context_limit=400000,
                 ),
             ),
             ModelConfig(
-                model_name="gpt-5.1-high",
-                provider="openai",
+                model_name="opus",
+                provider="anthropic",
                 model_params=llm_param.LLMConfigModelParameter(
-                    model="gpt-5.1-2025-11-13",
-                    max_tokens=32000,
-                    verbosity="medium",
+                    model="claude-opus-4-5-20251101",
+                    verbosity="high",
                     thinking=llm_param.Thinking(
-                        reasoning_effort="high",
-                        reasoning_summary="auto",
                         type="enabled",
-                        budget_tokens=None,
+                        budget_tokens=31999,
                     ),
-                    context_limit=368000,
+                    context_limit=200000,
                 ),
             ),
             ModelConfig(
@@ -136,7 +135,7 @@ def get_example_config() -> Config:
                     provider_routing=llm_param.OpenRouterProviderRouting(
                         sort="throughput",
                     ),
-                    context_limit=168000,
+                    context_limit=200000,
                 ),
             ),
         ],

klaude_code/core/manager/sub_agent_manager.py

@@ -57,7 +57,7 @@ class SubAgentManager:
 # Structured Output
 You have a `report_back` tool available. When you complete the task,\
 you MUST call `report_back` with the structured result matching the required schema.\
-This will end the task and return the structured data to the caller.
+Only the content passed to `report_back` will be returned to user.\
 """
             base_prompt = child_profile.system_prompt or ""
             child_profile = AgentProfile(

klaude_code/core/prompts/prompt-sub-agent-oracle.md

@@ -3,7 +3,6 @@ You are the Oracle - an expert AI advisor with advanced reasoning capabilities
 Your role is to provide high-quality technical guidance, code reviews, architectural advice, and strategic planning for software engineering tasks.
 You are running inside an AI coding system in which you act as a sub-agent that's used when the main agent needs a smarter, more capable model to help out.
 
-
 Key responsibilities:
 - Analyze code and architecture patterns
 - Provide detailed technical reviews and recommendations

klaude_code/core/prompts/prompt-sub-agent-web.md

@@ -0,0 +1,48 @@
+You are a web research agent that searches and fetches web content to provide up-to-date information.
+
+## Available Tools
+
+**WebSearch**: Search the web via DuckDuckGo
+- Returns: title, URL, and snippet for each result
+- Parameter `max_results`: control result count (default: 10, max: 20)
+- Snippets are brief summaries - use WebFetch for full content
+
+**WebFetch**: Fetch and process web page content
+- HTML pages are automatically converted to Markdown
+- JSON responses are auto-formatted with indentation
+- Other text content returned as-is
+
+## Tool Usage Strategy
+
+Scale tool calls to query complexity:
+- Simple facts: 1-2 calls
+- Medium research: 3-5 calls
+- Deep research/comparisons: 5-10 calls
+
+Balance efficiency with thoroughness. For open-ended questions (e.g., "recommendations for video games" or "recent developments in RL"), use more calls for comprehensive answers.
+
+## Search Guidelines
+
+- Keep queries concise (1-6 words). Start broad, then narrow if needed
+- Avoid repeating similar queries - they won't yield new results
+- NEVER use '-', 'site:', or quotes unless explicitly asked
+- Include year/date for time-sensitive queries (check "Today's date" in <env>)
+- Use WebFetch to get full content - search snippets are often insufficient
+- Follow relevant links on pages with WebFetch
+- If truncated results are saved to local files, use grep/read to explore
+
+## Response Guidelines
+
+- Only your last message is returned to the main agent
+- Be succinct - include only relevant information
+- Lead with the most recent info for evolving topics
+- Favor original sources (company blogs, papers, gov sites) over aggregators
+- Note conflicting sources when they exist
+
+## Sources (REQUIRED)
+
+You MUST end every response with a "Sources:" section listing all URLs as markdown links:
+
+Sources:
+- [Source Title](https://example.com)
+- [Another Source](https://example.com/page) (saved: /path/to/file)

klaude_code/core/task.py

@@ -182,6 +182,14 @@ class TaskExecutor:
                                 yield am
                             case events.ResponseMetadataEvent() as e:
                                 metadata_accumulator.add(e.metadata)
+                                # Emit context usage event if available
+                                if e.metadata.usage is not None:
+                                    context_percent = e.metadata.usage.context_usage_percent
+                                    if context_percent is not None:
+                                        yield events.ContextUsageEvent(
+                                            session_id=session_ctx.session_id,
+                                            context_percent=context_percent,
+                                        )
                             case events.ToolResultEvent() as e:
                                 # Collect sub-agent task metadata from tool results
                                 if e.task_metadata is not None:

klaude_code/core/tool/__init__.py

@@ -28,6 +28,7 @@ from .tool_runner import run_tool
 from .truncation import SimpleTruncationStrategy, TruncationStrategy, get_truncation_strategy, set_truncation_strategy
 from .web.mermaid_tool import MermaidTool
 from .web.web_fetch_tool import WebFetchTool
+from .web.web_search_tool import WebSearchTool
 
 __all__ = [
     "MEMORY_DIR_NAME",
@@ -53,6 +54,7 @@ __all__ = [
     "TruncationStrategy",
     "UpdatePlanTool",
     "WebFetchTool",
+    "WebSearchTool",
     "WriteTool",
     "build_todo_context",
     "current_run_subtask_callback",

klaude_code/core/tool/report_back_tool.py

@@ -1,10 +1,35 @@
 """ReportBackTool for sub-agents to return structured output."""
 
-from typing import Any, ClassVar
+from typing import Any, ClassVar, cast
 
 from klaude_code.protocol import llm_param, model, tools
 
 
+def _normalize_schema_types(schema: dict[str, Any]) -> dict[str, Any]:
+    """Recursively normalize JSON schema type values to lowercase.
+
+    Some LLMs (e.g., Gemini 3) generate type values in uppercase like "OBJECT", "STRING".
+    Standard JSON Schema requires lowercase type values.
+    """
+    result: dict[str, Any] = {}
+    for key, value in schema.items():
+        if key == "type" and isinstance(value, str):
+            result[key] = value.lower()
+        elif isinstance(value, dict):
+            result[key] = _normalize_schema_types(cast(dict[str, Any], value))
+        elif isinstance(value, list):
+            normalized_list: list[Any] = []
+            for item in cast(list[Any], value):
+                if isinstance(item, dict):
+                    normalized_list.append(_normalize_schema_types(cast(dict[str, Any], item)))
+                else:
+                    normalized_list.append(item)
+            result[key] = normalized_list
+        else:
+            result[key] = value
+    return result
+
+
 class ReportBackTool:
     """Special tool for sub-agents to return structured output and end the task.
 
@@ -29,7 +54,8 @@ class ReportBackTool:
         Returns:
             A new class with the schema set as a class variable.
         """
-        return type("ReportBackTool", (ReportBackTool,), {"_schema": schema})
+        normalized = _normalize_schema_types(schema)
+        return type("ReportBackTool", (ReportBackTool,), {"_schema": normalized})
 
     @classmethod
     def schema(cls) -> llm_param.ToolSchema:

klaude_code/core/tool/web/web_search_tool.md

@@ -0,0 +1,23 @@
+- Search the web and use the results to inform responses
+- Provides up-to-date information for current events and recent data
+- Returns search result information formatted as search result blocks, including links as markdown hyperlinks
+- Use this tool for accessing information beyond your knowledge cutoff
+- Searches are performed automatically within a single API call
+
+CRITICAL REQUIREMENT - You MUST follow this:
+- After answering the user's question, you MUST include a "Sources:" section at the end of your response
+- In the Sources section, list all relevant URLs from the search results as markdown hyperlinks: [Title](URL)
+- This is MANDATORY - never skip including sources in your response
+- Example format:
+
+[Your answer here]
+
+Sources:
+- [Source Title 1](https://example.com/1)
+- [Source Title 2](https://example.com/2)
+
+Usage notes:
+- Domain filtering is supported to include or block specific websites
+- Web search is only available in the US
+- Account for "Today's date" in <env>. For example, if <env> says "Today's date: 2025-07-01", and the user wants the latest docs, do not use 2024 in the search query. Use 2025.
+

klaude_code/core/tool/web/web_search_tool.py

@@ -0,0 +1,126 @@
+import asyncio
+from dataclasses import dataclass
+from pathlib import Path
+
+from pydantic import BaseModel
+
+from klaude_code.core.tool.tool_abc import ToolABC, load_desc
+from klaude_code.core.tool.tool_registry import register
+from klaude_code.protocol import llm_param, model, tools
+
+DEFAULT_MAX_RESULTS = 10
+MAX_RESULTS_LIMIT = 20
+
+
+@dataclass
+class SearchResult:
+    """A single search result from DuckDuckGo."""
+
+    title: str
+    url: str
+    snippet: str
+    position: int
+
+
+def _search_duckduckgo(query: str, max_results: int) -> list[SearchResult]:
+    """Perform a web search using ddgs library."""
+    from ddgs import DDGS  # type: ignore
+
+    results: list[SearchResult] = []
+
+    with DDGS() as ddgs:
+        for i, r in enumerate(ddgs.text(query, max_results=max_results)):
+            results.append(
+                SearchResult(
+                    title=r.get("title", ""),
+                    url=r.get("href", ""),
+                    snippet=r.get("body", ""),
+                    position=i + 1,
+                )
+            )
+
+    return results
+
+
+def _format_results(results: list[SearchResult]) -> str:
+    """Format search results for LLM consumption."""
+    if not results:
+        return (
+            "No results were found for your search query. "
+            "Please try rephrasing your search or using different keywords."
+        )
+
+    lines = [f"Found {len(results)} search results:\n"]
+
+    for result in results:
+        lines.append(f"{result.position}. {result.title}")
+        lines.append(f"   URL: {result.url}")
+        lines.append(f"   Summary: {result.snippet}\n")
+
+    return "\n".join(lines)
+
+
+@register(tools.WEB_SEARCH)
+class WebSearchTool(ToolABC):
+    @classmethod
+    def schema(cls) -> llm_param.ToolSchema:
+        return llm_param.ToolSchema(
+            name=tools.WEB_SEARCH,
+            type="function",
+            description=load_desc(Path(__file__).parent / "web_search_tool.md"),
+            parameters={
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "The search query to use",
+                    },
+                    "max_results": {
+                        "type": "integer",
+                        "description": f"Maximum number of results to return (default: {DEFAULT_MAX_RESULTS}, max: {MAX_RESULTS_LIMIT})",
+                    },
+                },
+                "required": ["query"],
+            },
+        )
+
+    class WebSearchArguments(BaseModel):
+        query: str
+        max_results: int = DEFAULT_MAX_RESULTS
+
+    @classmethod
+    async def call(cls, arguments: str) -> model.ToolResultItem:
+        try:
+            args = WebSearchTool.WebSearchArguments.model_validate_json(arguments)
+        except ValueError as e:
+            return model.ToolResultItem(
+                status="error",
+                output=f"Invalid arguments: {e}",
+            )
+        return await cls.call_with_args(args)
+
+    @classmethod
+    async def call_with_args(cls, args: WebSearchArguments) -> model.ToolResultItem:
+        query = args.query.strip()
+        if not query:
+            return model.ToolResultItem(
+                status="error",
+                output="Query cannot be empty",
+            )
+
+        max_results = min(max(args.max_results, 1), MAX_RESULTS_LIMIT)
+
+        try:
+            results = await asyncio.to_thread(_search_duckduckgo, query, max_results)
+            formatted = _format_results(results)
+
+            return model.ToolResultItem(
+                status="success",
+                output=formatted,
+            )
+
+        except Exception as e:
+            return model.ToolResultItem(
+                status="error",
+                output=f"Search failed: {e}",
+            )

klaude_code/protocol/commands.py

@@ -11,6 +11,7 @@ class CommandName(str, Enum):
     CLEAR = "clear"
     TERMINAL_SETUP = "terminal-setup"
     EXPORT = "export"
+    EXPORT_ONLINE = "export-online"
     STATUS = "status"
     RELEASE_NOTES = "release-notes"
     THINKING = "thinking"

klaude_code/protocol/events.py

@@ -133,6 +133,13 @@ class TodoChangeEvent(BaseModel):
     todos: list[model.TodoItem]
 
 
+class ContextUsageEvent(BaseModel):
+    """Real-time context usage update during task execution."""
+
+    session_id: str
+    context_percent: float  # Context usage percentage (0-100)
+
+
 HistoryItemEvent = (
     ThinkingEvent
     | TaskStartEvent
@@ -178,4 +185,5 @@ Event = (
     | TurnStartEvent
     | TurnEndEvent
     | TurnToolCallStartEvent
+    | ContextUsageEvent
 )

klaude_code/protocol/sub_agent/__init__.py

@@ -114,4 +114,4 @@ def sub_agent_tool_names(enabled_only: bool = False, model_name: str | None = No
 from klaude_code.protocol.sub_agent import explore as explore  # noqa: E402
 from klaude_code.protocol.sub_agent import oracle as oracle  # noqa: E402
 from klaude_code.protocol.sub_agent import task as task  # noqa: E402
-from klaude_code.protocol.sub_agent import web_fetch as web_fetch  # noqa: E402
+from klaude_code.protocol.sub_agent import web as web  # noqa: E402

klaude_code/protocol/sub_agent/explore.py

@@ -37,7 +37,7 @@ EXPLORE_PARAMETERS = {
             "description": "Optional JSON Schema for sub-agent structured output",
         },
     },
-    "required": ["description", "prompt", "output_format"],
+    "required": ["description", "prompt"],
     "additionalProperties": False,
 }