kimi-cli 0.44__py3-none-any.whl → 0.78__py3-none-any.whl

kimi_cli/llm.py

@@ -1,27 +1,45 @@
+from __future__ import annotations
+
 import os
-from typing import NamedTuple
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Literal, cast, get_args
 
-from kosong.base.chat_provider import ChatProvider
+from kosong.chat_provider import ChatProvider
 from pydantic import SecretStr
 
-from kimi_cli.config import LLMModel, LLMModelCapability, LLMProvider
 from kimi_cli.constant import USER_AGENT
 
+if TYPE_CHECKING:
+    from kimi_cli.config import LLMModel, LLMProvider
+
+type ProviderType = Literal[
+    "kimi",
+    "openai_legacy",
+    "openai_responses",
+    "anthropic",
+    "google_genai",  # for backward-compatibility, equals to `gemini`
+    "gemini",
+    "vertexai",
+    "_echo",
+    "_chaos",
+]
+
+type ModelCapability = Literal["image_in", "video_in", "thinking", "always_thinking"]
+ALL_MODEL_CAPABILITIES: set[ModelCapability] = set(get_args(ModelCapability.__value__))
 
-class LLM(NamedTuple):
+
+@dataclass(slots=True)
+class LLM:
     chat_provider: ChatProvider
     max_context_size: int
-    capabilities: set[LLMModelCapability]
-    # TODO: these additional fields should be moved to ChatProvider
+    capabilities: set[ModelCapability]
+    model_config: LLMModel | None = None
+    provider_config: LLMProvider | None = None
 
     @property
     def model_name(self) -> str:
         return self.chat_provider.model_name
 
-    @property
-    def supports_image_in(self) -> bool:
-        return "image_in" in self.capabilities
-
 
 def augment_provider_with_env_vars(provider: LLMProvider, model: LLMModel) -> dict[str, str]:
     """Override provider/model settings from environment variables.
@@ -41,11 +59,19 @@ def augment_provider_with_env_vars(provider: LLMProvider, model: LLMModel) -> di
                 applied["KIMI_API_KEY"] = "******"
             if model_name := os.getenv("KIMI_MODEL_NAME"):
                 model.model = model_name
-                applied["KIMI_MODEL_NAME"] = model.model
+                applied["KIMI_MODEL_NAME"] = model_name
             if max_context_size := os.getenv("KIMI_MODEL_MAX_CONTEXT_SIZE"):
                 model.max_context_size = int(max_context_size)
-                applied["KIMI_MODEL_MAX_CONTEXT_SIZE"] = str(model.max_context_size)
-        case "openai_legacy":
+                applied["KIMI_MODEL_MAX_CONTEXT_SIZE"] = max_context_size
+            if capabilities := os.getenv("KIMI_MODEL_CAPABILITIES"):
+                caps_lower = (cap.strip().lower() for cap in capabilities.split(",") if cap.strip())
+                model.capabilities = set(
+                    cast(ModelCapability, cap)
+                    for cap in caps_lower
+                    if cap in get_args(ModelCapability.__value__)
+                )
+                applied["KIMI_MODEL_CAPABILITIES"] = capabilities
+        case "openai_legacy" | "openai_responses":
             if base_url := os.getenv("OPENAI_BASE_URL"):
                 provider.base_url = base_url
             if api_key := os.getenv("OPENAI_API_KEY"):
@@ -60,9 +86,12 @@ def create_llm(
     provider: LLMProvider,
     model: LLMModel,
     *,
-    stream: bool = True,
+    thinking: bool | None = None,
     session_id: str | None = None,
-) -> LLM:
+) -> LLM | None:
+    if provider.type != "_echo" and (not provider.base_url or not model.model):
+        return None
+
     match provider.type:
         case "kimi":
             from kosong.chat_provider.kimi import Kimi
@@ -71,38 +100,115 @@ def create_llm(
                 model=model.model,
                 base_url=provider.base_url,
                 api_key=provider.api_key.get_secret_value(),
-                stream=stream,
                 default_headers={
                     "User-Agent": USER_AGENT,
                     **(provider.custom_headers or {}),
                 },
             )
+
+            gen_kwargs: Kimi.GenerationKwargs = {}
             if session_id:
-                chat_provider = chat_provider.with_generation_kwargs(prompt_cache_key=session_id)
+                gen_kwargs["prompt_cache_key"] = session_id
+            if temperature := os.getenv("KIMI_MODEL_TEMPERATURE"):
+                gen_kwargs["temperature"] = float(temperature)
+            if top_p := os.getenv("KIMI_MODEL_TOP_P"):
+                gen_kwargs["top_p"] = float(top_p)
+            if max_tokens := os.getenv("KIMI_MODEL_MAX_TOKENS"):
+                gen_kwargs["max_tokens"] = int(max_tokens)
+
+            if gen_kwargs:
+                chat_provider = chat_provider.with_generation_kwargs(**gen_kwargs)
         case "openai_legacy":
-            from kosong.chat_provider.openai_legacy import OpenAILegacy
+            from kosong.contrib.chat_provider.openai_legacy import OpenAILegacy
 
             chat_provider = OpenAILegacy(
                 model=model.model,
                 base_url=provider.base_url,
                 api_key=provider.api_key.get_secret_value(),
-                stream=stream,
             )
-        case "_chaos":
-            from kosong.chat_provider.chaos import ChaosChatProvider, ChaosConfig
+        case "openai_responses":
+            from kosong.contrib.chat_provider.openai_responses import OpenAIResponses
 
-            chat_provider = ChaosChatProvider(
+            chat_provider = OpenAIResponses(
+                model=model.model,
+                base_url=provider.base_url,
+                api_key=provider.api_key.get_secret_value(),
+            )
+        case "anthropic":
+            from kosong.contrib.chat_provider.anthropic import Anthropic
+
+            chat_provider = Anthropic(
                 model=model.model,
                 base_url=provider.base_url,
                 api_key=provider.api_key.get_secret_value(),
+                default_max_tokens=50000,
+            )
+        case "google_genai" | "gemini":
+            from kosong.contrib.chat_provider.google_genai import GoogleGenAI
+
+            chat_provider = GoogleGenAI(
+                model=model.model,
+                base_url=provider.base_url,
+                api_key=provider.api_key.get_secret_value(),
+            )
+        case "vertexai":
+            from kosong.contrib.chat_provider.google_genai import GoogleGenAI
+
+            os.environ.update(provider.env or {})
+            chat_provider = GoogleGenAI(
+                model=model.model,
+                base_url=provider.base_url,
+                api_key=provider.api_key.get_secret_value(),
+                vertexai=True,
+            )
+        case "_echo":
+            from kosong.chat_provider.echo import EchoChatProvider
+
+            chat_provider = EchoChatProvider()
+        case "_chaos":
+            from kosong.chat_provider.chaos import ChaosChatProvider, ChaosConfig
+            from kosong.chat_provider.kimi import Kimi
+
+            chat_provider = ChaosChatProvider(
+                provider=Kimi(
+                    model=model.model,
+                    base_url=provider.base_url,
+                    api_key=provider.api_key.get_secret_value(),
+                    default_headers={
+                        "User-Agent": USER_AGENT,
+                        **(provider.custom_headers or {}),
+                    },
+                ),
                 chaos_config=ChaosConfig(
                     error_probability=0.8,
                     error_types=[429, 500, 503],
                 ),
             )
 
+    capabilities = derive_model_capabilities(model)
+
+    # Apply thinking if specified or if model always requires thinking
+    if "always_thinking" in capabilities or (thinking is True and "thinking" in capabilities):
+        chat_provider = chat_provider.with_thinking("high")
+    elif thinking is False:
+        chat_provider = chat_provider.with_thinking("off")
+    # If thinking is None and model doesn't always think, leave as-is (default behavior)
+
     return LLM(
         chat_provider=chat_provider,
         max_context_size=model.max_context_size,
-        capabilities=model.capabilities or set(),
+        capabilities=capabilities,
+        model_config=model,
+        provider_config=provider,
     )
+
+
+def derive_model_capabilities(model: LLMModel) -> set[ModelCapability]:
+    capabilities = set(model.capabilities or ())
+    # Models with "thinking" in their name are always-thinking models
+    if "thinking" in model.model.lower() or "reason" in model.model.lower():
+        capabilities.update(("thinking", "always_thinking"))
+    # These models support thinking but can be toggled on/off
+    elif model.model in {"kimi-for-coding", "kimi-code"}:
+        capabilities.add("thinking")
+    return capabilities

kimi_cli/metadata.py

@@ -1,8 +1,13 @@
+from __future__ import annotations
+
 import json
 from hashlib import md5
 from pathlib import Path
 
-from pydantic import BaseModel, Field
+from kaos import get_current_kaos
+from kaos.local import local_kaos
+from kaos.path import KaosPath
+from pydantic import BaseModel, ConfigDict, Field
 
 from kimi_cli.share import get_share_dir
 from kimi_cli.utils.logging import logger
@@ -18,22 +23,42 @@ class WorkDirMeta(BaseModel):
     path: str
     """The full path of the work directory."""
 
+    kaos: str = local_kaos.name
+    """The name of the KAOS where the work directory is located."""
+
     last_session_id: str | None = None
     """Last session ID of this work directory."""
 
     @property
     def sessions_dir(self) -> Path:
-        path = get_share_dir() / "sessions" / md5(self.path.encode()).hexdigest()
-        path.mkdir(parents=True, exist_ok=True)
-        return path
+        """The directory to store sessions for this work directory."""
+        path_md5 = md5(self.path.encode(encoding="utf-8")).hexdigest()
+        dir_basename = path_md5 if self.kaos == local_kaos.name else f"{self.kaos}_{path_md5}"
+        session_dir = get_share_dir() / "sessions" / dir_basename
+        session_dir.mkdir(parents=True, exist_ok=True)
+        return session_dir
 
 
 class Metadata(BaseModel):
     """Kimi metadata structure."""
 
-    work_dirs: list[WorkDirMeta] = Field(
-        default_factory=list[WorkDirMeta], description="Work directory list"
-    )
+    model_config = ConfigDict(extra="ignore")
+
+    work_dirs: list[WorkDirMeta] = Field(default_factory=list[WorkDirMeta])
+    """Work directory list."""
+
+    def get_work_dir_meta(self, path: KaosPath) -> WorkDirMeta | None:
+        """Get the metadata for a work directory."""
+        for wd in self.work_dirs:
+            if wd.path == str(path) and wd.kaos == get_current_kaos().name:
+                return wd
+        return None
+
+    def new_work_dir_meta(self, path: KaosPath) -> WorkDirMeta:
+        """Create a new work directory metadata."""
+        wd_meta = WorkDirMeta(path=str(path), kaos=get_current_kaos().name)
+        self.work_dirs.append(wd_meta)
+        return wd_meta
 
 
 def load_metadata() -> Metadata:

kimi_cli/platforms.py

@@ -0,0 +1,262 @@
+from __future__ import annotations
+
+from typing import Any, NamedTuple, cast
+
+import aiohttp
+from pydantic import BaseModel
+
+from kimi_cli.config import Config, LLMModel, load_config, save_config
+from kimi_cli.llm import ModelCapability
+from kimi_cli.utils.aiohttp import new_client_session
+from kimi_cli.utils.logging import logger
+
+
+class ModelInfo(BaseModel):
+    """Model information returned from the API."""
+
+    id: str
+    context_length: int = 0
+    supports_reasoning: bool = False
+
+    @property
+    def capabilities(self) -> set[ModelCapability]:
+        """Derive capabilities from model info."""
+        caps: set[ModelCapability] = set()
+        if self.supports_reasoning:
+            caps.add("thinking")
+        # Models with "thinking" in name are always-thinking
+        if "thinking" in self.id.lower():
+            caps.update(("thinking", "always_thinking"))
+        return caps
+
+
+class Platform(NamedTuple):
+    id: str
+    name: str
+    base_url: str
+    search_url: str | None = None
+    fetch_url: str | None = None
+    allowed_prefixes: list[str] | None = None
+
+
+PLATFORMS: list[Platform] = [
+    Platform(
+        id="kimi-code",
+        name="Kimi Code",
+        base_url="https://api.kimi.com/coding/v1",
+        search_url="https://api.kimi.com/coding/v1/search",
+        fetch_url="https://api.kimi.com/coding/v1/fetch",
+    ),
+    Platform(
+        id="moonshot-cn",
+        name="Moonshot AI Open Platform (moonshot.cn)",
+        base_url="https://api.moonshot.cn/v1",
+        allowed_prefixes=["kimi-k"],
+    ),
+    Platform(
+        id="moonshot-ai",
+        name="Moonshot AI Open Platform (moonshot.ai)",
+        base_url="https://api.moonshot.ai/v1",
+        allowed_prefixes=["kimi-k"],
+    ),
+]
+
+_PLATFORM_BY_ID = {platform.id: platform for platform in PLATFORMS}
+_PLATFORM_BY_NAME = {platform.name: platform for platform in PLATFORMS}
+
+
+def get_platform_by_id(platform_id: str) -> Platform | None:
+    return _PLATFORM_BY_ID.get(platform_id)
+
+
+def get_platform_by_name(name: str) -> Platform | None:
+    return _PLATFORM_BY_NAME.get(name)
+
+
+MANAGED_PROVIDER_PREFIX = "managed:"
+
+
+def managed_provider_key(platform_id: str) -> str:
+    return f"{MANAGED_PROVIDER_PREFIX}{platform_id}"
+
+
+def managed_model_key(platform_id: str, model_id: str) -> str:
+    return f"{platform_id}/{model_id}"
+
+
+def parse_managed_provider_key(provider_key: str) -> str | None:
+    if not provider_key.startswith(MANAGED_PROVIDER_PREFIX):
+        return None
+    return provider_key.removeprefix(MANAGED_PROVIDER_PREFIX)
+
+
+def is_managed_provider_key(provider_key: str) -> bool:
+    return provider_key.startswith(MANAGED_PROVIDER_PREFIX)
+
+
+def get_platform_name_for_provider(provider_key: str) -> str | None:
+    platform_id = parse_managed_provider_key(provider_key)
+    if not platform_id:
+        return None
+    platform = get_platform_by_id(platform_id)
+    return platform.name if platform else None
+
+
+async def refresh_managed_models(config: Config) -> bool:
+    if not config.is_from_default_location:
+        return False
+
+    managed_providers = {
+        key: provider for key, provider in config.providers.items() if is_managed_provider_key(key)
+    }
+    if not managed_providers:
+        return False
+
+    changed = False
+    updates: list[tuple[str, str, list[ModelInfo]]] = []
+    for provider_key, provider in managed_providers.items():
+        platform_id = parse_managed_provider_key(provider_key)
+        if not platform_id:
+            continue
+        platform = get_platform_by_id(platform_id)
+        if platform is None:
+            logger.warning("Managed platform not found: {platform}", platform=platform_id)
+            continue
+
+        try:
+            models = await list_models(platform, provider.api_key.get_secret_value())
+        except Exception as exc:
+            logger.error(
+                "Failed to refresh models for {platform}: {error}",
+                platform=platform_id,
+                error=exc,
+            )
+            continue
+
+        updates.append((provider_key, platform_id, models))
+        if _apply_models(config, provider_key, platform_id, models):
+            changed = True
+
+    if changed:
+        config_for_save = load_config()
+        save_changed = False
+        for provider_key, platform_id, models in updates:
+            if _apply_models(config_for_save, provider_key, platform_id, models):
+                save_changed = True
+        if save_changed:
+            save_config(config_for_save)
+    return changed
+
+
+async def list_models(platform: Platform, api_key: str) -> list[ModelInfo]:
+    async with new_client_session() as session:
+        models = await _list_models(
+            session,
+            base_url=platform.base_url,
+            api_key=api_key,
+        )
+    if platform.allowed_prefixes is None:
+        return models
+    prefixes = tuple(platform.allowed_prefixes)
+    return [model for model in models if model.id.startswith(prefixes)]
+
+
+async def _list_models(
+    session: aiohttp.ClientSession,
+    *,
+    base_url: str,
+    api_key: str,
+) -> list[ModelInfo]:
+    models_url = f"{base_url.rstrip('/')}/models"
+    try:
+        async with session.get(
+            models_url,
+            headers={"Authorization": f"Bearer {api_key}"},
+            raise_for_status=True,
+        ) as response:
+            resp_json = await response.json()
+    except aiohttp.ClientError:
+        raise
+
+    data = resp_json.get("data")
+    if not isinstance(data, list):
+        raise ValueError(f"Unexpected models response for {base_url}")
+
+    result: list[ModelInfo] = []
+    for item in cast(list[dict[str, Any]], data):
+        model_id = item.get("id")
+        if not model_id:
+            continue
+        result.append(
+            ModelInfo(
+                id=str(model_id),
+                context_length=int(item.get("context_length") or 0),
+                supports_reasoning=bool(item.get("supports_reasoning")),
+            )
+        )
+    return result
+
+
+def _apply_models(
+    config: Config,
+    provider_key: str,
+    platform_id: str,
+    models: list[ModelInfo],
+) -> bool:
+    changed = False
+    model_keys: list[str] = []
+
+    for model in models:
+        model_key = managed_model_key(platform_id, model.id)
+        model_keys.append(model_key)
+
+        existing = config.models.get(model_key)
+        capabilities = model.capabilities or None  # empty set -> None
+
+        if existing is None:
+            config.models[model_key] = LLMModel(
+                provider=provider_key,
+                model=model.id,
+                max_context_size=model.context_length,
+                capabilities=capabilities,
+            )
+            changed = True
+            continue
+
+        if existing.provider != provider_key:
+            existing.provider = provider_key
+            changed = True
+        if existing.model != model.id:
+            existing.model = model.id
+            changed = True
+        if existing.max_context_size != model.context_length:
+            existing.max_context_size = model.context_length
+            changed = True
+        if existing.capabilities != capabilities:
+            existing.capabilities = capabilities
+            changed = True
+
+    removed_default = False
+    model_keys_set = set(model_keys)
+    for key, model in list(config.models.items()):
+        if model.provider != provider_key:
+            continue
+        if key in model_keys_set:
+            continue
+        del config.models[key]
+        if config.default_model == key:
+            removed_default = True
+        changed = True
+
+    if removed_default:
+        if model_keys:
+            config.default_model = model_keys[0]
+        else:
+            config.default_model = next(iter(config.models), "")
+        changed = True
+
+    if config.default_model and config.default_model not in config.models:
+        config.default_model = next(iter(config.models), "")
+        changed = True
+
+    return changed

kimi_cli/prompts/__init__.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from pathlib import Path
 
 INIT = (Path(__file__).parent / "init.md").read_text(encoding="utf-8")

kimi_cli/prompts/compact.md

@@ -1,4 +1,7 @@
-You are tasked with compacting a coding conversation context. This is critical for maintaining an effective working memory for the coding agent.
+
+---
+
+The above is a list of messages in an agent conversation. You are now given a task to compact this conversation context according to specific priorities and rules.
 
 **Compression Priorities (in order):**
 1. **Current Task State**: What is being worked on RIGHT NOW
@@ -19,10 +22,6 @@ You are tasked with compacting a coding conversation context. This is critical f
 - For errors: Keep full error message + final solution
 - For discussions: Extract decisions and action items only
 
-**Input Context to Compress:**
-
-${CONTEXT}
-
 **Required Output Structure:**
 
 <current_focus>