@cjhyy/code-shell-core 0.5.0-rc.0

package/dist/llm/model-pool.js

@@ -0,0 +1,246 @@
+/**
+ * ModelPool — runtime model registry.
+ *
+ * Holds all available models loaded from settings. Provides:
+ *   - `get(key?)` — retrieve a model config by key, or the active one
+ *   - `switch(key)` — change the active model
+ *   - `list()` — list all available models
+ *   - `register(entry)` — add a model at runtime
+ *
+ * Consumers:
+ *   - Engine/TurnLoop: `pool.get()` for the active model
+ *   - Arena: `pool.get("sonnet")` to resolve participants by key
+ *   - /model command: `pool.switch("haiku")` for hot-swap
+ */
+import { readCache } from "./model-cache.js";
+import { findOpenRouterModel } from "../data/openrouter-models.js";
+/**
+ * Last-resort context window when neither the provider's cached
+ * model list nor the OpenRouter snapshot knows the size. Picked
+ * to match the most common chat-model default in 2024–2026; better
+ * to truncate than to send a request the model will reject.
+ */
+const FALLBACK_CONTEXT_WINDOW = 200_000;
+/**
+ * Provider kind → OpenRouter vendor prefix. Mirrors the table in
+ * model-fetcher.ts so a missing context window on a direct-provider
+ * entry (e.g. OpenAI's `gpt-5.5`) can be patched from the bundled
+ * OpenRouter snapshot (`openai/gpt-5.5`). Kinds outside this map
+ * (groq/ollama/openrouter/custom) skip the snapshot lookup — the
+ * openrouter kind is handled separately since its ids already carry
+ * the vendor prefix.
+ */
+const OPENROUTER_VENDOR_BY_KIND = {
+    openai: "openai",
+    anthropic: "anthropic",
+    deepseek: "deepseek",
+    google: "google",
+    zai: "z-ai",
+    xai: "x-ai",
+    mistral: "mistralai",
+};
+// ─── Built-in context windows ────────────────────────────────────
+// Known max input tokens for well-known model names. Used as a fallback
+// when a settings entry doesn't specify maxContextTokens, so users don't
+// have to hand-fill it for common models.
+//
+// Patterns are matched against the full `model` string (case-insensitive).
+// First match wins — order from most specific to most generic.
+const BUILTIN_CONTEXT_WINDOWS = [
+    // DeepSeek V4 family — 1M context (api-docs.deepseek.com)
+    [/^deepseek-v4(?:-|$)/i, 1_000_000],
+    [/(?:^|\/)deepseek-v4(?:-|$)/i, 1_000_000],
+];
+function lookupBuiltinContextWindow(model) {
+    for (const [re, tokens] of BUILTIN_CONTEXT_WINDOWS) {
+        if (re.test(model))
+            return tokens;
+    }
+    return undefined;
+}
+// ─── ModelPool ───────────────────────────────────────────────────
+export class ModelPool {
+    models = new Map();
+    activeKey;
+    providerCatalog;
+    cacheDir;
+    setProviderCatalog(cat) {
+        this.providerCatalog = cat;
+    }
+    setCacheDir(dir) {
+        this.cacheDir = dir;
+    }
+    /**
+     * For each entry that lacks an explicit maxContextTokens but has a
+     * providerKey, fill it in. Lookup order:
+     *   1. The provider's cached /v1/models response (most authoritative —
+     *      it's what the vendor itself returned at last sync).
+     *   2. The bundled OpenRouter snapshot, keyed by `<vendor>/<id>` — covers
+     *      the common case where a direct-provider model (e.g. `gpt-5.5`)
+     *      is also published on OpenRouter with full metadata.
+     *   3. A final 200k floor so unknown models still get *some* context
+     *      window rather than tripping max-token math downstream.
+     *
+     * Entries with an explicit maxContextTokens (set by the user in settings
+     * or by a prior code path) are left alone — we never overwrite what the
+     * user typed in.
+     */
+    reloadCachedContextWindows() {
+        for (const [key, entry] of this.models) {
+            if (entry.maxContextTokens != null)
+                continue;
+            const resolved = this.resolveContextWindow(entry);
+            if (resolved != null) {
+                this.models.set(key, { ...entry, maxContextTokens: resolved });
+            }
+        }
+    }
+    resolveContextWindow(entry) {
+        // 1. Per-provider /v1/models cache.
+        if (this.cacheDir && entry.providerKey) {
+            const file = readCache(this.cacheDir, entry.providerKey);
+            const match = file?.models.find((m) => m.id === entry.model);
+            if (match?.contextLength)
+                return match.contextLength;
+        }
+        // 2. OpenRouter snapshot — translate the entry's provider kind to the
+        //    snapshot's `<vendor>/<id>` form.
+        const kind = entry.providerKey
+            ? this.providerCatalog?.get(entry.providerKey)?.kind
+            : undefined;
+        if (kind === "openrouter") {
+            const hit = findOpenRouterModel(entry.model);
+            if (hit?.contextLength)
+                return hit.contextLength;
+        }
+        else if (kind) {
+            const vendor = OPENROUTER_VENDOR_BY_KIND[kind];
+            if (vendor) {
+                const hit = findOpenRouterModel(`${vendor}/${entry.model}`);
+                if (hit?.contextLength)
+                    return hit.contextLength;
+            }
+        }
+        // 3. Final floor — better than leaving it undefined and reading
+        //    config.maxContextTokens (which may itself be unset).
+        return FALLBACK_CONTEXT_WINDOW;
+    }
+    /**
+     * Build a pool from an array of model entries.
+     * The first entry (or the one matching `defaultKey`) becomes active.
+     */
+    constructor(entries, defaultKey) {
+        if (entries) {
+            for (const e of entries) {
+                this.models.set(e.key, this.withBuiltinDefaults(e));
+            }
+        }
+        if (defaultKey && this.models.has(defaultKey)) {
+            this.activeKey = defaultKey;
+        }
+        else if (entries?.length) {
+            this.activeKey = entries[0].key;
+        }
+    }
+    /** Register a model at runtime. */
+    register(entry) {
+        this.models.set(entry.key, this.withBuiltinDefaults(entry));
+        if (!this.activeKey) {
+            this.activeKey = entry.key;
+        }
+    }
+    /** Fill in known defaults (e.g. context window for DeepSeek V4) when the entry doesn't specify them. */
+    withBuiltinDefaults(entry) {
+        if (entry.maxContextTokens != null)
+            return entry;
+        const builtin = lookupBuiltinContextWindow(entry.model);
+        if (builtin == null)
+            return entry;
+        return { ...entry, maxContextTokens: builtin };
+    }
+    /** Switch the active model. Throws if key not found. */
+    switch(key) {
+        const entry = this.models.get(key);
+        if (!entry) {
+            const available = [...this.models.keys()].join(", ");
+            throw new Error(`Model "${key}" not found. Available: ${available}`);
+        }
+        this.activeKey = key;
+        return entry;
+    }
+    /** Get a model by key. No key = active model. Returns undefined if not found. */
+    get(key) {
+        if (key)
+            return this.models.get(key);
+        if (this.activeKey)
+            return this.models.get(this.activeKey);
+        return undefined;
+    }
+    /** Get the active model key. */
+    getActiveKey() {
+        return this.activeKey;
+    }
+    /** List all registered models. */
+    list() {
+        return [...this.models.values()];
+    }
+    /** Number of registered models. */
+    get size() {
+        return this.models.size;
+    }
+    /** Check if a key exists. */
+    has(key) {
+        return this.models.has(key);
+    }
+    /**
+     * Build an LLMConfig for a given model entry, merging with a base config
+     * (inherits apiKey, baseUrl, etc. from the base if not set on the entry).
+     */
+    toLLMConfig(entry, base) {
+        const fromCat = entry.providerKey && this.providerCatalog
+            ? this.providerCatalog.get(entry.providerKey)
+            : undefined;
+        // Map provider-kind → client-factory name. client-factory only registers
+        // "anthropic" and "openai" (everything else is anthropic- or openai-
+        // compatible), so kinds outside that pair must collapse to one of them.
+        const kindToClientProvider = (kind) => {
+            if (!kind)
+                return "openai";
+            if (kind === "anthropic")
+                return "anthropic";
+            return "openai";
+        };
+        return {
+            provider: entry.provider ||
+                kindToClientProvider(fromCat?.kind) ||
+                "openai",
+            model: entry.model,
+            apiKey: entry.apiKey ?? fromCat?.apiKey ?? base?.apiKey,
+            baseUrl: entry.baseUrl ?? fromCat?.baseUrl ?? base?.baseUrl,
+            temperature: base?.temperature ?? 0.3,
+            maxTokens: entry.maxOutputTokens ?? base?.maxTokens ?? 8192,
+            enableStreaming: base?.enableStreaming ?? true,
+            // thinking precedence: model entry > provider catalog > base.
+            // Model-level wins so users can hold one default for "deepseek"
+            // and still override a single model (e.g. v4-pro off).
+            ...(entry.thinking || fromCat?.thinking || base?.thinking
+                ? { thinking: entry.thinking ?? fromCat?.thinking ?? base?.thinking }
+                : {}),
+            // Carry the catalog kind through so the capability layer can pick
+            // per-(kind, model) request-shape rules. Defaults below cover the
+            // unusual case where an entry has a provider but no providerKey
+            // (legacy / arena-injected models).
+            ...(fromCat?.kind ? { providerKind: fromCat.kind } : {}),
+        };
+    }
+    /**
+     * Build an LLMConfig for the active model (or a specific key),
+     * merging with a base config.
+     */
+    resolveLLMConfig(key, base) {
+        const entry = this.get(key);
+        if (!entry)
+            return undefined;
+        return this.toLLMConfig(entry, base);
+    }
+}

package/dist/llm/provider-catalog.d.ts

@@ -0,0 +1,32 @@
+/**
+ * In-memory catalog of provider credentials. Mirrors settings.providers[]
+ * but offers a small API for add/update/remove that validates uniqueness
+ * and (for remove) refuses to delete a provider still referenced by a
+ * model entry. The caller persists changes back to settings.
+ */
+import type { ProviderKindName } from "./provider-kinds.js";
+export interface ProviderConfig {
+    key: string;
+    label?: string;
+    kind: ProviderKindName;
+    baseUrl: string;
+    apiKey?: string;
+    protocol?: "openai-compat" | "anthropic-style";
+    modelsPath?: string;
+    /** Default DeepSeek V4 thinking-mode for this provider. See LLMConfig. */
+    thinking?: "enabled" | "disabled";
+}
+export declare class ProviderCatalog {
+    private byKey;
+    constructor(entries?: ProviderConfig[]);
+    list(): ProviderConfig[];
+    get(key: string): ProviderConfig | undefined;
+    has(key: string): boolean;
+    add(entry: ProviderConfig): void;
+    update(key: string, patch: Partial<ProviderConfig>): void;
+    remove(key: string, opts: {
+        referencedBy: string[];
+    }): void;
+    /** Compute an unused key for a new provider, given a desired base. */
+    deriveKey(base: string): string;
+}

package/dist/llm/provider-catalog.js

@@ -0,0 +1,50 @@
+/**
+ * In-memory catalog of provider credentials. Mirrors settings.providers[]
+ * but offers a small API for add/update/remove that validates uniqueness
+ * and (for remove) refuses to delete a provider still referenced by a
+ * model entry. The caller persists changes back to settings.
+ */
+export class ProviderCatalog {
+    byKey = new Map();
+    constructor(entries) {
+        for (const e of entries ?? [])
+            this.byKey.set(e.key, e);
+    }
+    list() {
+        return [...this.byKey.values()];
+    }
+    get(key) {
+        return this.byKey.get(key);
+    }
+    has(key) {
+        return this.byKey.has(key);
+    }
+    add(entry) {
+        if (this.byKey.has(entry.key)) {
+            throw new Error(`duplicate provider key: ${entry.key}`);
+        }
+        this.byKey.set(entry.key, entry);
+    }
+    update(key, patch) {
+        const cur = this.byKey.get(key);
+        if (!cur)
+            throw new Error(`no such provider: ${key}`);
+        this.byKey.set(key, { ...cur, ...patch, key: cur.key });
+    }
+    remove(key, opts) {
+        if (opts.referencedBy.length) {
+            throw new Error(`provider ${key} still referenced by models: ${opts.referencedBy.join(", ")}`);
+        }
+        this.byKey.delete(key);
+    }
+    /** Compute an unused key for a new provider, given a desired base. */
+    deriveKey(base) {
+        if (!this.byKey.has(base))
+            return base;
+        for (let i = 2;; i++) {
+            const candidate = `${base}-${i}`;
+            if (!this.byKey.has(candidate))
+                return candidate;
+        }
+    }
+}

package/dist/llm/provider-kinds.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Built-in provider kind metadata.
+ *
+ * Each kind defines how to talk to that provider family: where its
+ * model list lives, what auth header to send, which model IDs to keep
+ * (chat-completion only — embeddings / TTS / image generation are
+ * filtered out so they don't show up in the model picker).
+ */
+export type ProviderKindName = "openai" | "anthropic" | "deepseek" | "zai" | "xai" | "mistral" | "groq" | "google" | "openrouter" | "ollama" | "custom";
+export type ProviderProtocol = "openai-compat" | "anthropic-style" | "gemini" | "ollama";
+export interface ProviderKindMeta {
+    label: string;
+    defaultBaseUrl: string;
+    modelsPath: string;
+    protocol: ProviderProtocol;
+    authHeader: (apiKey: string) => Record<string, string>;
+    chatFilter: (id: string) => boolean;
+    authQuery?: (apiKey: string) => Record<string, string>;
+}
+export declare const PROVIDER_KINDS: Record<ProviderKindName, ProviderKindMeta>;
+export declare function getKindMeta(kind: string): ProviderKindMeta;

package/dist/llm/provider-kinds.js

@@ -0,0 +1,132 @@
+/**
+ * Built-in provider kind metadata.
+ *
+ * Each kind defines how to talk to that provider family: where its
+ * model list lives, what auth header to send, which model IDs to keep
+ * (chat-completion only — embeddings / TTS / image generation are
+ * filtered out so they don't show up in the model picker).
+ */
+// Models we want to hide from the picker — none of these speak the
+// vanilla chat-completions protocol the engine uses:
+//   embedding / whisper / tts / audio / image / dall-e / moderation
+//   rerank / guard / vision-only      — non-text outputs
+//   realtime / transcribe             — different endpoints (WS / audio)
+//   search-preview / search-api       — web-search wrappers
+//   sora / computer-use               — non-chat task APIs
+//   deep-research                     — async research API
+//   codex                             — IDE-integration specific
+//   chat-latest                       — moving alias (we'd rather pin a version)
+const NON_CHAT_PATTERNS = /(?:^|[-_/])(?:embed(?:ding)?|whisper|tts|audio|image|dall-?e|moderation|rerank|guard|vision-only|realtime|transcribe|search-preview|search-api|sora|computer-use|deep-research|codex|chat-latest)(?:$|[-_/])/i;
+// User-specific fine-tuned ids look like "ft:<base>:<org>::<hash>" —
+// keeping them out of the default picker; people who want them can
+// add manually.
+const isFineTunedId = (id) => id.startsWith("ft:");
+// "Dated snapshot" ids end with -YYYY-MM-DD. They're the immutable
+// pin behind the floating alias (`gpt-5.4` ⇨ `gpt-5.4-2026-03-05`).
+// Hide them by default — the floating alias covers the same model
+// and avoids picker noise.
+const isDatedSnapshotId = (id) => /-\d{4}-\d{2}-\d{2}$/.test(id);
+const isChatLike = (id) => !NON_CHAT_PATTERNS.test(id) && !isFineTunedId(id) && !isDatedSnapshotId(id);
+const bearer = (k) => (k ? { Authorization: `Bearer ${k}` } : {});
+export const PROVIDER_KINDS = {
+    openai: {
+        label: "OpenAI",
+        defaultBaseUrl: "https://api.openai.com/v1",
+        modelsPath: "/models",
+        protocol: "openai-compat",
+        authHeader: bearer,
+        chatFilter: isChatLike,
+    },
+    anthropic: {
+        label: "Anthropic",
+        defaultBaseUrl: "https://api.anthropic.com/v1",
+        modelsPath: "/models",
+        protocol: "anthropic-style",
+        authHeader: (k) => k
+            ? { "x-api-key": k, "anthropic-version": "2023-06-01" }
+            : { "anthropic-version": "2023-06-01" },
+        chatFilter: isChatLike,
+    },
+    deepseek: {
+        label: "DeepSeek",
+        defaultBaseUrl: "https://api.deepseek.com/v1",
+        modelsPath: "/models",
+        protocol: "openai-compat",
+        authHeader: bearer,
+        chatFilter: isChatLike,
+    },
+    zai: {
+        label: "Z.AI (GLM)",
+        defaultBaseUrl: "https://api.z.ai/api/paas/v4",
+        modelsPath: "/models",
+        protocol: "openai-compat",
+        authHeader: bearer,
+        chatFilter: isChatLike,
+    },
+    xai: {
+        label: "xAI (Grok)",
+        defaultBaseUrl: "https://api.x.ai/v1",
+        modelsPath: "/models",
+        protocol: "openai-compat",
+        authHeader: bearer,
+        chatFilter: isChatLike,
+    },
+    mistral: {
+        label: "Mistral",
+        defaultBaseUrl: "https://api.mistral.ai/v1",
+        modelsPath: "/models",
+        protocol: "openai-compat",
+        authHeader: bearer,
+        chatFilter: isChatLike,
+    },
+    groq: {
+        label: "Groq",
+        defaultBaseUrl: "https://api.groq.com/openai/v1",
+        modelsPath: "/models",
+        protocol: "openai-compat",
+        authHeader: bearer,
+        chatFilter: isChatLike,
+    },
+    google: {
+        label: "Google Gemini",
+        // OpenAI-compat endpoint — chat completions go to `<baseUrl>/chat/completions`.
+        // For the model list we override the path to escape back to /v1beta/models,
+        // which is where the native (key=...) listing lives.
+        defaultBaseUrl: "https://generativelanguage.googleapis.com/v1beta/openai",
+        // Absolute URL — escape the /openai segment so /models hits the
+        // native listing endpoint (the OpenAI-compat /openai/models exists
+        // but returns a thinner response).
+        modelsPath: "https://generativelanguage.googleapis.com/v1beta/models",
+        protocol: "gemini",
+        authHeader: bearer,
+        authQuery: (k) => (k ? { key: k } : {}),
+        chatFilter: (id) => isChatLike(id) && /gemini/i.test(id),
+    },
+    openrouter: {
+        label: "OpenRouter",
+        defaultBaseUrl: "https://openrouter.ai/api/v1",
+        modelsPath: "/models",
+        protocol: "openai-compat",
+        authHeader: bearer,
+        chatFilter: isChatLike,
+    },
+    ollama: {
+        label: "Ollama (local)",
+        defaultBaseUrl: "http://localhost:11434",
+        modelsPath: "/api/tags",
+        protocol: "ollama",
+        authHeader: () => ({}),
+        chatFilter: isChatLike,
+    },
+    custom: {
+        label: "Custom",
+        defaultBaseUrl: "",
+        modelsPath: "/models",
+        protocol: "openai-compat",
+        authHeader: bearer,
+        chatFilter: isChatLike,
+    },
+};
+export function getKindMeta(kind) {
+    return PROVIDER_KINDS[kind] ?? PROVIDER_KINDS.custom;
+}

package/dist/llm/providers/anthropic.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Anthropic Claude provider using @anthropic-ai/sdk.
+ */
+import type { LLMConfig, LLMResponse } from "../../types.js";
+import type { CreateMessageOptions } from "../types.js";
+import { LLMClientBase } from "../client-base.js";
+export declare class AnthropicClient extends LLMClientBase {
+    private _client;
+    constructor(config: LLMConfig);
+    protected initClient(): void;
+    private get client();
+    createMessage(options: CreateMessageOptions): Promise<LLMResponse>;
+    private nonStreamMessage;
+    private streamMessage;
+    private processResponse;
+    private buildMessages;
+    private convertTools;
+    private handleApiError;
+}