@este.systems/dsc 1.1.1 → 1.2.0

package/dist/api.js

@@ -1,11 +1,41 @@
-export const API_URL = "https://api.deepseek.com/chat/completions";
-export const AVAILABLE_MODELS = ["deepseek-v4-pro", "deepseek-v4-flash"];
-export const DEFAULT_MODEL = "deepseek-v4-pro";
-// USD per token. v4-pro figures are discounted (valid through 2026-05-31), copied from godot-assistant.
-export const MODEL_RATES = {
-    "deepseek-v4-pro": { in_hit: 0.0034e-6, in_miss: 0.414e-6, out: 0.828e-6 },
-    "deepseek-v4-flash": { in_hit: 0.0028e-6, in_miss: 0.138e-6, out: 0.276e-6 },
+export const DEEPSEEK_API_URL = "https://api.deepseek.com/chat/completions";
+// Registry of every model dsc knows. The active model is the routing key: its
+// `provider` selects the transport, the API key, and the cost table. Adding a
+// provider is two steps — register its models here, and register the Provider
+// in PROVIDERS below. v4-pro figures are discounted (valid through 2026-05-31).
+export const MODEL_REGISTRY = {
+    "deepseek-v4-pro": {
+        id: "deepseek-v4-pro",
+        provider: "deepseek",
+        rates: { in_hit: 0.0034e-6, in_miss: 0.414e-6, out: 0.828e-6 },
+        contextWindow: 1_000_000,
+    },
+    "deepseek-v4-flash": {
+        id: "deepseek-v4-flash",
+        provider: "deepseek",
+        rates: { in_hit: 0.0028e-6, in_miss: 0.138e-6, out: 0.276e-6 },
+        contextWindow: 1_000_000,
+    },
+    // Anthropic. Pricing: $3/M input, $15/M output, $0.30/M cache read.
+    // Requires ANTHROPIC_API_KEY (env) or providers.anthropic.api_key (config).
+    "claude-sonnet-4-6": {
+        id: "claude-sonnet-4-6",
+        provider: "anthropic",
+        rates: { in_hit: 0.30e-6, in_miss: 3e-6, out: 15e-6 },
+        contextWindow: 200_000,
+        maxTokens: 8192,
+    },
 };
+export const DEFAULT_MODEL = "deepseek-v4-pro";
+/** Model ids dsc will offer. Phase 1 lists every registered model (all
+ *  DeepSeek today); provider-key availability filtering arrives with the
+ *  multi-provider config work. Order is registry insertion order. */
+export const AVAILABLE_MODELS = Object.keys(MODEL_REGISTRY);
+/** Resolve a model id to its spec, falling back to the default for unknown
+ *  ids (mirrors history.ts's load-time model guard). */
+export function modelSpec(model) {
+    return MODEL_REGISTRY[model] ?? MODEL_REGISTRY[DEFAULT_MODEL];
+}
 export class DeepSeekError extends Error {
     status;
     body;
@@ -201,6 +231,88 @@ export function apiKeySource() {
         return null;
     }
 }
+/** Per-provider key metadata for `/api-key` and onboarding messages. */
+export const PROVIDER_KEY_INFO = {
+    deepseek: {
+        label: "DeepSeek",
+        envVar: "DEEPSEEK_API_KEY",
+        signup: "https://platform.deepseek.com/api_keys",
+    },
+    anthropic: {
+        label: "Anthropic",
+        envVar: "ANTHROPIC_API_KEY",
+        signup: "https://console.anthropic.com/settings/keys",
+    },
+};
+/** Read a non-DeepSeek provider's key from `providers.<id>.api_key`. */
+function configProviderKey(provider) {
+    const cfg = getConfig();
+    const providers = cfg && typeof cfg.providers === "object" && cfg.providers
+        ? cfg.providers
+        : null;
+    const p = providers?.[provider];
+    const k = p && typeof p === "object" ? p.api_key : undefined;
+    return typeof k === "string" && k.length ? k : null;
+}
+/** Where a provider's key comes from, without revealing it. */
+export function providerKeySource(provider) {
+    // DeepSeek has the richer legacy reader (env var, top-level api_key, env block).
+    if (provider === "deepseek")
+        return apiKeySource();
+    const info = PROVIDER_KEY_INFO[provider];
+    if (info && process.env[info.envVar])
+        return "env";
+    try {
+        return configProviderKey(provider) ? "file" : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Save a provider's API key to the config file, preserving other fields.
+ * DeepSeek writes the top-level `api_key` (back-compat with getApiKey);
+ * every other provider writes `providers.<id>.api_key`.
+ */
+export async function saveProviderKey(provider, key) {
+    const trimmed = key.trim();
+    if (!trimmed)
+        throw new DeepSeekError("api key is empty");
+    if (provider === "deepseek")
+        return saveApiKey(trimmed);
+    const p = configPath();
+    await fsp.mkdir(nodePath.dirname(p), { recursive: true });
+    let existing = {};
+    try {
+        let txt = await fsp.readFile(p, "utf8");
+        if (txt.charCodeAt(0) === 0xfeff)
+            txt = txt.slice(1);
+        const parsed = JSON.parse(txt);
+        if (parsed && typeof parsed === "object")
+            existing = parsed;
+    }
+    catch {
+        // missing or unparseable — start fresh
+    }
+    const providers = existing.providers && typeof existing.providers === "object"
+        ? existing.providers
+        : {};
+    const sub = providers[provider] && typeof providers[provider] === "object"
+        ? providers[provider]
+        : {};
+    sub.api_key = trimmed;
+    providers[provider] = sub;
+    existing.providers = providers;
+    await fsp.writeFile(p, JSON.stringify(existing, null, 2), { encoding: "utf8", mode: 0o600 });
+    try {
+        await fsp.chmod(p, 0o600);
+    }
+    catch {
+        // POSIX-only; ignore on Windows
+    }
+    _cachedConfig = undefined;
+    return p;
+}
 /**
  * Merge `key` into the config file at `configPath()`, creating the file +
  * parent directory if needed. Preserves any other fields already in the
@@ -330,8 +442,389 @@ export async function saveSearchKey(provider, key) {
     _cachedConfig = undefined;
     return p;
 }
+function openAICompatProvider(o) {
+    return {
+        id: o.id,
+        resolveKey: o.resolveKey,
+        chat: (opts) => openAICompatChat(o.url, o.requireKey(), opts),
+        chatStream: (opts) => openAICompatStreamOnce(o.url, o.requireKey(), opts),
+    };
+}
+const deepseekProvider = openAICompatProvider({
+    id: "deepseek",
+    url: DEEPSEEK_API_URL,
+    resolveKey: () => {
+        try {
+            return getApiKey();
+        }
+        catch {
+            return null;
+        }
+    },
+    // getApiKey throws the existing "set DEEPSEEK_API_KEY / config" guidance.
+    requireKey: getApiKey,
+});
+// ---------------------------------------------------------------------------
+// Anthropic provider
+//
+// The Messages API differs from the OpenAI shape in several ways, so this
+// provider owns a translation layer in both directions:
+//   - system prompt is a top-level field, not a message
+//   - content is an array of blocks (text / tool_use / tool_result / thinking)
+//   - tool *calls* are assistant `tool_use` blocks; tool *results* go in a
+//     following user message as `tool_result` blocks (consecutive tool results
+//     coalesce into one user turn)
+//   - SSE is event-typed (message_start / content_block_delta / message_delta)
+//   - usage splits cached vs. fresh input tokens differently
+// The normalized request in / ChatResponse out matches every other provider,
+// so the agent loop never sees the difference.
+// ---------------------------------------------------------------------------
+export const ANTHROPIC_API_URL = "https://api.anthropic.com/v1/messages";
+const ANTHROPIC_VERSION = "2023-06-01";
+const ANTHROPIC_DEFAULT_MAX_TOKENS = 8192;
+function anthropicKey() {
+    const env = process.env.ANTHROPIC_API_KEY;
+    if (env)
+        return env;
+    return configProviderKey("anthropic");
+}
+function requireAnthropicKey() {
+    const k = anthropicKey();
+    if (!k) {
+        throw new DeepSeekError(`No Anthropic API key. Set ANTHROPIC_API_KEY, or add providers.anthropic.api_key to ${configPath()}.`);
+    }
+    return k;
+}
+/** Translate the normalized message list into Anthropic's (system, messages)
+ *  pair. Runs of `tool` messages coalesce into a single user turn of
+ *  `tool_result` blocks, which must follow the assistant `tool_use` turn. */
+export function toAnthropic(messages) {
+    let system;
+    const out = [];
+    let pendingResults = [];
+    const flush = () => {
+        if (pendingResults.length) {
+            out.push({ role: "user", content: pendingResults });
+            pendingResults = [];
+        }
+    };
+    for (const m of messages) {
+        if (m.role === "system") {
+            const text = typeof m.content === "string" ? m.content : "";
+            if (text)
+                system = system ? `${system}\n\n${text}` : text;
+            continue;
+        }
+        if (m.role === "tool") {
+            pendingResults.push({
+                type: "tool_result",
+                tool_use_id: m.tool_call_id ?? "",
+                content: typeof m.content === "string" ? m.content : "",
+            });
+            continue;
+        }
+        flush();
+        if (m.role === "user") {
+            out.push({ role: "user", content: typeof m.content === "string" ? m.content : "" });
+        }
+        else {
+            const blocks = [];
+            if (typeof m.content === "string" && m.content)
+                blocks.push({ type: "text", text: m.content });
+            for (const tc of m.tool_calls ?? []) {
+                let input = {};
+                try {
+                    input = JSON.parse(tc.function.arguments || "{}");
+                }
+                catch {
+                    input = {};
+                }
+                blocks.push({ type: "tool_use", id: tc.id, name: tc.function.name, input });
+            }
+            // Anthropic rejects empty assistant content; guard (shouldn't happen).
+            if (blocks.length === 0)
+                blocks.push({ type: "text", text: " " });
+            out.push({ role: "assistant", content: blocks });
+        }
+    }
+    flush();
+    return { system, messages: out };
+}
+export function toAnthropicTools(tools) {
+    if (!tools || !tools.length)
+        return undefined;
+    return tools.map((t) => ({
+        name: t.function.name,
+        description: t.function.description,
+        input_schema: t.function.parameters,
+    }));
+}
+export function mapAnthropicStop(s) {
+    if (s === "tool_use")
+        return "tool_calls";
+    if (s === "end_turn" || s === "stop_sequence")
+        return "stop";
+    if (s === "max_tokens")
+        return "length";
+    return s ?? undefined;
+}
+export function anthropicUsage(u) {
+    if (!u)
+        return undefined;
+    const input = u.input_tokens ?? 0;
+    const cacheRead = u.cache_read_input_tokens ?? 0;
+    const cacheCreate = u.cache_creation_input_tokens ?? 0;
+    const output = u.output_tokens ?? 0;
+    const prompt = input + cacheRead + cacheCreate;
+    return {
+        prompt_tokens: prompt,
+        completion_tokens: output,
+        total_tokens: prompt + output,
+        // Map cached reads to "hit"; fresh input + cache writes bill at "miss".
+        prompt_cache_hit_tokens: cacheRead,
+        prompt_cache_miss_tokens: input + cacheCreate,
+    };
+}
+function anthropicRequestBody(opts, spec, stream) {
+    const { system, messages } = toAnthropic(opts.messages);
+    const body = {
+        model: opts.model,
+        max_tokens: spec.maxTokens ?? ANTHROPIC_DEFAULT_MAX_TOKENS,
+        messages,
+        stream,
+    };
+    if (system)
+        body.system = system;
+    const tools = toAnthropicTools(opts.tools);
+    if (tools)
+        body.tools = tools;
+    return body;
+}
+function anthropicHeaders(apiKey, stream) {
+    const h = {
+        "content-type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": ANTHROPIC_VERSION,
+    };
+    if (stream)
+        h["accept"] = "text/event-stream";
+    return h;
+}
+async function anthropicChat(opts, spec) {
+    const apiKey = requireAnthropicKey();
+    const res = await fetch(ANTHROPIC_API_URL, {
+        method: "POST",
+        headers: anthropicHeaders(apiKey, false),
+        body: JSON.stringify(anthropicRequestBody(opts, spec, false)),
+        signal: opts.signal,
+    });
+    const text = await res.text();
+    if (!res.ok)
+        throw new DeepSeekError(`HTTP ${res.status}`, res.status, text);
+    let data;
+    try {
+        data = JSON.parse(text);
+    }
+    catch {
+        throw new DeepSeekError(`Invalid JSON response: ${text.slice(0, 200)}`);
+    }
+    const blocks = Array.isArray(data.content) ? data.content : [];
+    let content = "";
+    let reasoning = "";
+    const toolCalls = [];
+    for (const b of blocks) {
+        if (b.type === "text")
+            content += b.text ?? "";
+        else if (b.type === "thinking")
+            reasoning += b.thinking ?? "";
+        else if (b.type === "tool_use")
+            toolCalls.push({
+                id: b.id,
+                type: "function",
+                function: { name: b.name, arguments: JSON.stringify(b.input ?? {}) },
+            });
+    }
+    return {
+        choices: [
+            {
+                message: {
+                    role: "assistant",
+                    content: content || null,
+                    tool_calls: toolCalls.length ? toolCalls : undefined,
+                    reasoning_content: reasoning || undefined,
+                },
+                finish_reason: mapAnthropicStop(data.stop_reason),
+            },
+        ],
+        usage: anthropicUsage(data.usage),
+    };
+}
+async function anthropicStreamOnce(opts, spec) {
+    const apiKey = requireAnthropicKey();
+    const res = await fetch(ANTHROPIC_API_URL, {
+        method: "POST",
+        headers: anthropicHeaders(apiKey, true),
+        body: JSON.stringify(anthropicRequestBody(opts, spec, true)),
+        signal: opts.signal,
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new DeepSeekError(`HTTP ${res.status}`, res.status, text);
+    }
+    if (!res.body)
+        throw new DeepSeekError("No response body for stream");
+    let content = "";
+    let reasoning = "";
+    let stopReason;
+    const blocks = {};
+    let uInput = 0;
+    let uCacheRead = 0;
+    let uCacheCreate = 0;
+    let uOutput = 0;
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder("utf-8");
+    let buf = "";
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buf += decoder.decode(value, { stream: true });
+        let nl;
+        while ((nl = buf.indexOf("\n")) >= 0) {
+            const rawLine = buf.slice(0, nl).replace(/\r$/, "");
+            buf = buf.slice(nl + 1);
+            // Anthropic sends "event: <type>" + "data: <json>"; the type is also in
+            // the JSON payload, so we route on that and ignore the event: lines.
+            if (!rawLine || rawLine.startsWith(":") || !rawLine.startsWith("data:"))
+                continue;
+            const data = rawLine.slice(5).trim();
+            let evt;
+            try {
+                evt = JSON.parse(data);
+            }
+            catch {
+                continue;
+            }
+            switch (evt.type) {
+                case "message_start": {
+                    const u = evt.message?.usage;
+                    if (u) {
+                        uInput = u.input_tokens ?? 0;
+                        uCacheRead = u.cache_read_input_tokens ?? 0;
+                        uCacheCreate = u.cache_creation_input_tokens ?? 0;
+                    }
+                    break;
+                }
+                case "content_block_start": {
+                    const idx = evt.index ?? 0;
+                    const cb = evt.content_block ?? {};
+                    blocks[idx] = { type: cb.type, id: cb.id, name: cb.name, args: "" };
+                    break;
+                }
+                case "content_block_delta": {
+                    const idx = evt.index ?? 0;
+                    const d = evt.delta ?? {};
+                    if (d.type === "text_delta" && d.text) {
+                        content += d.text;
+                        opts.onContent?.(d.text);
+                    }
+                    else if (d.type === "thinking_delta" && d.thinking) {
+                        reasoning += d.thinking;
+                        opts.onReasoning?.(d.thinking);
+                    }
+                    else if (d.type === "input_json_delta" && typeof d.partial_json === "string") {
+                        if (blocks[idx])
+                            blocks[idx].args += d.partial_json;
+                    }
+                    break;
+                }
+                case "message_delta": {
+                    if (evt.delta?.stop_reason)
+                        stopReason = evt.delta.stop_reason;
+                    if (evt.usage?.output_tokens != null)
+                        uOutput = evt.usage.output_tokens;
+                    break;
+                }
+                // content_block_stop / message_stop / ping: nothing to accumulate.
+            }
+        }
+    }
+    const toolCalls = Object.keys(blocks)
+        .map(Number)
+        .sort((a, b) => a - b)
+        .map((i) => blocks[i])
+        .filter((b) => b.type === "tool_use")
+        .map((b, i) => ({
+        id: b.id ?? `call_${i}`,
+        type: "function",
+        function: { name: b.name ?? "", arguments: b.args || "{}" },
+    }));
+    return {
+        choices: [
+            {
+                message: {
+                    role: "assistant",
+                    content: content || null,
+                    tool_calls: toolCalls.length ? toolCalls : undefined,
+                    reasoning_content: reasoning || undefined,
+                },
+                finish_reason: mapAnthropicStop(stopReason),
+            },
+        ],
+        usage: anthropicUsage({
+            input_tokens: uInput,
+            cache_read_input_tokens: uCacheRead,
+            cache_creation_input_tokens: uCacheCreate,
+            output_tokens: uOutput,
+        }),
+    };
+}
+const anthropicProvider = {
+    id: "anthropic",
+    resolveKey: anthropicKey,
+    chat: anthropicChat,
+    chatStream: anthropicStreamOnce,
+};
+const PROVIDERS = {
+    deepseek: deepseekProvider,
+    anthropic: anthropicProvider,
+};
+/** Whether a model id is registered (regardless of key availability). Used by
+ *  the session loader so resuming a session keyed to any known model works. */
+export function isKnownModel(model) {
+    return model in MODEL_REGISTRY;
+}
+/** Whether a model can actually be used right now — its provider has a key.
+ *  The default provider (DeepSeek) is always considered available so the
+ *  first-launch "set your key" flow still surfaces a model to select. */
+export function modelAvailable(model) {
+    const spec = MODEL_REGISTRY[model];
+    if (!spec)
+        return false;
+    if (spec.provider === MODEL_REGISTRY[DEFAULT_MODEL].provider)
+        return true;
+    const p = PROVIDERS[spec.provider];
+    return !!p && p.resolveKey() !== null;
+}
+/** Model ids dsc will offer right now — registered AND usable (provider key
+ *  present, or the default provider). This is the list `/model` and `--help`
+ *  should show; `AVAILABLE_MODELS` remains the full registry for validation. */
+export function availableModels() {
+    return AVAILABLE_MODELS.filter(modelAvailable);
+}
+/** The Provider that serves a given model, via the registry. */
+export function providerFor(model) {
+    const spec = modelSpec(model);
+    const p = PROVIDERS[spec.provider];
+    if (!p) {
+        throw new DeepSeekError(`No provider registered for '${spec.provider}' (model '${model}')`);
+    }
+    return p;
+}
 export async function chat(opts) {
-    const apiKey = getApiKey();
+    return providerFor(opts.model).chat(opts, modelSpec(opts.model));
+}
+async function openAICompatChat(url, apiKey, opts) {
     const body = {
         model: opts.model,
         messages: opts.messages,
@@ -339,7 +832,7 @@ export async function chat(opts) {
     };
     if (opts.tools && opts.tools.length)
         body.tools = opts.tools;
-    const res = await fetch(API_URL, {
+    const res = await fetch(url, {
         method: "POST",
         headers: {
             "Content-Type": "application/json",
@@ -392,9 +885,11 @@ function sleep(ms, signal) {
     });
 }
 export async function chatStream(opts) {
+    const provider = providerFor(opts.model);
+    const spec = modelSpec(opts.model);
     for (let attempt = 1;; attempt++) {
         try {
-            return await streamOnce(opts);
+            return await provider.chatStream(opts, spec);
         }
         catch (e) {
             if (isAbortError(e))
@@ -410,8 +905,7 @@ export async function chatStream(opts) {
         }
     }
 }
-async function streamOnce(opts) {
-    const apiKey = getApiKey();
+async function openAICompatStreamOnce(url, apiKey, opts) {
     const body = {
         model: opts.model,
         messages: opts.messages,
@@ -420,7 +914,7 @@ async function streamOnce(opts) {
     };
     if (opts.tools && opts.tools.length)
         body.tools = opts.tools;
-    const res = await fetch(API_URL, {
+    const res = await fetch(url, {
         method: "POST",
         headers: {
             "Content-Type": "application/json",
@@ -551,7 +1045,7 @@ export function recordUsage(stats, usage) {
     stats.cache_miss_tokens += usage.prompt_cache_miss_tokens ?? 0;
 }
 export function computeCostUsd(stats, model) {
-    const rates = MODEL_RATES[model] ?? MODEL_RATES[DEFAULT_MODEL];
+    const rates = modelSpec(model).rates;
     const hit = stats.cache_hit_tokens;
     const miss = stats.cache_miss_tokens;
     const out = stats.completion_tokens;