clauderipple 0.2.0

package/dist/router/src/ingress/translate.js

@@ -0,0 +1,457 @@
+// OpenAI Responses / Chat Completions ⇄ Anthropic Messages. Pure functions, no I/O.
+//
+// The translation deliberately emits deterministic object/property ordering. Prompt caching is
+// controlled at the Anthropic side: system, final tool, and final user content carry the
+// ephemeral breakpoint requested by the ingress contract.
+import crypto from "node:crypto";
+// Anthropic requires max_tokens; OpenAI clients (Codex included) usually omit it. 16k is safe for every current Claude model.
+export const DEFAULT_MAX_TOKENS = 16384;
+const EPHEMERAL = { type: "ephemeral" };
+function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function string(value) {
+    return typeof value === "string" ? value : null;
+}
+function contentText(value) {
+    if (typeof value === "string")
+        return value;
+    if (!Array.isArray(value))
+        return "";
+    return value
+        .flatMap((part) => {
+        const p = object(part);
+        if (!p)
+            return [];
+        const type = string(p.type);
+        if (type === "input_text" || type === "output_text" || type === "text")
+            return [string(p.text) ?? ""];
+        if (type === "refusal")
+            return [string(p.refusal) ?? ""];
+        return [];
+    })
+        .join("\n");
+}
+function imageFromPart(part) {
+    const imageUrl = object(part.image_url);
+    const value = string(part.image_url) ?? string(imageUrl?.url) ?? string(part.url);
+    if (!value)
+        return null;
+    const data = /^data:([^;,]+);base64,(.*)$/s.exec(value);
+    if (data)
+        return { type: "image", source: { type: "base64", media_type: data[1], data: data[2] } };
+    return { type: "image", source: { type: "url", url: value } };
+}
+function messageContent(value) {
+    if (typeof value === "string")
+        return value ? [{ type: "text", text: value }] : [];
+    if (!Array.isArray(value))
+        return [];
+    const out = [];
+    for (const raw of value) {
+        const part = object(raw);
+        if (!part)
+            continue;
+        const type = string(part.type);
+        if (type === "input_text" || type === "output_text" || type === "text") {
+            const text = string(part.text);
+            if (text)
+                out.push({ type: "text", text });
+        }
+        else if (type === "input_image" || type === "image_url") {
+            const image = imageFromPart(part);
+            if (image)
+                out.push(image);
+        }
+    }
+    return out;
+}
+function parseArguments(value) {
+    if (typeof value !== "string" || value === "")
+        return {};
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return { _raw_arguments: value };
+    }
+}
+function normalizeSchema(value) {
+    const source = object(value);
+    const out = source ? structuredClone(source) : {};
+    if (out.type !== "object")
+        out.type = "object";
+    if (!object(out.properties))
+        out.properties = {};
+    return out;
+}
+function mapTools(value) {
+    if (!Array.isArray(value))
+        return [];
+    const tools = value.flatMap((raw) => {
+        const tool = object(raw);
+        if (!tool || string(tool.type) !== "function")
+            return [];
+        // Responses uses function fields directly; Chat Completions nests them under `function`.
+        const fn = object(tool.function) ?? tool;
+        const name = string(fn.name);
+        if (!name)
+            return [];
+        const description = string(fn.description);
+        return [{ name, ...(description ? { description } : {}), input_schema: normalizeSchema(fn.parameters) }];
+    });
+    if (tools.length)
+        tools[tools.length - 1].cache_control = EPHEMERAL;
+    return tools;
+}
+function mapToolChoice(value) {
+    if (value === "auto")
+        return { type: "auto" };
+    if (value === "required")
+        return { type: "any" };
+    if (value === "none")
+        return { type: "none" };
+    const choice = object(value);
+    if (choice?.type === "function" && typeof choice.name === "string")
+        return { type: "tool", name: choice.name };
+    return undefined;
+}
+function applyMessageCache(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        if (message.role !== "user")
+            continue;
+        const last = message.content.at(-1);
+        if (last?.type === "text")
+            last.cache_control = EPHEMERAL;
+        else if (last)
+            last.cache_control = EPHEMERAL;
+        else
+            message.content.push({ type: "text", text: "", cache_control: EPHEMERAL });
+        return;
+    }
+}
+function responseItems(value) {
+    if (typeof value === "string")
+        return value ? [{ role: "user", content: [{ type: "text", text: value }] }] : [];
+    if (!Array.isArray(value))
+        return [];
+    const messages = [];
+    for (const raw of value) {
+        const item = object(raw);
+        if (!item)
+            continue;
+        const type = string(item.type);
+        if (type === "reasoning")
+            continue;
+        if (type === "function_call") {
+            const callId = string(item.call_id) ?? string(item.id) ?? `call_${crypto.randomUUID().replaceAll("-", "")}`;
+            messages.push({ role: "assistant", content: [{ type: "tool_use", id: callId, name: string(item.name) ?? "tool", input: parseArguments(item.arguments) }] });
+            continue;
+        }
+        if (type === "function_call_output") {
+            const callId = string(item.call_id) ?? "";
+            if (callId)
+                messages.push({ role: "user", content: [{ type: "tool_result", tool_use_id: callId, content: contentText(item.output) }] });
+            continue;
+        }
+        if (type !== "message")
+            continue;
+        const role = item.role === "assistant" ? "assistant" : "user";
+        const content = messageContent(item.content);
+        if (content.length)
+            messages.push({ role, content });
+    }
+    return messages;
+}
+export function effortFromRequest(value) {
+    const reasoning = object(value);
+    const effort = reasoning && string(reasoning.effort);
+    return effort ?? undefined;
+}
+/** Convert an OpenAI Responses request to a cache-friendly Anthropic Messages request. */
+/** Claude models that accept `output_config.effort` (measured 2026-09-13: Haiku 4.5 answers 400 "does not support the effort parameter"). */
+export function claudeSupportsEffort(model) {
+    return /^claude-(opus|sonnet|fable)-(4-[6-9]|5)(-|$)/.test(model);
+}
+/**
+ * With a borrowed Claude Code login, Anthropic accepts the request only when the system prompt is
+ * Claude Code's own (measured 2026-09-13: any other long system text → 429 "rate_limit_error: Error",
+ * even though a tiny request passes). So in that mode `system` carries just the identity line and
+ * the client's instructions travel as the first user block, tagged so the model reads them as
+ * operator instructions. The block is cache-marked, so the prefix still caches.
+ */
+function placeInstructions(prefix, instructions, messages) {
+    const text = instructions.filter((t) => t.length > 0).join("\n\n");
+    if (prefix) {
+        if (text) {
+            const block = { type: "text", text: `<operator_instructions>\n${text}\n</operator_instructions>`, cache_control: EPHEMERAL };
+            const first = messages.find((m) => m.role === "user");
+            if (first && Array.isArray(first.content))
+                first.content.unshift(block);
+            else
+                messages.unshift({ role: "user", content: [block] });
+        }
+        return [{ type: "text", text: prefix, cache_control: EPHEMERAL }];
+    }
+    return text ? [{ type: "text", text, cache_control: EPHEMERAL }] : undefined;
+}
+export function responsesToAnthropic(body, targetModel, systemPrefix) {
+    const instructions = string(body.instructions);
+    const messages = responseItems(body.input);
+    const system = placeInstructions(systemPrefix, instructions ? [instructions] : [], messages);
+    applyMessageCache(messages);
+    const tools = mapTools(body.tools);
+    const maxTokens = typeof body.max_output_tokens === "number" && Number.isFinite(body.max_output_tokens) ? Math.max(1, Math.floor(body.max_output_tokens)) : undefined;
+    const temperature = typeof body.temperature === "number" && Number.isFinite(body.temperature) ? body.temperature : undefined;
+    const effort = effortFromRequest(body.reasoning);
+    const toolChoice = mapToolChoice(body.tool_choice);
+    return {
+        model: targetModel,
+        ...(system ? { system } : {}),
+        messages,
+        ...(tools.length ? { tools } : {}),
+        ...(toolChoice ? { tool_choice: toolChoice } : {}),
+        max_tokens: maxTokens ?? DEFAULT_MAX_TOKENS,
+        ...(temperature !== undefined ? { temperature } : {}),
+        ...(effort && claudeSupportsEffort(targetModel) ? { output_config: { effort } } : {}),
+        stream: body.stream === true,
+    };
+}
+function chatMessageToAnthropic(raw) {
+    const message = object(raw);
+    if (!message)
+        return [];
+    const role = string(message.role);
+    if (role === "system" || role === "developer") {
+        const text = contentText(message.content);
+        return text ? [{ role: "user", content: [{ type: "text", text: `[${role}]\n${text}` }] }] : [];
+    }
+    if (role === "tool") {
+        const id = string(message.tool_call_id);
+        return id ? [{ role: "user", content: [{ type: "tool_result", tool_use_id: id, content: contentText(message.content) }] }] : [];
+    }
+    const mappedRole = role === "assistant" ? "assistant" : "user";
+    const content = messageContent(message.content);
+    const calls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+    for (const rawCall of calls) {
+        const call = object(rawCall);
+        const fn = call && object(call.function);
+        const id = call && string(call.id);
+        const name = fn && string(fn.name);
+        if (id && name)
+            content.push({ type: "tool_use", id, name, input: parseArguments(fn.arguments) });
+    }
+    return content.length ? [{ role: mappedRole, content }] : [];
+}
+/** Convert OpenAI Chat Completions request to an Anthropic Messages request. */
+export function chatToAnthropic(body, targetModel, systemPrefix) {
+    const rawMessages = Array.isArray(body.messages) ? body.messages : [];
+    const systems = [];
+    const messages = [];
+    for (const raw of rawMessages) {
+        const message = object(raw);
+        const role = message && string(message.role);
+        if (role === "system" || role === "developer") {
+            const text = message ? contentText(message.content) : "";
+            if (text)
+                systems.push(text);
+            continue;
+        }
+        messages.push(...chatMessageToAnthropic(raw));
+    }
+    const system = placeInstructions(systemPrefix, systems, messages);
+    applyMessageCache(messages);
+    const tools = mapTools(body.tools);
+    const maxTokensValue = body.max_completion_tokens ?? body.max_tokens;
+    const maxTokens = typeof maxTokensValue === "number" && Number.isFinite(maxTokensValue) ? Math.max(1, Math.floor(maxTokensValue)) : undefined;
+    const temperature = typeof body.temperature === "number" && Number.isFinite(body.temperature) ? body.temperature : undefined;
+    const toolChoice = mapToolChoice(body.tool_choice);
+    return {
+        model: targetModel,
+        ...(system ? { system } : {}),
+        messages,
+        ...(tools.length ? { tools } : {}),
+        ...(toolChoice ? { tool_choice: toolChoice } : {}),
+        max_tokens: maxTokens ?? DEFAULT_MAX_TOKENS,
+        ...(temperature !== undefined ? { temperature } : {}),
+        stream: body.stream === true,
+    };
+}
+function usageFromAnthropic(value) {
+    const usage = object(value);
+    const input = typeof usage?.input_tokens === "number" ? usage.input_tokens : 0;
+    const cached = typeof usage?.cache_read_input_tokens === "number" ? usage.cache_read_input_tokens : 0;
+    const output = typeof usage?.output_tokens === "number" ? usage.output_tokens : 0;
+    return { input_tokens: input + cached, input_tokens_details: { cached_tokens: cached }, output_tokens: output, total_tokens: input + cached + output };
+}
+function id(prefix) {
+    return `${prefix}_${crypto.randomBytes(12).toString("hex")}`;
+}
+/** Stateful Anthropic Messages SSE → OpenAI Responses event mapper. */
+export class ResponsesEventMapper {
+    responseId = id("resp");
+    created = Math.floor(Date.now() / 1000);
+    model;
+    output = [];
+    usage = { input_tokens: 0, input_tokens_details: { cached_tokens: 0 }, output_tokens: 0, total_tokens: 0 };
+    blocks = new Map();
+    emittedCreated = false;
+    completed = false;
+    outputIndex = 0;
+    toolNameFromWire;
+    constructor(model, toolNameFromWire = (name) => name) {
+        this.model = model;
+        this.toolNameFromWire = toolNameFromWire;
+    }
+    response(status = "in_progress") {
+        return { id: this.responseId, object: "response", created_at: this.created, status, model: this.model, output: this.output, usage: this.usage };
+    }
+    start() {
+        if (this.emittedCreated)
+            return [];
+        this.emittedCreated = true;
+        return [{ type: "response.created", response: this.response() }];
+    }
+    feed(event) {
+        const out = this.start();
+        const type = string(event.type) ?? "";
+        if (type === "message_start") {
+            const message = object(event.message);
+            this.usage = usageFromAnthropic(message?.usage);
+            return out;
+        }
+        if (type === "content_block_start") {
+            const index = typeof event.index === "number" ? event.index : -1;
+            const block = object(event.content_block);
+            if (index < 0 || !block)
+                return out;
+            const blockType = string(block.type);
+            if (blockType === "text") {
+                const item = { id: id("msg"), type: "message", role: "assistant", status: "in_progress", content: [] };
+                this.output.push(item);
+                this.blocks.set(index, { kind: "text", item, arguments: "" });
+                out.push({ type: "response.output_item.added", output_index: this.outputIndex++, item });
+            }
+            else if (blockType === "tool_use") {
+                const callId = string(block.id) ?? id("call");
+                const item = { id: id("fc"), type: "function_call", call_id: callId, name: this.toolNameFromWire(string(block.name) ?? "tool"), arguments: "", status: "in_progress" };
+                this.output.push(item);
+                this.blocks.set(index, { kind: "tool", item, arguments: "" });
+                out.push({ type: "response.output_item.added", output_index: this.outputIndex++, item });
+            }
+            return out;
+        }
+        if (type === "content_block_delta") {
+            const index = typeof event.index === "number" ? event.index : -1;
+            const state = this.blocks.get(index);
+            const delta = object(event.delta);
+            const deltaType = string(delta?.type);
+            if (!state || !delta)
+                return out;
+            if (state.kind === "text" && deltaType === "text_delta") {
+                const text = string(delta.text) ?? "";
+                const content = state.item.content;
+                if (content.length === 0)
+                    content.push({ type: "output_text", text: "", annotations: [] });
+                const piece = content[0];
+                piece.text = `${string(piece.text) ?? ""}${text}`;
+                out.push({ type: "response.output_text.delta", item_id: state.item.id, output_index: this.output.indexOf(state.item), content_index: 0, delta: text });
+            }
+            else if (state.kind === "tool" && deltaType === "input_json_delta") {
+                const text = string(delta.partial_json) ?? "";
+                state.arguments += text;
+                state.item.arguments = state.arguments;
+                out.push({ type: "response.function_call_arguments.delta", item_id: state.item.id, output_index: this.output.indexOf(state.item), delta: text });
+            }
+            return out;
+        }
+        if (type === "content_block_stop") {
+            const index = typeof event.index === "number" ? event.index : -1;
+            const state = this.blocks.get(index);
+            if (!state)
+                return out;
+            if (state.kind === "tool")
+                out.push({ type: "response.function_call_arguments.done", item_id: state.item.id, output_index: this.output.indexOf(state.item), arguments: state.arguments });
+            state.item.status = "completed";
+            out.push({ type: "response.output_item.done", output_index: this.output.indexOf(state.item), item: state.item });
+            this.blocks.delete(index);
+            return out;
+        }
+        if (type === "message_delta") {
+            this.usage = usageFromAnthropic(event.usage);
+            return out;
+        }
+        if (type === "message_stop")
+            return [...out, ...this.finish()];
+        if (type === "error") {
+            const error = object(event.error);
+            return [...out, { type: "error", error: { message: string(error?.message) ?? "Anthropic upstream error", type: string(error?.type) ?? "api_error", code: null } }];
+        }
+        return out;
+    }
+    finish() {
+        if (this.completed)
+            return [];
+        this.completed = true;
+        for (const state of this.blocks.values()) {
+            state.item.status = "completed";
+        }
+        this.blocks.clear();
+        return [{ type: "response.completed", response: this.response("completed") }];
+    }
+}
+function firstText(item) {
+    const content = item.content;
+    if (!Array.isArray(content))
+        return null;
+    return content
+        .filter((part) => object(part)?.type === "output_text")
+        .map((part) => string(object(part)?.text) ?? "")
+        .join("") || null;
+}
+export function responsesToChatCompletion(mapper) {
+    const toolCalls = mapper.output
+        .filter((item) => item.type === "function_call")
+        .map((item, index) => ({ id: string(item.call_id) ?? item.id, type: "function", function: { name: string(item.name) ?? "tool", arguments: string(item.arguments) ?? "" }, index }));
+    const text = mapper.output.filter((item) => item.type === "message").map(firstText).filter((x) => x !== null).join("");
+    return {
+        id: `chatcmpl_${mapper.responseId.slice(5)}`,
+        object: "chat.completion",
+        created: mapper.created,
+        model: mapper.model,
+        choices: [{ index: 0, message: { role: "assistant", content: text || null, ...(toolCalls.length ? { tool_calls: toolCalls.map(({ index: _index, ...call }) => call) } : {}) }, finish_reason: toolCalls.length ? "tool_calls" : "stop" }],
+        usage: { prompt_tokens: mapper.usage.input_tokens, prompt_tokens_details: mapper.usage.input_tokens_details, completion_tokens: mapper.usage.output_tokens, total_tokens: mapper.usage.total_tokens },
+    };
+}
+/** Convert Responses mapper events to OpenAI Chat Completions streaming chunks. */
+export function responsesEventsToChatChunks(events, mapper) {
+    const chunks = [];
+    const chatId = `chatcmpl_${mapper.responseId.slice(5)}`;
+    for (const event of events) {
+        const type = string(event.type);
+        const base = { id: chatId, object: "chat.completion.chunk", created: mapper.created, model: mapper.model };
+        if (type === "response.created")
+            chunks.push({ ...base, choices: [{ index: 0, delta: { role: "assistant" }, finish_reason: null }] });
+        else if (type === "response.output_text.delta")
+            chunks.push({ ...base, choices: [{ index: 0, delta: { content: string(event.delta) ?? "" }, finish_reason: null }] });
+        else if (type === "response.output_item.added") {
+            const item = object(event.item);
+            if (item?.type === "function_call")
+                chunks.push({ ...base, choices: [{ index: 0, delta: { tool_calls: [{ index: 0, id: string(item.call_id) ?? string(item.id), type: "function", function: { name: string(item.name) ?? "tool", arguments: "" } }] }, finish_reason: null }] });
+        }
+        else if (type === "response.function_call_arguments.delta")
+            chunks.push({ ...base, choices: [{ index: 0, delta: { tool_calls: [{ index: 0, function: { arguments: string(event.delta) ?? "" } }] }, finish_reason: null }] });
+        else if (type === "response.completed") {
+            const hasTools = mapper.output.some((item) => item.type === "function_call");
+            chunks.push({ ...base, choices: [{ index: 0, delta: {}, finish_reason: hasTools ? "tool_calls" : "stop" }], usage: { prompt_tokens: mapper.usage.input_tokens, prompt_tokens_details: mapper.usage.input_tokens_details, completion_tokens: mapper.usage.output_tokens, total_tokens: mapper.usage.total_tokens } });
+        }
+    }
+    return chunks;
+}
+export function formatSse(event) {
+    return `event: ${string(event.type) ?? "message"}\ndata: ${JSON.stringify(event)}\n\n`;
+}
+export function formatDataSse(event) {
+    return `data: ${JSON.stringify(event)}\n\n`;
+}

package/dist/router/src/log.js

@@ -0,0 +1,81 @@
+// Append-only log file with size-based rotation. Never logs request bodies or headers.
+import fs from "node:fs";
+import path from "node:path";
+export class Logger {
+    fd = null;
+    bytes = 0;
+    writesSinceCheck = 0;
+    file;
+    maxBytes;
+    keep;
+    echo;
+    constructor(file, maxBytes, keep, echo) {
+        this.file = file;
+        this.maxBytes = maxBytes;
+        this.keep = keep;
+        this.echo = echo;
+        if (file) {
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+            this.open();
+        }
+    }
+    open() {
+        if (!this.file)
+            return;
+        this.fd = fs.openSync(this.file, "a");
+        try {
+            this.bytes = fs.fstatSync(this.fd).size;
+        }
+        catch {
+            this.bytes = 0;
+        }
+    }
+    rotate() {
+        if (!this.file || this.fd === null)
+            return;
+        fs.closeSync(this.fd);
+        this.fd = null;
+        for (let i = this.keep - 1; i >= 1; i--) {
+            const from = `${this.file}.${i}`;
+            const to = `${this.file}.${i + 1}`;
+            if (fs.existsSync(from))
+                fs.renameSync(from, to);
+        }
+        if (this.keep >= 1)
+            fs.renameSync(this.file, `${this.file}.1`);
+        else
+            fs.unlinkSync(this.file);
+        this.open();
+    }
+    line(level, msg) {
+        const d = new Date();
+        const p = (n) => String(n).padStart(2, "0");
+        const ts = `${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`; // local time, like the app's own logs
+        const out = `${ts} ${level === "info" ? "" : level.toUpperCase() + " "}${msg}\n`;
+        if (this.echo || this.fd === null)
+            process.stdout.write(out);
+        if (this.fd !== null) {
+            try {
+                fs.writeSync(this.fd, out);
+                this.bytes += Buffer.byteLength(out);
+                if (++this.writesSinceCheck >= 50) {
+                    this.writesSinceCheck = 0;
+                    if (this.bytes >= this.maxBytes)
+                        this.rotate();
+                }
+            }
+            catch {
+                /* logging must never take the router down */
+            }
+        }
+    }
+    info(msg) {
+        this.line("info", msg);
+    }
+    warn(msg) {
+        this.line("warn", msg);
+    }
+    error(msg) {
+        this.line("error", msg);
+    }
+}

package/dist/router/src/picker.js

@@ -0,0 +1,74 @@
+// Picker mode: put real model names into the Claude Desktop model picker.
+//
+// The picker list comes from claude.ai's bootstrap response (`model_selector_config`, an
+// array of surfaces, each with `models[]`). The renderer forwards the chosen id to the app,
+// which passes it to the CLI unchecked (docs/ARCHITECTURE.md §3). So when the app's own
+// traffic goes through ClaudeRipple, we add our entries to the Code surface here.
+//
+// We do not know every field of a model entry, so we clone an existing enabled Claude
+// entry as a template and override the identifying fields. Surfaces are matched by id
+// heuristically (anything that is not the claude.ai chat surface); the ids we saw are
+// logged once so the heuristic can be tightened.
+export const BOOTSTRAP_PATHS = ["/edge-api/bootstrap", "/api/bootstrap"];
+export function isBootstrapPath(path) {
+    return BOOTSTRAP_PATHS.some((p) => path === p || path.startsWith(p + "/") || path.startsWith(p + "?"));
+}
+// Surfaces whose sessions run through the Claude Code CLI (and therefore through the router).
+// Measured 2026-09-13: app_start had chat, code, ccr, ccd, cowork, design, office_agent, chrome, voice,
+// claude_science; the Code tab list matched code/ccd/ccr (9 entries). Chat & co. never reach the CLI.
+const CLI_SURFACES = new Set(["code", "ccd", "ccr", "cowork"]);
+function isClaudeEntry(m) {
+    return typeof m.id === "string" && m.id.startsWith("claude-");
+}
+function pickTemplate(models) {
+    return models.find((m) => isClaudeEntry(m) && !m.disabled && m.section !== "deprecated" && m.section !== "legacy") ?? models.find(isClaudeEntry) ?? null;
+}
+/** Mutates `json` in place; returns what was done for logging. */
+export function injectPickerModels(json, extra, contextWindow) {
+    const result = { injected: 0, surfaces: [] };
+    const msc = json.model_selector_config;
+    if (!Array.isArray(msc) || extra.length === 0)
+        return result;
+    for (const surface of msc) {
+        if (!surface || typeof surface !== "object" || !Array.isArray(surface.models))
+            continue;
+        const id = String(surface.id ?? "");
+        result.surfaces.push({
+            id,
+            models: surface.models.map((m) => String(m.id ?? "?")),
+            entries: surface.models.map((m) => ({ id: String(m.id ?? "?"), name: typeof m.name === "string" ? m.name : String(m.id ?? "?") })),
+        });
+        if (!CLI_SURFACES.has(id))
+            continue;
+        const template = pickTemplate(surface.models);
+        if (!template)
+            continue;
+        const existing = new Set(surface.models.map((m) => m.id));
+        for (const e of extra) {
+            if (existing.has(e.model))
+                continue;
+            const entry = { ...structuredClone(template), id: e.model, name: e.name };
+            if (e.description)
+                entry.description = e.description;
+            else
+                delete entry.description;
+            for (const k of ["disabled", "disabled_reason", "notice", "selection_notice", "badge", "badge_tooltip", "tooltip", "minimum_tier", "is_default"])
+                delete entry[k];
+            entry.section = "main";
+            surface.models.push(entry);
+            result.injected++;
+        }
+        if (contextWindow) {
+            for (const key of ["context_window_by_model", "contextWindowByModel"]) {
+                const map = surface[key];
+                if (map && typeof map === "object")
+                    for (const e of extra)
+                        map[e.model] = contextWindow;
+            }
+        }
+        const recorded = result.surfaces[result.surfaces.length - 1];
+        recorded.models = surface.models.map((m) => String(m.id ?? "?"));
+        recorded.entries = surface.models.map((m) => ({ id: String(m.id ?? "?"), name: typeof m.name === "string" ? m.name : String(m.id ?? "?") }));
+    }
+    return result;
+}