mycode-cli 0.1.0__py3-none-any.whl

mycode/core/messages.py

@@ -0,0 +1,166 @@
+"""Internal conversation model shared by the runtime, session store, CLI, and UI.
+
+The runtime persists a single message shape everywhere:
+
+- user message: text blocks, image blocks, and tool_result blocks
+- assistant message: thinking blocks, text blocks, and tool_use blocks
+
+Provider adapters translate between this internal shape and provider-specific wire
+formats. The agent loop and session store should never need to know provider wire
+details.
+
+Metadata contract:
+
+- assistant message `meta` keeps normalized top-level fields only:
+  `provider`, `model`, `provider_message_id`, `stop_reason`, `usage`
+- provider-specific assistant message extras live under `meta.native`
+- provider-specific block replay hints live under `block.meta.native`
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+ContentBlock = dict[str, Any]
+ConversationMessage = dict[str, Any]
+
+
+def text_block(text: str, *, meta: dict[str, Any] | None = None) -> ContentBlock:
+    block: ContentBlock = {"type": "text", "text": text}
+    if meta:
+        block["meta"] = dict(meta)
+    return block
+
+
+def thinking_block(text: str, *, meta: dict[str, Any] | None = None) -> ContentBlock:
+    block: ContentBlock = {"type": "thinking", "text": text}
+    if meta:
+        block["meta"] = dict(meta)
+    return block
+
+
+def image_block(
+    data: str,
+    *,
+    mime_type: str,
+    name: str | None = None,
+    meta: dict[str, Any] | None = None,
+) -> ContentBlock:
+    block: ContentBlock = {"type": "image", "data": data, "mime_type": mime_type}
+    if name:
+        block["name"] = name
+    if meta:
+        block["meta"] = dict(meta)
+    return block
+
+
+def tool_use_block(
+    *,
+    tool_id: str,
+    name: str,
+    input: dict[str, Any] | None = None,
+    meta: dict[str, Any] | None = None,
+) -> ContentBlock:
+    block: ContentBlock = {
+        "type": "tool_use",
+        "id": tool_id,
+        "name": name,
+        "input": dict(input or {}),
+    }
+    if meta:
+        block["meta"] = dict(meta)
+    return block
+
+
+def tool_result_block(
+    *,
+    tool_use_id: str,
+    model_text: str,
+    display_text: str,
+    is_error: bool = False,
+    content: list[ContentBlock] | None = None,
+    meta: dict[str, Any] | None = None,
+) -> ContentBlock:
+    """Build a tool-result block.
+
+    `model_text` is replayed back to providers on later turns.
+    `display_text` is the user-facing text shown by CLI and web UI.
+    """
+
+    block: ContentBlock = {
+        "type": "tool_result",
+        "tool_use_id": tool_use_id,
+        "model_text": model_text,
+        "display_text": display_text,
+        "is_error": is_error,
+    }
+    if content:
+        block["content"] = [dict(item) for item in content]
+    if meta:
+        block["meta"] = dict(meta)
+    return block
+
+
+def user_text_message(text: str, *, meta: dict[str, Any] | None = None) -> ConversationMessage:
+    return build_message("user", [text_block(text)], meta=meta)
+
+
+def build_message(
+    role: str,
+    blocks: list[ContentBlock],
+    *,
+    meta: dict[str, Any] | None = None,
+) -> ConversationMessage:
+    message: ConversationMessage = {"role": role, "content": blocks}
+    if meta:
+        message["meta"] = dict(meta)
+    return message
+
+
+def assistant_message(
+    blocks: list[ContentBlock],
+    *,
+    provider: str | None = None,
+    model: str | None = None,
+    provider_message_id: str | None = None,
+    stop_reason: str | None = None,
+    usage: Any = None,
+    native_meta: dict[str, Any] | None = None,
+) -> ConversationMessage:
+    """Build a normalized assistant message with shared metadata fields."""
+
+    meta: dict[str, Any] = {}
+    if provider:
+        meta["provider"] = provider
+    if model:
+        meta["model"] = model
+    if provider_message_id:
+        meta["provider_message_id"] = provider_message_id
+    if stop_reason:
+        meta["stop_reason"] = stop_reason
+    if usage is not None:
+        meta["usage"] = usage
+    if native_meta:
+        native = {key: value for key, value in native_meta.items() if value is not None}
+        if native:
+            meta["native"] = native
+    return build_message("assistant", blocks, meta=meta or None)
+
+
+def flatten_message_text(message: ConversationMessage, *, include_thinking: bool = True) -> str:
+    """Flatten readable text while skipping synthetic attachment payload blocks."""
+
+    parts: list[str] = []
+    for block in message.get("content") or []:
+        if not isinstance(block, dict):
+            continue
+        raw_meta = block.get("meta")
+        meta = raw_meta if isinstance(raw_meta, dict) else {}
+        # Attached file snapshots should not become session titles or history labels.
+        if meta.get("attachment"):
+            continue
+        if block.get("type") == "text":
+            parts.append(str(block.get("text") or ""))
+        elif include_thinking and block.get("type") == "thinking":
+            parts.append(str(block.get("text") or ""))
+    return " ".join(part.strip() for part in parts if part and part.strip()).strip()

mycode/core/models.py

@@ -0,0 +1,144 @@
+"""Load and query the bundled model metadata catalog."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+_MODELS_CATALOG_PATH = Path(__file__).with_name("models_catalog.json")
+
+_models_catalog_cache: dict[str, Any] | None = None
+_models_catalog_loaded = False
+
+
+@dataclass(frozen=True)
+class ModelMetadata:
+    """Normalized metadata used by provider resolution."""
+
+    provider: str
+    model: str
+    context_window: int | None
+    max_output_tokens: int | None
+    supports_reasoning: bool | None
+    supports_image_input: bool | None
+
+
+def load_models_catalog() -> dict[str, Any] | None:
+    """Load the bundled model catalog from disk once per process."""
+
+    global _models_catalog_cache, _models_catalog_loaded
+
+    if _models_catalog_loaded:
+        return _models_catalog_cache
+
+    try:
+        data = json.loads(_MODELS_CATALOG_PATH.read_text(encoding="utf-8"))
+    except Exception:
+        data = None
+
+    _models_catalog_cache = data if isinstance(data, dict) else None
+    _models_catalog_loaded = True
+    return _models_catalog_cache
+
+
+def lookup_model_metadata(
+    *,
+    provider_type: str | None,
+    model: str | None,
+    provider_name: str | None = None,  # reserved for future per-alias lookup
+    api_base: str | None = None,  # reserved for future custom-endpoint lookup
+) -> ModelMetadata | None:
+    """Resolve metadata for one internal provider type and model."""
+
+    raw_model_id = (model or "").strip()
+    if not raw_model_id:
+        return None
+
+    catalog = load_models_catalog()
+    if not catalog:
+        return None
+
+    normalized_model_id = _strip_prefix(raw_model_id)
+    fallback_provider_type = _default_provider(normalized_model_id)
+
+    metadata = _lookup_entry(catalog, provider_type, raw_model_id)
+    if metadata is not None:
+        return metadata
+
+    if fallback_provider_type and fallback_provider_type != provider_type:
+        metadata = _lookup_entry(catalog, fallback_provider_type, normalized_model_id)
+        if metadata is not None:
+            return metadata
+
+    return _lookup_entry(catalog, "aihubmix", normalized_model_id)
+
+
+def _lookup_entry(
+    catalog: dict[str, Any],
+    provider_type: str | None,
+    model_id: str,
+) -> ModelMetadata | None:
+    """Read one exact provider/model entry from the bundled catalog."""
+
+    if not provider_type:
+        return None
+
+    provider = catalog.get(provider_type)
+    if not isinstance(provider, dict):
+        return None
+
+    raw_model = provider.get(model_id)
+    if not isinstance(raw_model, dict):
+        return None
+
+    return ModelMetadata(
+        provider=provider_type,
+        model=model_id,
+        context_window=_as_int(raw_model.get("context_window")),
+        max_output_tokens=_as_int(raw_model.get("max_output_tokens")),
+        supports_reasoning=raw_model.get("supports_reasoning")
+        if isinstance(raw_model.get("supports_reasoning"), bool)
+        else None,
+        supports_image_input=raw_model.get("supports_image_input")
+        if isinstance(raw_model.get("supports_image_input"), bool)
+        else None,
+    )
+
+
+def _default_provider(model_id: str) -> str | None:
+    """Return the canonical internal provider type for a normalized model id."""
+
+    normalized = model_id.lower()
+    if normalized.startswith("claude-"):
+        return "anthropic"
+    if normalized.startswith("deepseek-"):
+        return "deepseek"
+    if normalized.startswith("gemini-"):
+        return "google"
+    if normalized.startswith("glm-"):
+        return "zai"
+    if normalized.startswith("gpt-") or normalized.startswith(("o1", "o3", "o4")):
+        return "openai"
+    if normalized.startswith("kimi-"):
+        return "moonshotai"
+    if normalized.startswith("minimax-"):
+        return "minimax"
+    return None
+
+
+def _strip_prefix(model_id: str) -> str:
+    """Convert `provider/model` ids into the bare model id."""
+
+    if "/" not in model_id:
+        return model_id
+    return model_id.split("/", 1)[1].strip()
+
+
+def _as_int(value: Any) -> int | None:
+    """Return an int value while rejecting bools and non-ints."""
+
+    if isinstance(value, bool) or not isinstance(value, int):
+        return None
+    return value