pythinker-code 0.8.0__py3-none-any.whl

pythinker_code/llm.py

@@ -0,0 +1,441 @@
+from __future__ import annotations
+
+import contextlib
+import json
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Literal, cast, get_args
+
+from pydantic import SecretStr
+from pythinker_core.chat_provider import ChatProvider
+
+from pythinker_code.constant import USER_AGENT
+from pythinker_code.utils.logging import logger
+
+if TYPE_CHECKING:
+    from pythinker_code.auth.oauth import OAuthManager
+    from pythinker_code.config import Config, LLMModel, LLMProvider
+
+type ProviderType = Literal[
+    "pythinker",
+    "openai_legacy",
+    "openai_responses",
+    "openai_codex",
+    "anthropic",
+    "google_genai",  # for backward-compatibility, equals to `gemini`
+    "gemini",
+    "vertexai",
+    "_echo",
+    "_scripted_echo",
+    "_chaos",
+]
+
+type ModelCapability = Literal["image_in", "video_in", "thinking", "always_thinking"]
+ALL_MODEL_CAPABILITIES: set[ModelCapability] = set(get_args(ModelCapability.__value__))
+
+
+@dataclass(slots=True)
+class LLM:
+    chat_provider: ChatProvider
+    max_context_size: int
+    capabilities: set[ModelCapability]
+    model_config: LLMModel | None = None
+    provider_config: LLMProvider | None = None
+    thinking: bool | None = None
+
+    @property
+    def model_name(self) -> str:
+        return self.chat_provider.model_name
+
+
+def model_display_name(model_name: str | None, model: LLMModel | None = None) -> str:
+    if model is not None and model.display_name:
+        return model.display_name
+    if not model_name:
+        return ""
+    if model_name in ("pythinker-for-coding", "pythinker-code"):
+        return "pythinker-for-coding"
+    return model_name
+
+
+def augment_provider_with_env_vars(
+    provider: LLMProvider,
+    model: LLMModel,
+    *,
+    provider_key: str | None = None,
+) -> dict[str, str]:
+    """Override provider/model settings from environment variables.
+
+    Returns:
+        Mapping of environment variables that were applied.
+    """
+    applied: dict[str, str] = {}
+
+    if provider_key == "managed:lm-studio":
+        if base_url := os.getenv("LM_STUDIO_BASE_URL"):
+            provider.base_url = base_url
+            applied["LM_STUDIO_BASE_URL"] = base_url
+        if api_key := os.getenv("LM_STUDIO_API_KEY"):
+            provider.api_key = SecretStr(api_key)
+            applied["LM_STUDIO_API_KEY"] = "******"
+        return applied
+
+    if provider_key == "managed:ollama":
+        if base_url := os.getenv("OLLAMA_BASE_URL"):
+            provider.base_url = base_url
+            applied["OLLAMA_BASE_URL"] = base_url
+        if api_key := os.getenv("OLLAMA_API_KEY"):
+            provider.api_key = SecretStr(api_key)
+            applied["OLLAMA_API_KEY"] = "******"
+        return applied
+
+    match provider.type:
+        case "pythinker":
+            if base_url := os.getenv("PYTHINKER_BASE_URL"):
+                provider.base_url = base_url
+                applied["PYTHINKER_BASE_URL"] = base_url
+            if api_key := os.getenv("PYTHINKER_API_KEY"):
+                provider.api_key = SecretStr(api_key)
+                applied["PYTHINKER_API_KEY"] = "******"
+            if model_name := os.getenv("PYTHINKER_MODEL_NAME"):
+                model.model = model_name
+                applied["PYTHINKER_MODEL_NAME"] = model_name
+            if max_context_size := os.getenv("PYTHINKER_MODEL_MAX_CONTEXT_SIZE"):
+                model.max_context_size = int(max_context_size)
+                applied["PYTHINKER_MODEL_MAX_CONTEXT_SIZE"] = max_context_size
+            if capabilities := os.getenv("PYTHINKER_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["PYTHINKER_MODEL_CAPABILITIES"] = capabilities
+        case "openai_legacy" | "openai_responses" | "openai_codex":
+            if base_url := os.getenv("OPENAI_BASE_URL"):
+                provider.base_url = base_url
+            if api_key := os.getenv("OPENAI_API_KEY"):
+                provider.api_key = SecretStr(api_key)
+        case _:
+            pass
+
+    return applied
+
+
+def _pythinker_default_headers(provider: LLMProvider, oauth: OAuthManager | None) -> dict[str, str]:
+    headers = {"User-Agent": USER_AGENT}
+    if oauth:
+        headers.update(oauth.common_headers())
+    if provider.custom_headers:
+        headers.update(provider.custom_headers)
+    return headers
+
+
+def _build_recording_http_client(provider_key: str) -> object:
+    """Build an httpx.AsyncClient that pipes response headers from each chat
+    completion into the rate-limit cache.
+
+    Returned as `object` so this module doesn't have to import httpx eagerly
+    (chat-completion code paths are the only callers, and they're already
+    importing httpx via openai/anthropic).
+    """
+    import httpx
+
+    from pythinker_code.usage_ratelimit_cache import get_cache
+
+    cache = get_cache()
+
+    async def _on_response(response: httpx.Response) -> None:
+        # Telemetry must never fail a chat request. The header dict is cheap
+        # to copy and the cache `record` call is sync + non-blocking.
+        with contextlib.suppress(Exception):
+            cache.record(provider_key, dict(response.headers))
+
+    return httpx.AsyncClient(event_hooks={"response": [_on_response]})
+
+
+def create_llm(
+    provider: LLMProvider,
+    model: LLMModel,
+    *,
+    thinking: bool | None = None,
+    session_id: str | None = None,
+    oauth: OAuthManager | None = None,
+) -> LLM | None:
+    if provider.type not in {"_echo", "_scripted_echo"} and (
+        not provider.base_url or not model.model
+    ):
+        logger.warning(
+            "Cannot create LLM: missing base_url or model (provider_type={provider_type})",
+            provider_type=provider.type,
+        )
+        return None
+
+    resolved_api_key = (
+        oauth.resolve_api_key(provider.api_key, provider.oauth)
+        if oauth and provider.oauth
+        else provider.api_key.get_secret_value()
+    )
+
+    # Capture rate-limit headers from every chat-completion HTTP response so
+    # /usage can render a "live rate limits" fallback panel for providers
+    # without a dedicated usage adapter (or whose adapter returned no data).
+    rl_http_client = (
+        _build_recording_http_client(model.provider)
+        if provider.type
+        not in {"_echo", "_scripted_echo", "_chaos", "google_genai", "gemini", "vertexai"}
+        else None
+    )
+
+    match provider.type:
+        case "pythinker":
+            from pythinker_core.chat_provider.pythinker import Pythinker
+
+            chat_provider = Pythinker(
+                model=model.model,
+                base_url=provider.base_url,
+                api_key=resolved_api_key,
+                default_headers=_pythinker_default_headers(provider, oauth),
+                http_client=rl_http_client,
+            )
+
+            gen_kwargs: Pythinker.GenerationKwargs = {}
+            if session_id:
+                gen_kwargs["prompt_cache_key"] = session_id
+            if temperature := os.getenv("PYTHINKER_MODEL_TEMPERATURE"):
+                gen_kwargs["temperature"] = float(temperature)
+            if top_p := os.getenv("PYTHINKER_MODEL_TOP_P"):
+                gen_kwargs["top_p"] = float(top_p)
+            if max_tokens := os.getenv("PYTHINKER_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 pythinker_core.contrib.chat_provider.openai_legacy import OpenAILegacy
+
+            reasoning_key = (
+                provider.reasoning_key
+                if provider.reasoning_key is not None
+                else "reasoning_content"
+            )
+            chat_provider = OpenAILegacy(
+                model=model.model,
+                base_url=provider.base_url,
+                api_key=resolved_api_key,
+                reasoning_key=reasoning_key,
+                default_headers=dict(provider.custom_headers) if provider.custom_headers else None,
+                http_client=rl_http_client,
+            )
+        case "openai_responses":
+            from pythinker_core.contrib.chat_provider.openai_responses import OpenAIResponses
+
+            chat_provider = OpenAIResponses(
+                model=model.model,
+                base_url=provider.base_url,
+                api_key=resolved_api_key,
+                default_headers=dict(provider.custom_headers) if provider.custom_headers else None,
+                http_client=rl_http_client,
+            )
+        case "openai_codex":
+            from pythinker_core.contrib.chat_provider.openai_responses import OpenAIResponses
+
+            chat_provider = OpenAIResponses(
+                model=model.model,
+                base_url=provider.base_url,
+                api_key=resolved_api_key,
+                system_prompt_as_instructions=True,
+                default_headers=dict(provider.custom_headers) if provider.custom_headers else None,
+                http_client=rl_http_client,
+            )
+        case "anthropic":
+            from pythinker_core.contrib.chat_provider.anthropic import Anthropic
+
+            chat_provider = Anthropic(
+                model=model.model,
+                base_url=provider.base_url,
+                api_key=resolved_api_key,
+                default_max_tokens=50000,
+                metadata={"user_id": session_id} if session_id else None,
+                default_headers=dict(provider.custom_headers) if provider.custom_headers else None,
+                http_client=rl_http_client,
+            )
+        case "google_genai" | "gemini":
+            from pythinker_core.contrib.chat_provider.google_genai import GoogleGenAI
+
+            chat_provider = GoogleGenAI(
+                model=model.model,
+                base_url=provider.base_url,
+                api_key=resolved_api_key,
+                default_headers=dict(provider.custom_headers) if provider.custom_headers else None,
+            )
+        case "vertexai":
+            from pythinker_core.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=resolved_api_key,
+                vertexai=True,
+                default_headers=dict(provider.custom_headers) if provider.custom_headers else None,
+            )
+        case "_echo":
+            from pythinker_core.chat_provider.echo import EchoChatProvider
+
+            chat_provider = EchoChatProvider()
+        case "_scripted_echo":
+            from pythinker_core.chat_provider.echo import ScriptedEchoChatProvider
+
+            if provider.env:
+                os.environ.update(provider.env)
+            scripts = _load_scripted_echo_scripts()
+            trace_value = os.getenv("PYTHINKER_SCRIPTED_ECHO_TRACE", "")
+            trace = trace_value.strip().lower() in {"1", "true", "yes", "on"}
+            chat_provider = ScriptedEchoChatProvider(scripts, trace=trace)
+        case "_chaos":
+            from pythinker_core.chat_provider.chaos import ChaosChatProvider, ChaosConfig
+            from pythinker_core.chat_provider.pythinker import Pythinker
+
+            chat_provider = ChaosChatProvider(
+                provider=Pythinker(
+                    model=model.model,
+                    base_url=provider.base_url,
+                    api_key=resolved_api_key,
+                    default_headers=_pythinker_default_headers(provider, oauth),
+                ),
+                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
+    thinking_on = "always_thinking" in capabilities or (
+        thinking is True and "thinking" in capabilities
+    )
+    is_kimi_openai_legacy = provider.type == "openai_legacy" and _is_kimi_k2_model(model.model)
+    if thinking_on and not is_kimi_openai_legacy:
+        chat_provider = chat_provider.with_thinking("high")
+    elif thinking is False and "thinking" in capabilities and not is_kimi_openai_legacy:
+        # Only explicitly send `reasoning_effort: null` for models that actually
+        # support reasoning. For models without the thinking capability, omit
+        # the field entirely — some providers (e.g., Alibaba via OpenAI-compat)
+        # reject explicit nulls with `'reasoning_effort' must be an object ...
+        # or a String`.
+        chat_provider = chat_provider.with_thinking("off")
+    # If thinking is None, or thinking is False on a non-reasoning model, leave
+    # the chat provider's default reasoning_effort (Omit) untouched.
+
+    # Kimi K2.5/K2.6 use an OpenAI-compatible API but their thinking toggle is
+    # the provider-specific `thinking.type` body field rather than OpenAI's
+    # `reasoning_effort`. Kimi defaults thinking to enabled, so when Pythinker
+    # config says thinking is off we must send the explicit Kimi switch;
+    # otherwise multi-step tool calls can still enter thinking mode and require
+    # `reasoning_content` on replayed tool-call turns.
+    if is_kimi_openai_legacy:
+        thinking_type = "enabled" if thinking_on else "disabled" if thinking is False else None
+        if thinking_type is not None:
+            chat_provider = cast(Any, chat_provider).with_generation_kwargs(
+                extra_body={"thinking": {"type": thinking_type}}
+            )
+
+    # Apply Pythinker AI-specific ``thinking.keep`` (preserved thinking) only when
+    # the model is actually in thinking mode; otherwise the API would see a
+    # ``thinking.keep`` without an accompanying ``thinking.type`` it honors.
+    if thinking_on and provider.type == "pythinker":
+        from pythinker_core.chat_provider.pythinker import Pythinker
+
+        if isinstance(chat_provider, Pythinker) and (
+            thinking_keep := os.getenv("PYTHINKER_MODEL_THINKING_KEEP")
+        ):
+            chat_provider = chat_provider.with_extra_body({"thinking": {"keep": thinking_keep}})
+
+    return LLM(
+        chat_provider=chat_provider,
+        max_context_size=model.max_context_size,
+        capabilities=capabilities,
+        model_config=model,
+        provider_config=provider,
+        thinking=thinking,
+    )
+
+
+def clone_llm_with_model_alias(
+    llm: LLM | None,
+    config: Config,
+    model_alias: str | None,
+    *,
+    session_id: str,
+    oauth: OAuthManager | None,
+    thinking: bool | None = None,
+) -> LLM | None:
+    if model_alias is None:
+        return llm
+    if model_alias not in config.models:
+        raise KeyError(f"Unknown model alias: {model_alias}")
+    model = config.models[model_alias]
+    provider = config.providers[model.provider]
+    if thinking is None and llm is not None:
+        thinking = llm.thinking
+    if thinking is None and llm is not None:
+        effort = getattr(llm.chat_provider, "thinking_effort", None)
+        if effort is not None:
+            thinking = effort != "off"
+    return create_llm(
+        provider,
+        model,
+        thinking=thinking,
+        session_id=session_id,
+        oauth=oauth,
+    )
+
+
+def derive_model_capabilities(model: LLMModel) -> set[ModelCapability]:
+    capabilities = set(model.capabilities or ())
+    model_name = model.model.lower()
+    # Kimi K2.5/K2.6 support thinking, but it can be disabled via
+    # `thinking.type`. Keep them out of always_thinking so --no-thinking and the
+    # default_thinking=false config path can send the provider-specific disable
+    # switch in create_llm().
+    if _is_kimi_k2_model(model.model):
+        capabilities.add("thinking")
+    # Models with "thinking" in their name are always-thinking models
+    elif "thinking" in model_name or "reason" in model_name:
+        capabilities.update(("thinking", "always_thinking"))
+    # These models support thinking but can be toggled on/off
+    elif model.model in {"pythinker-for-coding", "pythinker-code"}:
+        capabilities.update(("thinking", "image_in", "video_in"))
+    return capabilities
+
+
+def _is_kimi_k2_model(model_name: str) -> bool:
+    return "kimi-k2" in model_name.lower().replace("_", "-")
+
+
+def _load_scripted_echo_scripts() -> list[str]:
+    script_path = os.getenv("PYTHINKER_SCRIPTED_ECHO_SCRIPTS")
+    if not script_path:
+        raise ValueError("PYTHINKER_SCRIPTED_ECHO_SCRIPTS is required for _scripted_echo.")
+    path = Path(script_path).expanduser()
+    if not path.exists():
+        raise ValueError(f"Scripted echo file not found: {path}")
+    text = path.read_text(encoding="utf-8")
+    try:
+        data: object = json.loads(text)
+    except json.JSONDecodeError:
+        scripts = [chunk.strip() for chunk in text.split("\n---\n") if chunk.strip()]
+        if scripts:
+            return scripts
+        raise ValueError(
+            "Scripted echo file must be a JSON array of strings or a text file "
+            "split by '\\n---\\n'."
+        ) from None
+    if isinstance(data, list):
+        data_list = cast(list[object], data)
+        if all(isinstance(item, str) for item in data_list):
+            return cast(list[str], data_list)
+    raise ValueError("Scripted echo JSON must be an array of strings.")

pythinker_code/metadata.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import json
+from hashlib import md5
+from pathlib import Path
+
+from pydantic import BaseModel, ConfigDict, Field
+from pythinker_host import get_current_host
+from pythinker_host.local import local_host
+from pythinker_host.path import HostPath
+
+from pythinker_code.share import get_share_dir
+from pythinker_code.utils.io import atomic_json_write
+from pythinker_code.utils.logging import logger
+
+
+def get_metadata_file() -> Path:
+    return get_share_dir() / "pythinker.json"
+
+
+class WorkDirMeta(BaseModel):
+    """Metadata for a work directory."""
+
+    path: str
+    """The full path of the work directory."""
+
+    host: str = local_host.name
+    """The name of the host backend 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:
+        """The directory to store sessions for this work directory."""
+        path_md5 = md5(self.path.encode(encoding="utf-8"), usedforsecurity=False).hexdigest()
+        dir_basename = path_md5 if self.host == local_host.name else f"{self.host}_{path_md5}"
+        session_dir = get_share_dir() / "sessions" / dir_basename
+        session_dir.mkdir(parents=True, exist_ok=True)
+        return session_dir
+
+
+class Metadata(BaseModel):
+    """Pythinker metadata structure."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    work_dirs: list[WorkDirMeta] = Field(default_factory=list[WorkDirMeta])
+    """Work directory list."""
+
+    def get_work_dir_meta(self, path: HostPath) -> WorkDirMeta | None:
+        """Get the metadata for a work directory."""
+        for wd in self.work_dirs:
+            if wd.path == str(path) and wd.host == get_current_host().name:
+                return wd
+        return None
+
+    def new_work_dir_meta(self, path: HostPath) -> WorkDirMeta:
+        """Create a new work directory metadata."""
+        wd_meta = WorkDirMeta(path=str(path), host=get_current_host().name)
+        self.work_dirs.append(wd_meta)
+        return wd_meta
+
+
+def load_metadata() -> Metadata:
+    metadata_file = get_metadata_file()
+    logger.debug("Loading metadata from file: {file}", file=metadata_file)
+    if not metadata_file.exists():
+        logger.debug("No metadata file found, creating empty metadata")
+        return Metadata()
+    with open(metadata_file, encoding="utf-8") as f:
+        data = json.load(f)
+        return Metadata(**data)
+
+
+def save_metadata(metadata: Metadata):
+    metadata_file = get_metadata_file()
+    logger.debug("Saving metadata to file: {file}", file=metadata_file)
+    atomic_json_write(metadata.model_dump(), metadata_file)

pythinker_code/notifications/__init__.py

@@ -0,0 +1,33 @@
+from .llm import build_notification_message, extract_notification_ids, is_notification_message
+from .manager import NotificationManager
+from .models import (
+    NotificationCategory,
+    NotificationDelivery,
+    NotificationDeliveryStatus,
+    NotificationEvent,
+    NotificationSeverity,
+    NotificationSink,
+    NotificationSinkState,
+    NotificationView,
+)
+from .notifier import NotificationWatcher
+from .store import NotificationStore
+from .wire import to_wire_notification
+
+__all__ = [
+    "NotificationCategory",
+    "NotificationDelivery",
+    "NotificationDeliveryStatus",
+    "NotificationEvent",
+    "NotificationManager",
+    "NotificationSeverity",
+    "NotificationSink",
+    "NotificationSinkState",
+    "NotificationStore",
+    "NotificationView",
+    "NotificationWatcher",
+    "build_notification_message",
+    "extract_notification_ids",
+    "is_notification_message",
+    "to_wire_notification",
+]

pythinker_code/notifications/llm.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import re
+from collections.abc import Sequence
+from typing import TYPE_CHECKING
+
+from pythinker_core.message import Message
+
+from pythinker_code.wire.types import TextPart
+
+from .models import NotificationView
+
+if TYPE_CHECKING:
+    from pythinker_code.soul.agent import Runtime
+
+_NOTIFICATION_ID_RE = re.compile(r'<notification id="([^"]+)"')
+
+
+def build_notification_message(view: NotificationView, runtime: Runtime) -> Message:
+    event = view.event
+    lines = [
+        (
+            f'<notification id="{event.id}" category="{event.category}" '
+            f'type="{event.type}" source_kind="{event.source_kind}" source_id="{event.source_id}">'
+        ),
+        f"Title: {event.title}",
+        f"Severity: {event.severity}",
+        event.body,
+    ]
+
+    if event.category == "task" and event.source_kind == "background_task":
+        task_view = runtime.background_tasks.get_task(event.source_id)
+        if task_view is not None:
+            tail = runtime.background_tasks.tail_output(
+                task_view.spec.id,
+                max_bytes=runtime.config.background.notification_tail_chars,
+                max_lines=runtime.config.background.notification_tail_lines,
+            )
+            lines.extend(
+                [
+                    "<task-notification>",
+                    f"Task ID: {task_view.spec.id}",
+                    f"Task Type: {task_view.spec.kind}",
+                    f"Description: {task_view.spec.description}",
+                    f"Status: {task_view.runtime.status}",
+                ]
+            )
+            if task_view.runtime.exit_code is not None:
+                lines.append(f"Exit code: {task_view.runtime.exit_code}")
+            if task_view.runtime.failure_reason:
+                lines.append(f"Failure reason: {task_view.runtime.failure_reason}")
+            if tail:
+                lines.extend(["Output tail:", tail])
+            lines.append("</task-notification>")
+
+    lines.append("</notification>")
+    return Message(role="user", content=[TextPart(text="\n".join(lines))])
+
+
+def extract_notification_ids(history: Sequence[Message]) -> set[str]:
+    ids: set[str] = set()
+    for message in history:
+        if message.role != "user":
+            continue
+        for part in message.content:
+            if not isinstance(part, TextPart):
+                continue
+            for match in _NOTIFICATION_ID_RE.finditer(part.text):
+                ids.add(match.group(1))
+    return ids
+
+
+def is_notification_message(message: Message) -> bool:
+    if message.role != "user" or len(message.content) != 1:
+        return False
+    part = message.content[0]
+    return isinstance(part, TextPart) and part.text.lstrip().startswith("<notification ")