klaude-code 1.2.9__py3-none-any.whl → 1.2.10__py3-none-any.whl

klaude_code/core/tool/memory/skill_loader.py

@@ -115,7 +115,8 @@ class SkillLoader:
 
             return skill
 
-        except Exception:
+        except (OSError, yaml.YAMLError) as e:
+            log_debug(f"Failed to load skill from {skill_path}: {e}")
             return None
 
     def discover_skills(self) -> list[Skill]:

klaude_code/core/tool/memory/skill_tool.py

@@ -13,15 +13,26 @@ class SkillTool(ToolABC):
     """Tool to execute/load a skill within the main conversation"""
 
     _skill_loader: SkillLoader | None = None
+    _discovery_done: bool = False
 
     @classmethod
     def set_skill_loader(cls, loader: SkillLoader) -> None:
         """Set the skill loader instance"""
         cls._skill_loader = loader
+        cls._discovery_done = False
+
+    @classmethod
+    def _ensure_skills_discovered(cls) -> None:
+        if cls._discovery_done:
+            return
+        if cls._skill_loader is not None:
+            cls._skill_loader.discover_skills()
+        cls._discovery_done = True
 
     @classmethod
     def schema(cls) -> llm_param.ToolSchema:
         """Generate schema with embedded available skills metadata"""
+        cls._ensure_skills_discovered()
         skills_xml = cls._generate_skills_xml()
 
         return llm_param.ToolSchema(
@@ -69,6 +80,8 @@ class SkillTool(ToolABC):
                 output=f"Invalid arguments: {e}",
             )
 
+        cls._ensure_skills_discovered()
+
         if not cls._skill_loader:
             return model.ToolResultItem(
                 status="error",

klaude_code/llm/__init__.py

@@ -1,23 +1,13 @@
 """LLM package init.
 
-Imports built-in LLM clients so their ``@register`` decorators run and they
-become available via the registry.
+LLM clients are lazily loaded to avoid heavy imports at module load time.
+Only LLMClientABC and create_llm_client are exposed.
 """
 
-from .anthropic import AnthropicClient
 from .client import LLMClientABC
-from .codex import CodexClient
-from .openai_compatible import OpenAICompatibleClient
-from .openrouter import OpenRouterClient
 from .registry import create_llm_client
-from .responses import ResponsesClient
 
 __all__ = [
     "LLMClientABC",
-    "ResponsesClient",
-    "OpenAICompatibleClient",
-    "OpenRouterClient",
-    "AnthropicClient",
-    "CodexClient",
     "create_llm_client",
 ]

klaude_code/llm/anthropic/client.py

@@ -46,7 +46,7 @@ class AnthropicClient(LLMClientABC):
     async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem, None]:
         param = apply_config_defaults(param, self.get_llm_config())
 
-        metadata_tracker = MetadataTracker(cost_config=self._config.cost)
+        metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
 
         messages = convert_history_to_input(param.input, param.model)
         tools = convert_tool_schema(param.tools)
@@ -179,6 +179,7 @@ class AnthropicClient(LLMClientABC):
                             output_tokens=output_tokens,
                             cached_tokens=cached_tokens,
                             context_limit=param.context_limit,
+                            max_tokens=param.max_tokens,
                         )
                         metadata_tracker.set_usage(usage)
                         metadata_tracker.set_model_name(str(param.model))

klaude_code/llm/client.py

@@ -19,7 +19,7 @@ class LLMClientABC(ABC):
     @abstractmethod
     async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem, None]:
         raise NotImplementedError
-        yield cast(model.ConversationItem, None)  # pyright: ignore[reportUnreachable]
+        yield cast(model.ConversationItem, None)
 
     def get_llm_config(self) -> llm_param.LLMConfigParameter:
         return self._config

klaude_code/llm/codex/client.py

@@ -84,7 +84,7 @@ class CodexClient(LLMClientABC):
         # Codex API requires store=False
         param.store = False
 
-        metadata_tracker = MetadataTracker(cost_config=self._config.cost)
+        metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
 
         inputs = convert_history_to_input(param.input, param.model)
         tools = convert_tool_schema(param.tools)

klaude_code/llm/openai_compatible/client.py

@@ -47,7 +47,7 @@ class OpenAICompatibleClient(LLMClientABC):
         messages = convert_history_to_input(param.input, param.system, param.model)
         tools = convert_tool_schema(param.tools)
 
-        metadata_tracker = MetadataTracker(cost_config=self._config.cost)
+        metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
 
         extra_body = {}
         extra_headers = {"extra": json.dumps({"session_id": param.session_id}, sort_keys=True)}
@@ -88,7 +88,7 @@ class OpenAICompatibleClient(LLMClientABC):
                 if (
                     event.usage is not None and event.usage.completion_tokens is not None  # pyright: ignore[reportUnnecessaryComparison] gcp gemini will return None usage field
                 ):
-                    metadata_tracker.set_usage(convert_usage(event.usage, param.context_limit))
+                    metadata_tracker.set_usage(convert_usage(event.usage, param.context_limit, param.max_tokens))
                 if event.model:
                     metadata_tracker.set_model_name(event.model)
                 if provider := getattr(event, "provider", None):
@@ -104,6 +104,7 @@ class OpenAICompatibleClient(LLMClientABC):
                         convert_usage(
                             openai.types.CompletionUsage.model_validate(getattr(event.choices[0], "usage")),
                             param.context_limit,
+                            param.max_tokens,
                         )
                     )
 

klaude_code/llm/openrouter/client.py

@@ -38,7 +38,7 @@ class OpenRouterClient(LLMClientABC):
         messages = convert_history_to_input(param.input, param.system, param.model)
         tools = convert_tool_schema(param.tools)
 
-        metadata_tracker = MetadataTracker(cost_config=self._config.cost)
+        metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
 
         extra_body: dict[str, object] = {
             "usage": {"include": True}  # To get the cache tokens at the end of the response
@@ -73,7 +73,7 @@ class OpenRouterClient(LLMClientABC):
             max_tokens=param.max_tokens,
             tools=tools,
             verbosity=param.verbosity,
-            extra_body=extra_body,  # pyright: ignore[reportUnknownArgumentType]
+            extra_body=extra_body,
             extra_headers=extra_headers,  # pyright: ignore[reportUnknownArgumentType]
         )
 
@@ -100,7 +100,7 @@ class OpenRouterClient(LLMClientABC):
                 if (
                     event.usage is not None and event.usage.completion_tokens is not None  # pyright: ignore[reportUnnecessaryComparison]
                 ):  # gcp gemini will return None usage field
-                    metadata_tracker.set_usage(convert_usage(event.usage, param.context_limit))
+                    metadata_tracker.set_usage(convert_usage(event.usage, param.context_limit, param.max_tokens))
                 if event.model:
                     metadata_tracker.set_model_name(event.model)
                 if provider := getattr(event, "provider", None):

klaude_code/llm/registry.py

@@ -1,22 +1,48 @@
-from typing import Callable, TypeVar
+from typing import TYPE_CHECKING, Callable, TypeVar
 
-from klaude_code.llm.client import LLMClientABC
 from klaude_code.protocol import llm_param
 
-_REGISTRY: dict[llm_param.LLMClientProtocol, type[LLMClientABC]] = {}
+if TYPE_CHECKING:
+    from klaude_code.llm.client import LLMClientABC
 
-T = TypeVar("T", bound=LLMClientABC)
+_T = TypeVar("_T", bound=type["LLMClientABC"])
 
+# Track which protocols have been loaded
+_loaded_protocols: set[llm_param.LLMClientProtocol] = set()
+_REGISTRY: dict[llm_param.LLMClientProtocol, type["LLMClientABC"]] = {}
 
-def register(name: llm_param.LLMClientProtocol) -> Callable[[type[T]], type[T]]:
-    def _decorator(cls: type[T]) -> type[T]:
+
+def _load_protocol(protocol: llm_param.LLMClientProtocol) -> None:
+    """Load the module for a specific protocol on demand."""
+    if protocol in _loaded_protocols:
+        return
+    _loaded_protocols.add(protocol)
+
+    # Import only the needed module to trigger @register decorator
+    if protocol == llm_param.LLMClientProtocol.ANTHROPIC:
+        from . import anthropic as _  # noqa: F401
+    elif protocol == llm_param.LLMClientProtocol.CODEX:
+        from . import codex as _  # noqa: F401
+    elif protocol == llm_param.LLMClientProtocol.OPENAI:
+        from . import openai_compatible as _  # noqa: F401
+    elif protocol == llm_param.LLMClientProtocol.OPENROUTER:
+        from . import openrouter as _  # noqa: F401
+    elif protocol == llm_param.LLMClientProtocol.RESPONSES:
+        from . import responses as _  # noqa: F401
+
+
+def register(name: llm_param.LLMClientProtocol) -> Callable[[_T], _T]:
+    """Decorator to register an LLM client class for a protocol."""
+
+    def _decorator(cls: _T) -> _T:
         _REGISTRY[name] = cls
         return cls
 
     return _decorator
 
 
-def create_llm_client(config: llm_param.LLMConfigParameter) -> LLMClientABC:
+def create_llm_client(config: llm_param.LLMConfigParameter) -> "LLMClientABC":
+    _load_protocol(config.protocol)
     if config.protocol not in _REGISTRY:
         raise ValueError(f"Unknown LLMClient protocol: {config.protocol}")
     return _REGISTRY[config.protocol].create(config)

klaude_code/llm/responses/client.py

@@ -102,6 +102,7 @@ async def parse_responses_stream(
                             reasoning_tokens=event.response.usage.output_tokens_details.reasoning_tokens,
                             total_tokens=event.response.usage.total_tokens,
                             context_limit=param.context_limit,
+                            max_tokens=param.max_tokens,
                         )
                         metadata_tracker.set_usage(usage)
                     metadata_tracker.set_model_name(str(param.model))
@@ -159,7 +160,7 @@ class ResponsesClient(LLMClientABC):
     async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem, None]:
         param = apply_config_defaults(param, self.get_llm_config())
 
-        metadata_tracker = MetadataTracker(cost_config=self._config.cost)
+        metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
 
         inputs = convert_history_to_input(param.input, param.model)
         tools = convert_tool_schema(param.tools)

klaude_code/llm/responses/input.py

@@ -34,7 +34,7 @@ def _build_tool_result_item(tool: model.ToolResultItem) -> responses.ResponseInp
         "call_id": tool.call_id,
         "output": content_parts,
     }
-    return item  # type: ignore[return-value]
+    return item
 
 
 def convert_history_to_input(

klaude_code/llm/usage.py

@@ -92,10 +92,14 @@ class MetadataTracker:
         return self._metadata_item
 
 
-def convert_usage(usage: openai.types.CompletionUsage, context_limit: int | None = None) -> model.Usage:
+def convert_usage(
+    usage: openai.types.CompletionUsage,
+    context_limit: int | None = None,
+    max_tokens: int | None = None,
+) -> model.Usage:
     """Convert OpenAI CompletionUsage to internal Usage model.
 
-    context_window_size is set to total_tokens from the API response,
+    context_token is set to total_tokens from the API response,
     representing the actual context window usage for this turn.
     """
     return model.Usage(
@@ -104,8 +108,9 @@ def convert_usage(usage: openai.types.CompletionUsage, context_limit: int | None
         reasoning_tokens=(usage.completion_tokens_details.reasoning_tokens if usage.completion_tokens_details else 0)
         or 0,
         output_tokens=usage.completion_tokens,
-        context_window_size=usage.total_tokens,
+        context_token=usage.total_tokens,
         context_limit=context_limit,
+        max_tokens=max_tokens,
     )
 
 
@@ -114,19 +119,21 @@ def convert_anthropic_usage(
     output_tokens: int,
     cached_tokens: int,
     context_limit: int | None = None,
+    max_tokens: int | None = None,
 ) -> model.Usage:
     """Convert Anthropic usage data to internal Usage model.
 
-    context_window_size is computed from input + cached + output tokens,
+    context_token is computed from input + cached + output tokens,
     representing the actual context window usage for this turn.
     """
-    context_window_size = input_tokens + cached_tokens + output_tokens
+    context_token = input_tokens + cached_tokens + output_tokens
     return model.Usage(
         input_tokens=input_tokens,
         output_tokens=output_tokens,
         cached_tokens=cached_tokens,
-        context_window_size=context_window_size,
+        context_token=context_token,
         context_limit=context_limit,
+        max_tokens=max_tokens,
     )
 
 
@@ -137,10 +144,11 @@ def convert_responses_usage(
     reasoning_tokens: int,
     total_tokens: int,
     context_limit: int | None = None,
+    max_tokens: int | None = None,
 ) -> model.Usage:
     """Convert OpenAI Responses API usage data to internal Usage model.
 
-    context_window_size is set to total_tokens from the API response,
+    context_token is set to total_tokens from the API response,
     representing the actual context window usage for this turn.
     """
     return model.Usage(
@@ -148,6 +156,7 @@ def convert_responses_usage(
         output_tokens=output_tokens,
         cached_tokens=cached_tokens,
         reasoning_tokens=reasoning_tokens,
-        context_window_size=total_tokens,
+        context_token=total_tokens,
         context_limit=context_limit,
+        max_tokens=max_tokens,
     )

klaude_code/protocol/model.py

@@ -4,6 +4,7 @@ from typing import Annotated, Literal
 
 from pydantic import BaseModel, ConfigDict, Field, computed_field
 
+from klaude_code import const
 from klaude_code.protocol.commands import CommandName
 from klaude_code.protocol.tools import SubAgentType
 
@@ -19,8 +20,9 @@ class Usage(BaseModel):
     output_tokens: int = 0
 
     # Context window tracking
-    context_window_size: int | None = None  # Peak total_tokens seen (for context usage display)
+    context_token: int | None = None  # Peak total_tokens seen (for context usage display)
     context_limit: int | None = None  # Model's context limit
+    max_tokens: int | None = None  # Max output tokens for this request
 
     throughput_tps: float | None = None
     first_token_latency_ms: float | None = None
@@ -31,13 +33,13 @@ class Usage(BaseModel):
     cache_read_cost: float | None = None  # Cost for cached tokens
     currency: str = "USD"  # Currency for cost display (USD or CNY)
 
-    @computed_field  # type: ignore[prop-decorator]
+    @computed_field
     @property
     def total_tokens(self) -> int:
         """Total tokens computed from input + output tokens."""
         return self.input_tokens + self.output_tokens
 
-    @computed_field  # type: ignore[prop-decorator]
+    @computed_field
     @property
     def total_cost(self) -> float | None:
         """Total cost computed from input + output + cache_read costs."""
@@ -45,15 +47,18 @@ class Usage(BaseModel):
         non_none = [c for c in costs if c is not None]
         return sum(non_none) if non_none else None
 
-    @computed_field  # type: ignore[prop-decorator]
+    @computed_field
     @property
     def context_usage_percent(self) -> float | None:
-        """Context usage percentage computed from context_window_size / context_limit."""
+        """Context usage percentage computed from context_token / (context_limit - max_tokens)."""
         if self.context_limit is None or self.context_limit <= 0:
             return None
-        if self.context_window_size is None:
+        if self.context_token is None:
             return None
-        return (self.context_window_size / self.context_limit) * 100
+        effective_limit = self.context_limit - (self.max_tokens or const.DEFAULT_MAX_TOKENS)
+        if effective_limit <= 0:
+            return None
+        return (self.context_token / effective_limit) * 100
 
 
 class TodoItem(BaseModel):

klaude_code/protocol/op.py

@@ -67,6 +67,7 @@ class InitAgentOperation(Operation):
 
     type: OperationType = OperationType.INIT_AGENT
     session_id: str | None = None
+    is_new_session: bool = False
 
     async def execute(self, handler: OperationHandler) -> None:
         await handler.handle_init_agent(self)

klaude_code/session/export.py

@@ -294,7 +294,7 @@ def _try_render_todo_args(arguments: str) -> str | None:
             return None
 
         return f'<div class="todo-list">{"".join(items_html)}</div>'
-    except Exception:
+    except (json.JSONDecodeError, KeyError, TypeError):
         return None
 
 
@@ -380,7 +380,7 @@ def _get_mermaid_link_html(
         try:
             args = json.loads(tool_call.arguments)
             code = args.get("code", "")
-        except Exception:
+        except (json.JSONDecodeError, TypeError):
             code = ""
     else:
         code = ""
@@ -447,7 +447,7 @@ def _format_tool_call(tool_call: model.ToolCallItem, result: model.ToolResultIte
         try:
             parsed = json.loads(tool_call.arguments)
             args_text = json.dumps(parsed, ensure_ascii=False, indent=2)
-        except Exception:
+        except (json.JSONDecodeError, TypeError):
             args_text = tool_call.arguments
 
         args_html = _escape_html(args_text or "")
@@ -469,7 +469,7 @@ def _format_tool_call(tool_call: model.ToolCallItem, result: model.ToolResultIte
                 parsed_args = json.loads(tool_call.arguments)
                 if parsed_args.get("command") in {"create", "str_replace", "insert"}:
                     force_collapse = True
-            except Exception:
+            except (json.JSONDecodeError, TypeError):
                 pass
 
         should_collapse = force_collapse or _should_collapse(args_html)
@@ -506,7 +506,7 @@ def _format_tool_call(tool_call: model.ToolCallItem, result: model.ToolResultIte
                 new_string = args_data.get("new_string", "")
                 if old_string == "" and new_string:
                     diff_text = "\n".join(f"+{line}" for line in new_string.splitlines())
-            except Exception:
+            except (json.JSONDecodeError, TypeError):
                 pass
 
         items_to_render: list[str] = []

klaude_code/session/session.py

@@ -103,7 +103,17 @@ class Session(BaseModel):
         return self._messages_dir() / f"{prefix}-{self.id}.jsonl"
 
     @classmethod
-    def load(cls, id: str) -> "Session":
+    def create(cls, id: str | None = None) -> "Session":
+        """Create a new session without checking for existing files."""
+        return Session(id=id or uuid.uuid4().hex, work_dir=Path.cwd())
+
+    @classmethod
+    def load(cls, id: str, *, skip_if_missing: bool = False) -> "Session":
+        """Load an existing session or create a new one if not found."""
+
+        if skip_if_missing:
+            return Session(id=id, work_dir=Path.cwd())
+
         # Load session metadata
         sessions_dir = cls._sessions_dir()
         session_candidates = sorted(
@@ -167,7 +177,7 @@ class Session(BaseModel):
                     item = cls_type(**data)
                     # pyright: ignore[reportAssignmentType]
                     history.append(item)  # type: ignore[arg-type]
-                except Exception:
+                except (json.JSONDecodeError, KeyError, TypeError):
                     # Best-effort load; skip malformed lines
                     continue
             sess.conversation_history = history
@@ -242,7 +252,7 @@ class Session(BaseModel):
                 if ts > latest_ts:
                     latest_ts = ts
                     latest_id = sid
-            except Exception:
+            except (json.JSONDecodeError, KeyError, TypeError, OSError):
                 continue
         return latest_id
 
@@ -395,7 +405,7 @@ class Session(BaseModel):
                                         text_parts.append(text)
                             return " ".join(text_parts) if text_parts else None
                         return None
-            except Exception:
+            except (json.JSONDecodeError, KeyError, TypeError, OSError):
                 return None
             return None
 
@@ -403,7 +413,7 @@ class Session(BaseModel):
         for p in sessions_dir.glob("*.json"):
             try:
                 data = json.loads(p.read_text())
-            except Exception:
+            except (json.JSONDecodeError, OSError):
                 # Skip unreadable files
                 continue
             # Filter out sub-agent sessions

klaude_code/ui/core/input.py

@@ -68,4 +68,4 @@ class InputProviderABC(ABC):
             UserInputPayload with text and optional images.
         """
         raise NotImplementedError
-        yield UserInputPayload(text="")  # pyright: ignore[reportUnreachable]
+        yield UserInputPayload(text="")

klaude_code/ui/modes/repl/clipboard.py

@@ -40,19 +40,19 @@ class ClipboardCaptureState:
         """Capture image from clipboard, save to disk, and return a tag like [Image #N]."""
         try:
             clipboard_data = ImageGrab.grabclipboard()
-        except Exception:
+        except OSError:
             return None
         if not isinstance(clipboard_data, Image.Image):
             return None
         try:
             self._images_dir.mkdir(parents=True, exist_ok=True)
-        except Exception:
+        except OSError:
             return None
         filename = f"clipboard_{uuid.uuid4().hex[:8]}.png"
         path = self._images_dir / filename
         try:
             clipboard_data.save(path, "PNG")
-        except Exception:
+        except OSError:
             return None
         tag = f"[Image #{self._counter}]"
         self._counter += 1
@@ -123,7 +123,7 @@ def _encode_image_file(file_path: str) -> ImageURLPart | None:
         # Clipboard images are always saved as PNG
         data_url = f"data:image/png;base64,{encoded}"
         return ImageURLPart(image_url=ImageURLPart.ImageURL(url=data_url, id=None))
-    except Exception:
+    except OSError:
         return None
 
 
@@ -148,5 +148,5 @@ def copy_to_clipboard(text: str) -> None:
                     input=text.encode("utf-8"),
                     check=True,
                 )
-    except Exception:
+    except (OSError, subprocess.SubprocessError):
         pass

klaude_code/ui/renderers/metadata.py

@@ -118,7 +118,7 @@ def _render_task_metadata_block(
     if metadata.usage is not None:
         # Context (only for main agent)
         if show_context_and_time and metadata.usage.context_usage_percent is not None:
-            context_size = format_number(metadata.usage.context_window_size or 0)
+            context_size = format_number(metadata.usage.context_token or 0)
             parts3.append(
                 Text.assemble(
                     ("context", ThemeKey.METADATA_DIM),

klaude_code/ui/terminal/control.py

@@ -38,7 +38,7 @@ def start_esc_interrupt_monitor(
     # Fallback for non-interactive or non-POSIX environments.
     if not sys.stdin.isatty() or os.name != "posix":
 
-        async def _noop() -> None:  # type: ignore[return-type]
+        async def _noop() -> None:
             return None
 
         return stop_event, asyncio.create_task(_noop())
@@ -85,7 +85,7 @@ def start_esc_interrupt_monitor(
             log((f"esc monitor error: {exc}", "r red"))
         finally:
             try:
-                termios.tcsetattr(fd, termios.TCSADRAIN, old)  # type: ignore[name-defined]
+                termios.tcsetattr(fd, termios.TCSADRAIN, old)
             except Exception:
                 pass
 

klaude_code/version.py

@@ -57,7 +57,7 @@ def _get_installed_version() -> str | None:
                         ver = ver[1:]
                     return ver
         return None
-    except Exception:
+    except (OSError, subprocess.SubprocessError):
         return None
 
 
@@ -67,7 +67,7 @@ def _get_latest_version() -> str | None:
         with urllib.request.urlopen(PYPI_URL, timeout=5) as response:
             data = json.loads(response.read().decode())
             return data.get("info", {}).get("version")
-    except Exception:
+    except (OSError, json.JSONDecodeError, ValueError):
         return None
 
 
@@ -93,7 +93,7 @@ def _compare_versions(installed: str, latest: str) -> bool:
         installed_tuple = _parse_version(installed)
         latest_tuple = _parse_version(latest)
         return latest_tuple > installed_tuple
-    except Exception:
+    except ValueError:
         return False
 
 

{klaude_code-1.2.9.dist-info → klaude_code-1.2.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 1.2.9
+Version: 1.2.10
 Summary: Add your description here
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: openai>=1.102.0