klaude-code 1.2.16__tar.gz → 1.2.17__tar.gz

{klaude_code-1.2.16 → klaude_code-1.2.17}/PKG-INFO

@@ -1,8 +1,9 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 1.2.16
+Version: 1.2.17
 Summary: Add your description here
 Requires-Dist: anthropic>=0.66.0
+Requires-Dist: ddgs>=9.9.3
 Requires-Dist: openai>=1.102.0
 Requires-Dist: pillow>=12.0.0
 Requires-Dist: prompt-toolkit>=3.0.52
@@ -71,47 +72,137 @@ Open the configuration file in editor:
 klaude config
 ```
 
-An minimal example config yaml using OpenRouter's API Key:
+An example config yaml:
 
 ```yaml
 provider_list:
-- provider_name: openrouter-work
+- provider_name: openrouter
   protocol: openrouter # support <responses|openrouter|anthropic|openai>
   api_key: <your-openrouter-api-key>
+
+- provider_name: openai-responses
+  protocol: responses
+  api_key: <your-openai-api-key>
+
+- provider_name: anthropic
+  protocol: anthropic
+  api_key: <your-anthropic-api-key>
+
+- provider_name: moonshot
+  protocol: anthropic
+  base_url: https://api.moonshot.cn/anthropic
+  api_key: <your-api-key>
+
+- provider_name: deepseek
+  protocol: anthropic
+  base_url: https://api.deepseek.com/anthropic
+  api_key: <your-api-key>
+
 model_list:
-- model_name: gpt-5.1-codex
-  provider: openrouter
+
+- model_name: deepseek
+  provider: deepseek
+  model_params:
+    model: deepseek-reasoner
+    context_limit: 128000
+    thinking:
+      type: enabled
+      budget_tokens: 8192
+    cost:
+      currency: CNY
+      input: 2
+      output: 3
+      cache_read: 0.2
+
+- model_name: codex-max
+  provider: openai-responses
   model_params:
-    model: openai/gpt-5.1-codex
-    context_limit: 368000
+    model: gpt-5.1-codex-max
     thinking:
       reasoning_effort: medium
-- model_name: gpt-5.1-high
+    context_limit: 400000
+    max_tokens: 128000
+    cost:
+      input: 1.25
+      output: 10
+      cache_read: 0.13
+
+- model_name: gpt-5.1
   provider: openrouter
   model_params:
     model: openai/gpt-5.1
-    context_limit: 368000
+    context_limit: 400000
+    max_tokens: 128000
+    verbosity: high
     thinking:
       reasoning_effort: high
-- model_name: sonnet
+    cost:
+      input: 1.25
+      output: 10
+      cache_read: 0.13
+
+- model_name: kimi@moonshot
+  provider: moonshot
+  model_params:
+    model: kimi-k2-thinking
+    context_limit: 262144
+    thinking:
+      type: enabled
+      budget_tokens: 8192
+    cost:
+      currency: CNY
+      input: 4
+      output: 16
+      cache_read: 1
+
+- model_name: opus
   provider: openrouter
   model_params:
-    model: anthropic/claude-4.5-sonnet
-    context_limit: 168000
+    model: anthropic/claude-4.5-opus
+    context_limit: 200000
     provider_routing:
-      sort: throughput
-- model_name: haiku
+      only: [ google-vertex ]
+    verbosity: high
+    thinking:
+      type: enabled
+      budget_tokens: 31999
+    cost:
+      input: 5
+      output: 25
+      cache_read: 0.5
+      cache_write: 6.25
+
+- model_name: gemini
   provider: openrouter
   model_params:
-    model: anthropic/claude-haiku-4.5
-    context_limit: 168000
-    provider_routing:
-      sort: throughput
-main_model: gpt-5.1-codex
+    model: google/gemini-3-pro-preview
+    context_limit: 1048576
+    thinking:
+      reasoning_effort: medium
+    cost:
+      input: 2
+      output: 12
+      cache_read: 0.2
+
+- model_name: haiku
+  provider: anthropic
+  model_params:
+    model: claude-haiku-4-5-20251001
+    context_limit: 200000
+    cost:
+      input: 1
+      output: 5
+      cache_read: 0.1
+      cache_write: 1.25
+
+main_model: opus
+
 sub_agent_models:
-  oracle: gpt-5.1-high
+  oracle: gpt-5.1
   explore: haiku
-  task: sonnet
+  task: opus
+  webfetchagent: haiku
+
 ```
 
 List configured providers and models:

{klaude_code-1.2.16 → klaude_code-1.2.17}/README.md

@@ -54,47 +54,137 @@ Open the configuration file in editor:
 klaude config
 ```
 
-An minimal example config yaml using OpenRouter's API Key:
+An example config yaml:
 
 ```yaml
 provider_list:
-- provider_name: openrouter-work
+- provider_name: openrouter
   protocol: openrouter # support <responses|openrouter|anthropic|openai>
   api_key: <your-openrouter-api-key>
+
+- provider_name: openai-responses
+  protocol: responses
+  api_key: <your-openai-api-key>
+
+- provider_name: anthropic
+  protocol: anthropic
+  api_key: <your-anthropic-api-key>
+
+- provider_name: moonshot
+  protocol: anthropic
+  base_url: https://api.moonshot.cn/anthropic
+  api_key: <your-api-key>
+
+- provider_name: deepseek
+  protocol: anthropic
+  base_url: https://api.deepseek.com/anthropic
+  api_key: <your-api-key>
+
 model_list:
-- model_name: gpt-5.1-codex
-  provider: openrouter
+
+- model_name: deepseek
+  provider: deepseek
+  model_params:
+    model: deepseek-reasoner
+    context_limit: 128000
+    thinking:
+      type: enabled
+      budget_tokens: 8192
+    cost:
+      currency: CNY
+      input: 2
+      output: 3
+      cache_read: 0.2
+
+- model_name: codex-max
+  provider: openai-responses
   model_params:
-    model: openai/gpt-5.1-codex
-    context_limit: 368000
+    model: gpt-5.1-codex-max
     thinking:
       reasoning_effort: medium
-- model_name: gpt-5.1-high
+    context_limit: 400000
+    max_tokens: 128000
+    cost:
+      input: 1.25
+      output: 10
+      cache_read: 0.13
+
+- model_name: gpt-5.1
   provider: openrouter
   model_params:
     model: openai/gpt-5.1
-    context_limit: 368000
+    context_limit: 400000
+    max_tokens: 128000
+    verbosity: high
     thinking:
       reasoning_effort: high
-- model_name: sonnet
+    cost:
+      input: 1.25
+      output: 10
+      cache_read: 0.13
+
+- model_name: kimi@moonshot
+  provider: moonshot
+  model_params:
+    model: kimi-k2-thinking
+    context_limit: 262144
+    thinking:
+      type: enabled
+      budget_tokens: 8192
+    cost:
+      currency: CNY
+      input: 4
+      output: 16
+      cache_read: 1
+
+- model_name: opus
   provider: openrouter
   model_params:
-    model: anthropic/claude-4.5-sonnet
-    context_limit: 168000
+    model: anthropic/claude-4.5-opus
+    context_limit: 200000
     provider_routing:
-      sort: throughput
-- model_name: haiku
+      only: [ google-vertex ]
+    verbosity: high
+    thinking:
+      type: enabled
+      budget_tokens: 31999
+    cost:
+      input: 5
+      output: 25
+      cache_read: 0.5
+      cache_write: 6.25
+
+- model_name: gemini
   provider: openrouter
   model_params:
-    model: anthropic/claude-haiku-4.5
-    context_limit: 168000
-    provider_routing:
-      sort: throughput
-main_model: gpt-5.1-codex
+    model: google/gemini-3-pro-preview
+    context_limit: 1048576
+    thinking:
+      reasoning_effort: medium
+    cost:
+      input: 2
+      output: 12
+      cache_read: 0.2
+
+- model_name: haiku
+  provider: anthropic
+  model_params:
+    model: claude-haiku-4-5-20251001
+    context_limit: 200000
+    cost:
+      input: 1
+      output: 5
+      cache_read: 0.1
+      cache_write: 1.25
+
+main_model: opus
+
 sub_agent_models:
-  oracle: gpt-5.1-high
+  oracle: gpt-5.1
   explore: haiku
-  task: sonnet
+  task: opus
+  webfetchagent: haiku
+
 ```
 
 List configured providers and models:

{klaude_code-1.2.16 → klaude_code-1.2.17}/pyproject.toml

@@ -4,12 +4,13 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "1.2.16"
+version = "1.2.17"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.13"
 dependencies = [
     "anthropic>=0.66.0",
+    "ddgs>=9.9.3",
     "openai>=1.102.0",
     "pillow>=12.0.0",
     "prompt-toolkit>=3.0.52",

{klaude_code-1.2.16 → klaude_code-1.2.17}/src/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-1.2.16 → klaude_code-1.2.17}/src/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-1.2.17/src/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-1.2.16 → klaude_code-1.2.17}/src/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-1.2.16 → klaude_code-1.2.17}/src/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-1.2.16 → klaude_code-1.2.17}/src/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-1.2.17/src/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)