algo-cli-runtime 0.14.0__py3-none-any.whl

algo_cli/model_profile.py

@@ -0,0 +1,160 @@
+"""Model-aware runtime profiles.
+
+The harness knows each model's parameter size and provider but historically
+applied one static set of knobs (num_ctx, temperature, reflection cadence) to
+every model. A 4B local model and a 671B cloud model have very different needs:
+small models want a tighter window, cooler sampling, and more frequent
+reflection; large/cloud models can take a wider window and lighter supervision.
+
+This module derives a :class:`ModelProfile` from model metadata. It only fills
+in values the user has NOT explicitly changed from the Config defaults, so an
+explicit ``/ctx``, ``/temp``, or ``/thinkevery`` always wins.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from . import model_info as _model_info_module
+
+# Config-default sentinels. A field still equal to its default is treated as
+# "untouched" and therefore eligible for adaptation. Kept in sync with
+# config.Config; a mismatch only means adaptation is slightly more conservative.
+DEFAULT_NUM_CTX = 8192
+DEFAULT_TEMPERATURE = 0.4
+DEFAULT_TOOL_THINK_EVERY = 10
+
+# Size bands in billions of parameters.
+SMALL_MAX_B = 9.0      # <=9B  -> small
+MEDIUM_MAX_B = 32.0    # <=32B -> medium; above -> large
+
+
+@dataclass(frozen=True)
+class ModelProfile:
+    size_class: str            # "small" | "medium" | "large" | "unknown"
+    provider: str              # "local" | "cloud" | "xai" | "chatgpt"
+    num_ctx: int
+    temperature: float
+    tool_think_every: int
+    note: str                  # short human-readable rationale
+
+
+def _size_class(size_b: float | None) -> str:
+    if size_b is None:
+        return "unknown"
+    if size_b <= SMALL_MAX_B:
+        return "small"
+    if size_b <= MEDIUM_MAX_B:
+        return "medium"
+    return "large"
+
+
+def _provider(cfg: Any) -> str:
+    model = getattr(cfg, "model", "")
+    if _model_info_module.is_xai_model(model):
+        return "xai"
+    if _model_info_module.is_chatgpt_model(model):
+        return "chatgpt"
+    return "cloud" if getattr(cfg, "cloud", False) else "local"
+
+
+def recommend_profile(cfg: Any, model_info: dict[str, Any] | None) -> ModelProfile:
+    """Compute a recommended profile for the active model.
+
+    The recommendation is bounded by the model's real native context window
+    when known, so we never recommend a window the model cannot serve.
+    """
+    info = model_info or {}
+    size_b = _model_info_module.parameter_size_billions(info)
+    size_class = _size_class(size_b)
+    provider = _provider(cfg)
+    native_ctx = _model_info_module.get_context_length(info)
+
+    # Baseline recommendations by size class. Native context is a ceiling, not
+    # a default allocation: requesting a 128K-1M window for a short task wastes
+    # KV-cache memory and can sharply increase local prefill latency. Explicit
+    # /ctx user overrides still opt into wider windows in effective_params().
+    if size_class == "small":
+        num_ctx, temperature, think_every = 8192, 0.3, 6
+        note = "small model: tight fallback window, cooler sampling, frequent reflection"
+    elif size_class == "medium":
+        num_ctx, temperature, think_every = 16384, 0.4, 10
+        note = "medium model: standard fallback window and supervision"
+    elif size_class == "large":
+        num_ctx, temperature, think_every = 32768, 0.5, 14
+        note = "large model: wider fallback window, lighter supervision"
+    else:  # unknown
+        # Remote models often report no size; assume capable but be moderate.
+        if provider in {"cloud", "xai", "chatgpt"}:
+            num_ctx, temperature, think_every = 32768, 0.4, 12
+            note = "unknown-size remote model: moderate-wide fallback window"
+        else:
+            num_ctx, temperature, think_every = DEFAULT_NUM_CTX, DEFAULT_TEMPERATURE, DEFAULT_TOOL_THINK_EVERY
+            note = "unknown model: conservative fallback defaults"
+
+    if isinstance(native_ctx, int) and native_ctx > 0:
+        if provider == "local":
+            num_ctx = min(num_ctx, native_ctx)
+            note = f"{note}; local allocation capped by native context"
+        else:
+            num_ctx = native_ctx
+            note = f"{note}; remote native context"
+
+    return ModelProfile(
+        size_class=size_class,
+        provider=provider,
+        num_ctx=num_ctx,
+        temperature=temperature,
+        tool_think_every=think_every,
+        note=note,
+    )
+
+
+@dataclass(frozen=True)
+class EffectiveParams:
+    """The values to actually use this turn, after honoring user overrides."""
+
+    num_ctx: int
+    temperature: float
+    tool_think_every: int
+    adapted_fields: tuple[str, ...]
+
+
+def effective_params(cfg: Any, model_info: dict[str, Any] | None) -> EffectiveParams:
+    """Resolve per-turn params: user overrides win, else the model profile.
+
+    A Config field still equal to its default is considered untouched and is
+    replaced by the profile recommendation. Any field the user changed via
+    ``/ctx``, ``/temp``, or ``/thinkevery`` is preserved exactly.
+    """
+    profile = recommend_profile(cfg, model_info)
+    adapted: list[str] = []
+
+    if int(getattr(cfg, "num_ctx", DEFAULT_NUM_CTX)) == DEFAULT_NUM_CTX:
+        num_ctx = profile.num_ctx
+        if num_ctx != DEFAULT_NUM_CTX:
+            adapted.append("num_ctx")
+    else:
+        num_ctx = int(cfg.num_ctx)
+
+    if float(getattr(cfg, "temperature", DEFAULT_TEMPERATURE)) == DEFAULT_TEMPERATURE:
+        temperature = profile.temperature
+        if temperature != DEFAULT_TEMPERATURE:
+            adapted.append("temperature")
+    else:
+        temperature = float(cfg.temperature)
+
+    if int(getattr(cfg, "tool_think_every", DEFAULT_TOOL_THINK_EVERY)) == DEFAULT_TOOL_THINK_EVERY:
+        think_every = profile.tool_think_every
+        if think_every != DEFAULT_TOOL_THINK_EVERY:
+            adapted.append("tool_think_every")
+    else:
+        think_every = int(cfg.tool_think_every)
+
+    return EffectiveParams(
+        num_ctx=max(1, num_ctx),
+        temperature=temperature,
+        tool_think_every=max(1, think_every),
+        adapted_fields=tuple(adapted),
+    )

algo_cli/model_routing.py

@@ -0,0 +1,74 @@
+"""Model/host routing helpers (cloud vs local vs xAI)."""
+
+from __future__ import annotations
+
+import os
+
+from .config import Config, load_runtime_env
+from . import model_info as _model_info_module
+
+
+def is_cloud_model_name(name: str) -> bool:
+    return name.endswith(":cloud") or name.endswith("-cloud") or ":cloud-" in name
+
+
+def _runtime_ollama_api_key() -> str:
+    """Return OLLAMA_API_KEY after loading Algo CLI's runtime env file.
+
+    Tool/API subprocesses may start without inheriting the user's shell
+    environment. Loading here keeps routing/status checks consistent with
+    tool clients that already call ``load_runtime_env()``.
+    """
+    load_runtime_env(override=True)
+    return os.environ.get("OLLAMA_API_KEY", "").strip()
+
+
+def uses_ollama_cloud(cfg: Config) -> bool:
+    """Whether chat traffic should route through Ollama Cloud's direct API.
+
+    A ``:cloud`` model can also be served by a signed-in local Ollama daemon.
+    The first-run picker represents that case as ``cloud via local Ollama`` and
+    leaves ``cfg.cloud`` false. Even if stale config has ``cfg.cloud`` true, the
+    direct API route is active only when ``OLLAMA_API_KEY`` is present.
+    """
+    if _model_info_module.is_xai_model(cfg.model) or _model_info_module.is_chatgpt_model(cfg.model):
+        return False
+    return bool(cfg.cloud and _runtime_ollama_api_key())
+
+
+def effective_runtime_host(cfg: Config) -> str:
+    """Provider endpoint label for session_start / ops (not necessarily cfg.host)."""
+    if _model_info_module.is_xai_model(cfg.model):
+        return "xai"
+    if _model_info_module.is_chatgpt_model(cfg.model):
+        return "chatgpt"
+    if uses_ollama_cloud(cfg):
+        return "https://ollama.com"
+    return cfg.host
+
+
+def require_cloud_api_key(cfg: Config) -> None:
+    """Fail fast before a direct Cloud API chat call when OLLAMA_API_KEY is missing."""
+    if not uses_ollama_cloud(cfg):
+        return
+    if not _runtime_ollama_api_key():
+        raise ValueError(
+            "OLLAMA_API_KEY is required for direct Ollama Cloud API mode. "
+            "Set it in the process environment or in ~/.algo_cli/env."
+        )
+
+
+def is_embedding_model_name(name: str) -> bool:
+    lowered = name.lower()
+    return (
+        "embed" in lowered
+        or "embedding" in lowered
+        or lowered.startswith("nomic-embed")
+        or "minilm" in lowered
+        or "paraphrase" in lowered
+    )
+
+
+def is_vision_model_name(name: str) -> bool:
+    lowered = name.lower()
+    return any(token in lowered for token in ("vision", "-vl", "llava", "qwen2.5-vl", "qwen3-vl"))

algo_cli/oneshot.py

@@ -0,0 +1,331 @@
+"""One-shot non-interactive JSON event mode.
+
+Emits one JSON object per line to stdout, suitable for subprocess consumption
+by an external bridge (Telegram bot, CI, scripts). The agent loop, tool
+execution, policy, and contract code are unchanged; this module only swaps
+the output sink and gates the approval flow.
+
+Event schema (one JSON object per line, no embedded raw newlines):
+    {"type":"session_start","model":...,"host":...,"cwd":...,"approval_mode":...,"version":...}
+    {"type":"thinking","text":...}
+    {"type":"content","text":...}
+    {"type":"tool_call","call_id":...,"name":...,"args":{...}}
+    {"type":"tool_result","call_id":...,"name":...,"status":"ok|failed|denied|skipped",
+                         "duration_ms":...,"summary":...,"truncated":...}
+    {"type":"tool_denied","call_id":...,"name":...,"reason":...}
+    {"type":"error","class":"timeout|policy|tool|model|internal","message":...}
+    {"type":"done","status":"complete|partial|failed","status_reason":...,
+                   "tool_calls":...,"duration_ms":...}
+
+Invariants:
+    - session_start is the first event; done is the last event.
+    - tool_result always follows the matching tool_call by call_id.
+    - No ANSI escape codes in stdout.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+import time
+from collections import deque
+from typing import Any
+
+
+DANGEROUS_TOOLS = {"run_shell", "write_file", "edit_file", "batch_edit", "update_user_profile", "model_delete", "model_create"}
+SUMMARY_LIMIT = 600
+
+
+def _summarize(text: str, limit: int = SUMMARY_LIMIT) -> tuple[str, bool]:
+    s = str(text).strip()
+    if len(s) <= limit:
+        return s, False
+    return s[:limit].rstrip() + "...", True
+
+
+def _tool_status_from_result(result: str) -> str:
+    lowered = str(result).strip().lower()
+    if lowered.startswith("user denied"):
+        return "denied"
+    if lowered.startswith("skipped repeated"):
+        return "skipped"
+    if lowered.startswith(("error", "tool error", "tool argument error", "unknown tool")):
+        return "failed"
+    return "ok"
+
+
+class JsonEventSink:
+    """Stdout writer for one-shot JSON events. Thread-safe enough for serial dispatch."""
+
+    def __init__(self, *, stream=None, approval_mode: str = "never") -> None:
+        self._stream = stream if stream is not None else sys.stdout
+        self.approval_mode = approval_mode
+        self.deny_dangerous = approval_mode == "never"
+        self._call_count = 0
+        self._pending_call_ids: dict[str, deque[str]] = {}
+        self._tool_calls_done = 0
+        self._prompt_tokens = 0
+        self._completion_tokens = 0
+        self._errors: list[dict[str, str]] = []
+        self._started_at = time.perf_counter()
+
+    def _write(self, event: dict[str, Any]) -> None:
+        line = json.dumps(event, ensure_ascii=False, default=str)
+        # JSON encoding already escapes embedded newlines; one event per line is invariant.
+        self._stream.write(line + "\n")
+        self._stream.flush()
+
+    # --- framing ---
+
+    def session_start(self, *, model: str, host: str, cwd: str, version: str) -> None:
+        self._write({
+            "type": "session_start",
+            "model": model,
+            "host": host,
+            "cwd": cwd,
+            "approval_mode": self.approval_mode,
+            "version": version,
+        })
+
+    def done(self, *, status: str, status_reason: str, duration_ms: float) -> None:
+        total_tokens = self._prompt_tokens + self._completion_tokens
+        self._write({
+            "type": "done",
+            "status": status,
+            "status_reason": status_reason,
+            "tool_calls": self._tool_calls_done,
+            "duration_ms": round(duration_ms, 2),
+            "usage": {
+                "prompt_tokens": self._prompt_tokens,
+                "completion_tokens": self._completion_tokens,
+                "total_tokens": total_tokens,
+            },
+        })
+
+    # --- model output ---
+
+    def thinking(self, text: str) -> None:
+        if not text:
+            return
+        self._write({"type": "thinking", "text": text})
+
+    def content(self, text: str) -> None:
+        if not text:
+            return
+        self._write({"type": "content", "text": text})
+
+    def chat_usage(self, *, prompt_tokens: Any, completion_tokens: Any) -> None:
+        """Accumulate provider-reported usage once per completed chat turn."""
+
+        try:
+            prompt = int(prompt_tokens or 0)
+            completion = int(completion_tokens or 0)
+        except (TypeError, ValueError):
+            return
+        if prompt > 0 or completion > 0:
+            self._prompt_tokens += max(0, prompt)
+            self._completion_tokens += max(0, completion)
+
+    # --- tool dispatch ---
+
+    def next_call_id(self) -> str:
+        self._call_count += 1
+        return f"oneshot-{self._call_count}"
+
+    def tool_call(self, *, call_id: str, name: str, args: dict[str, Any]) -> None:
+        self._pending_call_ids.setdefault(name, deque()).append(call_id)
+        self._write({
+            "type": "tool_call",
+            "call_id": call_id,
+            "name": name,
+            "args": args,
+        })
+
+    def tool_result(
+        self,
+        *,
+        call_id: str | None,
+        name: str,
+        result: str,
+        duration_ms: float | None,
+    ) -> None:
+        call_id = self._matching_call_id(name, call_id)
+        status = _tool_status_from_result(result)
+        summary, truncated = _summarize(result)
+        self._tool_calls_done += 1
+        self._write({
+            "type": "tool_result",
+            "call_id": call_id,
+            "name": name,
+            "status": status,
+            "duration_ms": round(duration_ms, 2) if duration_ms is not None else None,
+            "summary": summary,
+            "truncated": truncated,
+        })
+
+    def tool_denied(self, *, call_id: str | None, name: str, reason: str) -> None:
+        call_id = self._matching_call_id(name, call_id)
+        self._tool_calls_done += 1
+        self._write({
+            "type": "tool_denied",
+            "call_id": call_id,
+            "name": name,
+            "reason": reason,
+        })
+
+    def _matching_call_id(self, name: str, call_id: str | None) -> str:
+        """Resolve a result to the oldest unmatched call of the same tool."""
+
+        pending = self._pending_call_ids.get(name)
+        if call_id:
+            if pending:
+                try:
+                    pending.remove(call_id)
+                except ValueError:
+                    pass
+                if not pending:
+                    self._pending_call_ids.pop(name, None)
+            return call_id
+        if pending:
+            matched = pending.popleft()
+            if not pending:
+                self._pending_call_ids.pop(name, None)
+            return matched
+        return self.next_call_id()
+
+    # --- errors ---
+
+    def error(self, *, error_class: str, message: str) -> None:
+        self._errors.append({"class": str(error_class), "message": str(message)})
+        self._write({
+            "type": "error",
+            "class": error_class,
+            "message": message,
+        })
+
+    @property
+    def errors(self) -> tuple[dict[str, str], ...]:
+        return tuple(self._errors)
+
+
+def run_oneshot(
+    *,
+    prompt: str,
+    approval_mode: str = "never",
+    cfg_overrides: dict[str, Any] | None = None,
+    stream=None,
+) -> int:
+    """Run a single agent turn and emit JSON events to stdout. Returns exit code.
+
+    - approval_mode="never" (default): dangerous tools are denied; emits tool_denied.
+    - approval_mode="auto": equivalent to cfg.auto_mode=True for this run only.
+    - cfg_overrides: applied to the loaded Config before the run (e.g., {"model": "qwen3"}).
+    """
+    # Imports deferred to avoid cycle with display + to keep import cost off the
+    # interactive path when --oneshot is not used.
+    from . import deliberation, display, harness, main, skills, tool_runtime
+    from .config import Config
+    from .model_routing import effective_runtime_host
+    from .tool_runtime import session_command_requires_approval
+
+    cfg = Config.load()
+    persistent_values: dict[str, Any] = {
+        "auto_mode": cfg.auto_mode,
+        "skill_crystallize_enabled": cfg.skill_crystallize_enabled,
+        "session_summary": cfg.session_summary,
+        "show_thinking": cfg.show_thinking,
+        "temperature": cfg.temperature,
+    }
+    if cfg_overrides:
+        for key, value in cfg_overrides.items():
+            if value is not None and hasattr(cfg, key):
+                persistent_values.setdefault(key, getattr(cfg, key))
+                setattr(cfg, key, value)
+    harness.configure_context_sources(
+        external=cfg.external_harness_sources_enabled,
+        index_compute_lab=cfg.index_compute_lab_auto_inject,
+    )
+    if approval_mode not in {"never", "auto"}:
+        raise ValueError("approval_mode must be 'never' or 'auto'")
+    cfg.auto_mode = approval_mode == "auto"
+    cfg.skill_crystallize_enabled = False  # subprocess invocation must not mutate skill store
+    if not cfg_overrides or "show_thinking" not in cfg_overrides:
+        cfg.show_thinking = cfg.show_thinking and deliberation.needs_deliberation(prompt)
+    if not cfg_overrides or "temperature" not in cfg_overrides:
+        cfg.temperature = min(cfg.temperature, 0.2)
+
+    # Bridge runs (Telegram, CI) must not inherit interactive session_summary into prompts.
+    cfg.session_summary = ""
+
+    sink = JsonEventSink(stream=stream, approval_mode=approval_mode)
+    sink.session_start(
+        model=cfg.model,
+        host=effective_runtime_host(cfg),
+        cwd=cfg.cwd,
+        version=_resolve_version(),
+    )
+
+    display.install_json_sink(sink)
+    original_ask_approval = main.ask_approval
+    original_runtime_ask_approval = tool_runtime.ask_approval
+
+    def _oneshot_ask_approval(name: str, args: dict[str, Any], cfg: Config, *, force: bool = False) -> bool:
+        del cfg
+        requires_approval = name in DANGEROUS_TOOLS or (
+            name == "session_command"
+            and session_command_requires_approval(str(args.get("command") or ""))
+        )
+        if approval_mode == "never" and requires_approval:
+            # Sink's tool_denied is emitted in the agent_loop's denial path via show_tool_result.
+            # We just refuse here; the existing "User denied this operation." message flows
+            # through show_tool_result → sink.tool_denied conversion.
+            return False
+        if approval_mode == "auto" and not force:
+            return True
+        return True
+
+    main.ask_approval = _oneshot_ask_approval
+    tool_runtime.ask_approval = _oneshot_ask_approval
+
+    started = time.perf_counter()
+    status = "complete"
+    status_reason = ""
+    try:
+        client = main.create_client(cfg)
+        main.agent_loop(client, cfg, prompt)
+    except KeyboardInterrupt:
+        status = "failed"
+        status_reason = "interrupted"
+        sink.error(error_class="internal", message="KeyboardInterrupt")
+    except Exception as exc:
+        status = "failed"
+        status_reason = f"{type(exc).__name__}: {exc}"
+        sink.error(error_class="internal", message=status_reason)
+    finally:
+        main.ask_approval = original_ask_approval
+        tool_runtime.ask_approval = original_runtime_ask_approval
+        display.uninstall_json_sink()
+        skills.ensure_dirs()  # restore any deferred dir state
+        # agent_loop saves config; restore bridge-only mutations and CLI override fields.
+        for key, value in persistent_values.items():
+            setattr(cfg, key, value)
+        cfg.save()
+
+    if status == "complete" and sink.errors:
+        status = "partial"
+        status_reason = sink.errors[-1].get("message", "one-shot run emitted an error event")
+
+    sink.done(
+        status=status,
+        status_reason=status_reason,
+        duration_ms=(time.perf_counter() - started) * 1000,
+    )
+    return 0 if status == "complete" else 2
+
+
+def _resolve_version() -> str:
+    try:
+        from importlib.metadata import version
+        return version("algo-cli-runtime")
+    except Exception:
+        return "unknown"