@zenithfoundry/slm-gate 1.2.1

package/dist/ledger/wipe-langfuse.js

@@ -0,0 +1,130 @@
+/**
+ * @fileoverview Deletes slm-gate's own traces from the configured Langfuse project.
+ *
+ * Other programs may write to the same project, so only traces tagged SLM_GATE_SOURCE_TAG
+ * are deleted, and only the score configs the gate registers are archived — never the whole
+ * project. Traces written before the tag existed are not matched: `pnpm run ledger:sync`
+ * resends them with it.
+ *
+ * Deleting a trace also deletes its scores and observations (Langfuse's data-deletion docs),
+ * so scores are never deleted on their own. The previous script deleted every score first
+ * and every trace second; a rate limit between the two passes left the project half wiped.
+ *
+ * Resumable by construction: each run lists the tagged traces still present, so a run
+ * stopped by a quota is continued by running it again after the reset time it prints.
+ *
+ * Usage:
+ *   pnpm run langfuse:wipe [--dry-run]
+ */
+import { setTimeout } from 'node:timers/promises';
+import { CONFIG, requireKeys } from '../config.js';
+import { waitWithBackoff } from '../utils/backoff.js';
+import { SLM_GATE_SOURCE_TAG } from './index.js';
+import { SCORE_CONFIGS } from './sync-config.js';
+/** Hobby projects allow 30 requests a minute; one every 2.1 s stays under it. */
+const REQUEST_SPACING_MS = 2100;
+const MAX_RETRIES = 3;
+/** A 429 asking to wait longer than this is a quota (e.g. daily deletes), not a burst: stop and report. */
+const MAX_RETRY_WAIT_S = 120;
+const DELETE_CHUNK = 100;
+/** Seconds a 429/5xx asks us to wait, from the Retry-After header or Langfuse's error body. */
+async function retryAfterSeconds(res) {
+    const header = Number(res.headers.get('retry-after'));
+    if (Number.isFinite(header) && header > 0)
+        return header;
+    const body = await res.clone().json().catch(() => null);
+    return typeof body?.details?.retryAfterSeconds === 'number' ? body.details.retryAfterSeconds : null;
+}
+/** One paced request, retried on 429 and 5xx unless the wait asked for is a quota reset. */
+async function send(params) {
+    const baseUrl = CONFIG.LANGFUSE_HOST.replace(/\/$/, '');
+    const auth = `Basic ${Buffer.from(`${CONFIG.LANGFUSE_PUBLIC_KEY}:${CONFIG.LANGFUSE_SECRET_KEY}`).toString('base64')}`;
+    for (let attempt = 0;; attempt++) {
+        await setTimeout(REQUEST_SPACING_MS);
+        const res = await fetch(`${baseUrl}${params.path}`, {
+            ...params.init,
+            headers: { Authorization: auth, 'Content-Type': 'application/json' },
+        });
+        const transient = res.status === 429 || res.status >= 500;
+        if (!transient || attempt >= MAX_RETRIES - 1)
+            return res;
+        const wait = await retryAfterSeconds(res);
+        if (wait !== null && wait > MAX_RETRY_WAIT_S)
+            return res;
+        await waitWithBackoff(attempt, MAX_RETRIES, `${params.label}: HTTP ${res.status}`, wait === null ? null : String(wait), 'wipe');
+    }
+}
+/** Throws with the status and body, so a failed request stops the run instead of being skipped. */
+async function failure(res, label) {
+    const text = await res.text().catch(() => '');
+    if (res.status !== 429)
+        return new Error(`${label} failed (${res.status}): ${text.slice(0, 300)}`);
+    let details = {};
+    try {
+        details = JSON.parse(text).details ?? {};
+    }
+    catch { /* not JSON */ }
+    const resetAt = details.resetAt ? new Date(details.resetAt).toLocaleString() : 'unknown';
+    return new Error(`${label} was rate limited (remaining ${details.remaining ?? '?'} / ${details.limit ?? '?'}). ` +
+        `Quota resets at ${resetAt}. Run this command again after that to continue.`);
+}
+/** Every item of a paginated Langfuse list. */
+async function listAll(params) {
+    const items = [];
+    for (let page = 1;; page++) {
+        const res = await send({ path: `${params.path}${params.path.includes('?') ? '&' : '?'}page=${page}&limit=100`, label: params.label });
+        if (!res.ok)
+            throw await failure(res, params.label);
+        const body = await res.json();
+        items.push(...(body.data ?? []));
+        if ((body.data ?? []).length === 0 || page >= (body.meta?.totalPages ?? 1))
+            return items;
+    }
+}
+async function wipeLangfuse(options) {
+    requireKeys(['LANGFUSE_PUBLIC_KEY', 'LANGFUSE_SECRET_KEY', 'LANGFUSE_HOST']);
+    console.log('=== SLM Gate: delete the gate\'s traces from Langfuse ===\n');
+    console.log(`Target host : ${CONFIG.LANGFUSE_HOST}`);
+    console.log(`Matching    : traces tagged ${SLM_GATE_SOURCE_TAG}; other writers' traces are left alone`);
+    console.log(`Mode        : ${options.dryRun ? 'DRY-RUN (nothing is deleted)' : 'DELETE'}\n`);
+    // The trace list is Langfuse's only way to find traces by tag. It is deprecated on Cloud
+    // (removal 2026-11-16) and lags live data by about 10 minutes, so traces written in the
+    // last few minutes may need a second run.
+    const traces = await listAll({
+        path: `/api/public/traces?tags=${encodeURIComponent(SLM_GATE_SOURCE_TAG)}`,
+        label: 'list gate traces',
+    });
+    const traceIds = traces.map(t => t.id);
+    console.log(`Found ${traceIds.length} gate trace(s). Their scores and observations are deleted with them.`);
+    const gateConfigNames = new Set(SCORE_CONFIGS.map(c => c.name));
+    const configs = (await listAll({ path: '/api/public/score-configs', label: 'list score configs' }))
+        .filter(c => gateConfigNames.has(c.name) && !c.isArchived);
+    console.log(`Found ${configs.length} active gate score config(s) to archive.\n`);
+    if (options.dryRun) {
+        console.log('Dry run: nothing was deleted.');
+        return;
+    }
+    let deleted = 0;
+    for (let i = 0; i < traceIds.length; i += DELETE_CHUNK) {
+        const chunk = traceIds.slice(i, i + DELETE_CHUNK);
+        const res = await send({ path: '/api/public/traces', init: { method: 'DELETE', body: JSON.stringify({ traceIds: chunk }) }, label: 'delete traces' });
+        if (!res.ok) {
+            console.error(`\nDeleted ${deleted} of ${traceIds.length} trace(s) before stopping.`);
+            throw await failure(res, 'delete traces');
+        }
+        deleted += chunk.length;
+        console.log(`  Deleted ${deleted} / ${traceIds.length}`);
+    }
+    for (const config of configs) {
+        const res = await send({ path: `/api/public/score-configs/${config.id}`, init: { method: 'PATCH', body: JSON.stringify({ isArchived: true }) }, label: `archive score config ${config.name}` });
+        if (!res.ok)
+            throw await failure(res, `archive score config ${config.name}`);
+        console.log(`  Archived score config ${config.name}`);
+    }
+    console.log(`\n✓ Deleted ${deleted} gate trace(s) and archived ${configs.length} gate score config(s).`);
+    console.log('Langfuse can take ~10 minutes to stop listing deleted traces; check with `pnpm run ledger:verify`.');
+}
+wipeLangfuse({ dryRun: process.argv.includes('--dry-run') }).catch((err) => {
+    console.error('\n⛔', err instanceof Error ? err.message : err);
+    process.exit(1);
+});

package/dist/llm-gate/distill.js

@@ -0,0 +1,239 @@
+/**
+ * @fileoverview Step B of the model gate: distil the large command, search and listing tool results of
+ * one request before it leaves the machine, and change nothing else.
+ *
+ * Byte stability is the point. Coding tools resend the whole history every turn, providers cache that
+ * history, and Anthropic rejects a request whose earlier messages differ from what produced earlier
+ * thinking. So each tool result is decided once per conversation — distilled text or original — and
+ * that decision is resent from then on:
+ *  - Only results the provider has never seen (the newest turn) are ever distilled. A history result
+ *    with no stored decision was necessarily sent as the original, so it stays the original.
+ *  - Distilled text is sent only after its decision is stored. If storing fails the original is sent,
+ *    so "no stored decision" can only ever mean "the original was sent".
+ *  - Past the time budget, or on any error, the original is the decision.
+ *  - The decision key holds only what cannot change within a conversation (see decisionKey).
+ * File reads are never distilled because edits need their exact text; that includes shell commands
+ * that read files, which is how Codex reads them.
+ */
+import crypto from 'node:crypto';
+import { CONFIG } from '../config.js';
+import { getDistillDecision, recordDistillDecision } from '../ledger/index.js';
+import { compressNarrativeRun } from '../models/reasoning.js';
+import { SLM } from '../models/slm.js';
+import { distillToolResult, estimateTokens, rewriteElisionHint } from '../utils/elision.js';
+import { buildPreserveList } from '../utils/preserve-patterns.js';
+// Lowercased function names of the tools whose output is distilled. Anything else — file reads, web
+// fetches, sub-agents, MCP tools, edits — passes unchanged.
+const KIND_BY_TOOL = new Map([
+    ...['bash', 'run_shell_command', 'shell', 'exec_command', 'local_shell', 'execute_command', 'run_command'].map(name => [name, 'command']),
+    ...['grep', 'grep_search', 'search_file_content', 'search_files'].map(name => [name, 'search']),
+    ...['glob', 'list_directory', 'ls', 'list_files', 'list_dir', 'list'].map(name => [name, 'listing']),
+]);
+// distillToolResult picks its rules by a substring of the tool name: these fire the log rule (errors
+// with context plus the last 50 lines) and the top-50-lines rule. The real name follows a colon.
+const ENGINE_RULE = { command: 'run_command', search: 'grep_search', listing: 'list_dir' };
+const FILE_READERS = new Set(['cat', 'bat', 'less', 'more', 'head', 'tail', 'nl']);
+// Words that run the program after them.
+const COMMAND_PREFIXES = new Set(['env', 'sudo', 'command', 'exec', 'time', 'nice', 'xargs']);
+class DeadlineExceeded extends Error {
+}
+let slm;
+let preserveList;
+const inFlight = new Map();
+function parsedArgs(callArgs) {
+    if (typeof callArgs !== 'string')
+        return callArgs;
+    try {
+        return JSON.parse(callArgs);
+    }
+    catch {
+        return { command: callArgs };
+    }
+}
+/** The shell command a command tool ran: `command` / `cmd` as a string or an argv array. */
+export function commandOf(callArgs) {
+    const args = parsedArgs(callArgs);
+    const command = args?.command ?? args?.cmd;
+    if (Array.isArray(command))
+        return command.map(String).join(' ');
+    return typeof command === 'string' ? command : '';
+}
+/**
+ * True when any step of the command prints a file: cat, bat, less, more, head, tail, nl, or sed with
+ * -n (also -ne, -En), after `bash -lc` / `sh -c` wrappers, `NAME=value` assignments and the prefixes
+ * env, sudo, command, exec, time, nice, xargs. Pipes into head/tail count too, which keeps some
+ * listings whole (the safe direction). Not detected, so still distilled: awk, python -c,
+ * `git show rev:file`, `find -exec cat`.
+ */
+export function isFileReadCommand(command) {
+    return command.split(/&&|\|\||;|\|/).some(segment => {
+        let words = segment.trim().split(/\s+/).map(word => word.replace(/^['"]+|['"]+$/g, '')).filter(Boolean);
+        for (;;) {
+            if (words.length > 2 && /^(?:ba|z)?sh$/.test(words[0]) && /^-\w*c$/.test(words[1]))
+                words = words.slice(2);
+            else if (words.length > 1 && /^[A-Za-z_]\w*=/.test(words[0]))
+                words = words.slice(1);
+            else
+                break;
+        }
+        // A prefix may carry its own flags and values before the real program (`nice -n 10 cat`,
+        // `xargs -I {} cat {}`), so any reader word after it counts — the safe direction.
+        const programs = COMMAND_PREFIXES.has(words[0]) ? words.slice(1) : words.slice(0, 1);
+        return programs.some(word => {
+            const program = word.split('/').pop() ?? '';
+            return FILE_READERS.has(program) || (program === 'sed' && words.some(flag => /^-[A-Za-z]*n[A-Za-z]*$/.test(flag)));
+        });
+    });
+}
+function distillableKind(result) {
+    const kind = KIND_BY_TOOL.get(result.toolName.toLowerCase());
+    if (!kind)
+        return null;
+    if (kind === 'command' && isFileReadCommand(commandOf(result.callArgs)))
+        return null;
+    return kind;
+}
+/**
+ * Identifies the conversation by its first user entry, which never changes while the conversation lasts
+ * (the history only grows). Two sessions that meet the same tool output must not share a decision: one
+ * of them may already have sent the original.
+ */
+function conversationKey(body) {
+    const history = body.messages ?? body.contents ?? (Array.isArray(body.input) ? body.input : []);
+    const first = history.find(entry => entry?.role === 'user') ?? history[0] ?? null;
+    return crypto.createHash('sha256').update(JSON.stringify(first)).digest('hex');
+}
+/**
+ * Only what cannot change for a result within a conversation. Engine version, prompt version and marker
+ * wording are deliberately left out: a changed key would find no decision for history the provider has
+ * already seen distilled.
+ */
+function decisionKey(params) {
+    const { conversation, result } = params;
+    return crypto.createHash('sha256').update(conversation).update('\0').update(result.toolName).update('\0').update(result.text).digest('hex');
+}
+function toolNames(tools) {
+    if (!Array.isArray(tools))
+        return [];
+    return tools
+        .flatMap((tool) => [tool?.name, tool?.function?.name, ...(Array.isArray(tool?.functionDeclarations) ? tool.functionDeclarations.map((f) => f?.name) : [])])
+        .filter((name) => typeof name === 'string');
+}
+const defaultEngine = async ({ text, toolName, callArgs, kind }) => {
+    const client = (slm ??= new SLM());
+    preserveList ??= buildPreserveList();
+    const compress = (run, task) => compressNarrativeRun({ slm: client, text: run, task });
+    // An empty task keeps the engine's own cache key the same on every turn.
+    return distillToolResult(compress, text, '', `${ENGINE_RULE[kind]}:${toolName}`, callArgs, await preserveList);
+};
+/** One distillation per key at a time: a retried request joins the one already running. */
+function distilOnce(key, run) {
+    let pending = inFlight.get(key);
+    if (!pending) {
+        pending = run();
+        inFlight.set(key, pending);
+        const forget = () => { inFlight.delete(key); };
+        pending.then(forget, forget);
+    }
+    return pending;
+}
+function beforeDeadline(work, deadline) {
+    let timer;
+    const expiry = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new DeadlineExceeded()), Math.max(0, deadline - Date.now()));
+    });
+    return Promise.race([work, expiry]).finally(() => clearTimeout(timer));
+}
+/** Stores a decision and returns the text to send; distilled text is only sent once its decision is on disk. */
+function persistThenSend(params) {
+    const { key, original, text, outcome } = params;
+    try {
+        return { text: recordDistillDecision({ key, text, outcome }).text, stored: true };
+    }
+    catch (err) {
+        console.error(`[llm-gate] distill decision not stored (${err instanceof Error ? err.message : String(err)}); sending the original`);
+        return { text: original, stored: false };
+    }
+}
+async function decide(params) {
+    const { result, kind, conversation, deadline, engine, expandHint } = params;
+    const key = decisionKey({ conversation, result });
+    let stored;
+    try {
+        stored = getDistillDecision(key);
+    }
+    catch (err) {
+        // Unknown whether a decision exists: send the original, record nothing.
+        console.error(`[llm-gate] distill decision not readable (${err instanceof Error ? err.message : String(err)}); sending the original`);
+        return { text: result.text, outcome: 'read_error' };
+    }
+    if (stored)
+        return { text: stored.text, outcome: 'reused' };
+    if (!result.newTurn) {
+        // The provider has already seen this text and no decision exists, so what it saw was the original.
+        const sent = persistThenSend({ key, original: result.text, text: result.text, outcome: 'history' });
+        return { text: sent.text, outcome: sent.stored ? 'history' : 'store_error' };
+    }
+    let text = result.text;
+    let outcome = 'distilled';
+    try {
+        const distilled = await beforeDeadline(distilOnce(key, () => engine({ text: result.text, toolName: result.toolName, callArgs: result.callArgs, kind })), deadline);
+        text = expandHint ? distilled : rewriteElisionHint(distilled);
+    }
+    catch (err) {
+        outcome = err instanceof DeadlineExceeded ? 'timeout' : 'error';
+        if (outcome === 'error')
+            console.error(`[llm-gate] distillation failed, sending the original: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const sent = persistThenSend({ key, original: result.text, text, outcome });
+    return { text: sent.text, outcome: sent.stored ? outcome : 'store_error' };
+}
+/**
+ * Distils the new large command, search and listing results of one request and resends every earlier
+ * decision unchanged.
+ *
+ * @param params.format The request's wire-format module
+ * @param params.body The parsed request body (not modified)
+ * @param params.engine Produces distilled text; defaults to distillToolResult with the local model
+ * @returns The body to send, or null when nothing changed, and what happened
+ */
+export async function distilRequest(params) {
+    const { format, body, engine = defaultEngine } = params;
+    const results = format.listToolResults(body);
+    const candidates = results.flatMap(result => {
+        const kind = distillableKind(result);
+        return kind && estimateTokens(result.text) >= CONFIG.DISTILL_MIN_TOKENS ? [{ result, kind }] : [];
+    });
+    const stats = { toolResults: results.length, candidates: candidates.length, distilled: 0, reused: 0, keptOriginal: 0, timeouts: 0, errors: 0 };
+    if (candidates.length === 0)
+        return { body: null, stats };
+    const conversation = conversationKey(body);
+    const expandHint = toolNames(body.tools).some(name => name.endsWith('expand_elision'));
+    const deadline = Date.now() + CONFIG.DISTILL_BUDGET_MS;
+    const decisions = await Promise.all(candidates.map(({ result, kind }) => decide({ result, kind, conversation, deadline, engine, expandHint })));
+    let sendBody = body;
+    decisions.forEach((decision, i) => {
+        const { result } = candidates[i];
+        const changed = decision.text !== result.text;
+        if (decision.outcome === 'timeout')
+            stats.timeouts++;
+        else if (decision.outcome === 'error')
+            stats.errors++;
+        if (!changed)
+            stats.keptOriginal++;
+        else if (decision.outcome === 'reused')
+            stats.reused++;
+        else
+            stats.distilled++;
+        if (changed)
+            sendBody = format.replaceToolResultText({ body: sendBody, location: result.location, text: decision.text });
+    });
+    return { body: sendBody === body ? null : sendBody, stats };
+}
+/** Loads the local model in the background so the first distillation does not pay the ~9 s cold start. */
+export function warmUpLocalModel() {
+    slm ??= new SLM();
+    slm.generateText(CONFIG.SLM_GATE_MODEL, [{ role: 'user', content: 'ok' }], 0, 1).catch(() => {
+        // Ollama down or model missing: each distillation then falls back to the original on its own.
+    });
+}

package/dist/llm-gate/formats/anthropic.js

@@ -0,0 +1,185 @@
+import crypto from 'node:crypto';
+import { typedText } from './contract.js';
+/**
+ * Parses an incoming Anthropic-formatted messages request and translates it
+ * into the agnostic `InternalRequest` structure.
+ * Anthropic uses a top-level `system` field, which seamlessly maps to our internal structure.
+ *
+ * @param body The raw JSON body of an Anthropic API request
+ * @param modelFallback A default model to use if the request omits it
+ */
+export function parseAnthropicRequest(body, modelFallback) {
+    const messages = [];
+    let system;
+    if (body.system) {
+        if (typeof body.system === 'string') {
+            system = body.system;
+        }
+        else if (Array.isArray(body.system)) {
+            system = body.system.map((b) => b.text || '').join('\n');
+        }
+    }
+    for (const m of (body.messages || [])) {
+        let content = '';
+        if (typeof m.content === 'string') {
+            content = m.content;
+        }
+        else if (Array.isArray(m.content)) {
+            content = m.content.map((b) => b.text || JSON.stringify(b)).join('\n');
+        }
+        messages.push({ role: m.role, content });
+    }
+    return {
+        system,
+        messages,
+        maxTokens: body.max_tokens,
+        stream: !!body.stream,
+        tools: body.tools, // If Anthropic native tools are sent
+        model: body.model || modelFallback
+    };
+}
+export function buildAnthropicRequest(internal) {
+    // Strip out any internal system messages from the messages array
+    const cleanMessages = internal.messages.filter(m => m.role !== 'system');
+    const req = {
+        model: internal.model,
+        messages: cleanMessages.map(m => ({ role: m.role === 'tool' ? 'user' : m.role, content: m.content })),
+        max_tokens: internal.maxTokens || 4096, // REQUIRED for Anthropic
+    };
+    // 1. Breakpoint on system block
+    if (internal.system) {
+        req.system = [{ type: 'text', text: internal.system, cache_control: { type: 'ephemeral' } }];
+    }
+    // 2. Breakpoint on last tool
+    if (internal.tools && internal.tools.length > 0) {
+        req.tools = [...internal.tools];
+        req.tools[req.tools.length - 1] = {
+            ...req.tools[req.tools.length - 1],
+            cache_control: { type: 'ephemeral' }
+        };
+    }
+    // 3. Breakpoint on historical message (skip current turn)
+    if (req.messages.length >= 3) {
+        // A standard turn is user -> assistant -> user, so length - 3 skips the current uncompleted turn
+        const targetIdx = req.messages.length - 3;
+        req.messages[targetIdx].content = [
+            { type: 'text', text: req.messages[targetIdx].content, cache_control: { type: 'ephemeral' } }
+        ];
+    }
+    if (internal.stream) {
+        req.stream = true;
+    }
+    return req;
+}
+export function formatAnthropicStreamChunk(content, isFirst = false, isLast = false, usage = null) {
+    let chunks = '';
+    if (isFirst) {
+        chunks += `event: message_start\ndata: ${JSON.stringify({ type: 'message_start', message: { id: `msg_${Date.now()}`, type: 'message', role: 'assistant', model: 'local', content: [] } })}\n\n`;
+        chunks += `event: content_block_start\ndata: ${JSON.stringify({ type: 'content_block_start', index: 0, content_block: { type: 'text', text: '' } })}\n\n`;
+    }
+    if (content) {
+        chunks += `event: content_block_delta\ndata: ${JSON.stringify({ type: 'content_block_delta', index: 0, delta: { type: 'text_delta', text: content } })}\n\n`;
+    }
+    if (isLast) {
+        chunks += `event: content_block_stop\ndata: ${JSON.stringify({ type: 'content_block_stop', index: 0 })}\n\n`;
+        chunks += `event: message_delta\ndata: ${JSON.stringify({ type: 'message_delta', delta: { stop_reason: 'end_turn', stop_sequence: null }, usage })}\n\n`;
+        chunks += `event: message_stop\ndata: ${JSON.stringify({ type: 'message_stop' })}\n\n`;
+    }
+    return chunks;
+}
+export function listToolResults(body) {
+    const messages = Array.isArray(body?.messages) ? body.messages : [];
+    const calls = new Map();
+    let lastAssistant = -1;
+    messages.forEach((message, i) => {
+        if (message?.role !== 'assistant')
+            return;
+        lastAssistant = i;
+        if (!Array.isArray(message.content))
+            return;
+        for (const block of message.content) {
+            if (block?.type === 'tool_use' && typeof block.id === 'string')
+                calls.set(block.id, { name: String(block.name ?? ''), input: block.input });
+        }
+    });
+    const results = [];
+    messages.forEach((message, i) => {
+        if (message?.role !== 'user' || !Array.isArray(message.content))
+            return;
+        message.content.forEach((block, j) => {
+            if (block?.type !== 'tool_result')
+                return;
+            const call = calls.get(block.tool_use_id);
+            const found = { toolName: call?.name ?? '', callArgs: call?.input, newTurn: i > lastAssistant };
+            if (typeof block.content === 'string') {
+                results.push({ ...found, location: { message: i, block: j }, text: block.content });
+            }
+            else if (Array.isArray(block.content)) {
+                block.content.forEach((part, k) => {
+                    if (part?.type === 'text' && typeof part.text === 'string') {
+                        results.push({ ...found, location: { message: i, block: j, part: k }, text: part.text });
+                    }
+                });
+            }
+        });
+    });
+    return results;
+}
+export function replaceToolResultText(params) {
+    const { body, location: { message, block, part }, text } = params;
+    const messages = [...body.messages];
+    const content = [...messages[message].content];
+    const result = content[block];
+    content[block] = part === undefined
+        ? { ...result, content: text }
+        : { ...result, content: result.content.map((p, k) => (k === part ? { ...p, text } : p)) };
+    messages[message] = { ...messages[message], content };
+    return { ...body, messages };
+}
+export function firstRequestPrompt(body) {
+    const messages = Array.isArray(body?.messages) ? body.messages : [];
+    if (messages.some(message => message?.role === 'assistant'))
+        return null;
+    // Structured output (Claude Code's title side request) or a forced tool call cannot be a text reply.
+    if (body.output_config?.format || body.output_format)
+        return null;
+    if (body.tool_choice?.type === 'any' || body.tool_choice?.type === 'tool')
+        return null;
+    const lastUser = [...messages].reverse().find(message => message?.role === 'user');
+    const content = lastUser?.content;
+    const texts = typeof content === 'string'
+        ? [content]
+        : Array.isArray(content)
+            ? content.filter((block) => block?.type === 'text' && typeof block.text === 'string').map((block) => block.text)
+            : [];
+    const text = typedText(texts);
+    return text ? { text, toolsListed: Array.isArray(body.tools) && body.tools.length > 0 } : null;
+}
+export function buildLocalReply(params) {
+    const { text, stream, model, usage } = params;
+    const message = {
+        id: `msg_slmgate_${crypto.randomUUID().replace(/-/g, '')}`,
+        type: 'message',
+        role: 'assistant',
+        model,
+        content: [{ type: 'text', text }],
+        stop_reason: 'end_turn',
+        stop_sequence: null,
+        usage: { input_tokens: usage.inputTokens, output_tokens: usage.outputTokens },
+    };
+    if (!stream)
+        return { contentType: 'application/json', body: JSON.stringify(message) };
+    const event = (name, data) => `event: ${name}\ndata: ${JSON.stringify(data)}\n\n`;
+    return {
+        contentType: 'text/event-stream; charset=utf-8',
+        body: event('message_start', {
+            type: 'message_start',
+            message: { ...message, content: [], stop_reason: null, usage: { input_tokens: usage.inputTokens, output_tokens: 1 } },
+        }) +
+            event('content_block_start', { type: 'content_block_start', index: 0, content_block: { type: 'text', text: '' } }) +
+            event('content_block_delta', { type: 'content_block_delta', index: 0, delta: { type: 'text_delta', text } }) +
+            event('content_block_stop', { type: 'content_block_stop', index: 0 }) +
+            event('message_delta', { type: 'message_delta', delta: { stop_reason: 'end_turn', stop_sequence: null }, usage: { output_tokens: usage.outputTokens } }) +
+            event('message_stop', { type: 'message_stop' }),
+    };
+}

package/dist/llm-gate/formats/chat-completions.js

@@ -0,0 +1,103 @@
+/**
+ * @fileoverview OpenAI Chat Completions, for the model gate contract (formats/contract.ts).
+ *
+ * Tool results are `role: 'tool'` messages (legacy: `role: 'function'` with a `name`). Their `content`
+ * is a string or an array of parts whose `text` parts are the text. The call is the entry with the
+ * same id in a preceding assistant message's `tool_calls`; its `arguments` is a JSON string.
+ */
+import crypto from 'node:crypto';
+import { typedText } from './contract.js';
+function parseArguments(raw) {
+    if (typeof raw !== 'string')
+        return raw;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+export function listToolResults(body) {
+    const messages = Array.isArray(body?.messages) ? body.messages : [];
+    const calls = new Map();
+    let lastAssistant = -1;
+    messages.forEach((message, i) => {
+        if (message?.role !== 'assistant')
+            return;
+        lastAssistant = i;
+        for (const call of Array.isArray(message.tool_calls) ? message.tool_calls : []) {
+            if (typeof call?.id === 'string')
+                calls.set(call.id, { name: String(call.function?.name ?? ''), args: parseArguments(call.function?.arguments) });
+        }
+    });
+    const results = [];
+    messages.forEach((message, i) => {
+        if (message?.role !== 'tool' && message?.role !== 'function')
+            return;
+        const call = calls.get(message.tool_call_id);
+        const found = { toolName: call?.name ?? String(message.name ?? ''), callArgs: call?.args, newTurn: i > lastAssistant };
+        if (typeof message.content === 'string') {
+            results.push({ ...found, location: { message: i }, text: message.content });
+        }
+        else if (Array.isArray(message.content)) {
+            message.content.forEach((part, k) => {
+                if (part?.type === 'text' && typeof part.text === 'string')
+                    results.push({ ...found, location: { message: i, part: k }, text: part.text });
+            });
+        }
+    });
+    return results;
+}
+export function replaceToolResultText(params) {
+    const { body, location: { message, part }, text } = params;
+    const messages = [...body.messages];
+    const target = messages[message];
+    messages[message] = part === undefined
+        ? { ...target, content: text }
+        : { ...target, content: target.content.map((p, k) => (k === part ? { ...p, text } : p)) };
+    return { ...body, messages };
+}
+export function firstRequestPrompt(body) {
+    const messages = Array.isArray(body?.messages) ? body.messages : [];
+    if (messages.some(message => message?.role === 'assistant'))
+        return null;
+    if (['json_schema', 'json_object'].includes(body.response_format?.type))
+        return null;
+    if (body.tool_choice === 'required' || (body.tool_choice && typeof body.tool_choice === 'object'))
+        return null;
+    const lastUser = [...messages].reverse().find(message => message?.role === 'user');
+    const content = lastUser?.content;
+    const texts = typeof content === 'string'
+        ? [content]
+        : Array.isArray(content)
+            ? content.filter((part) => part?.type === 'text' && typeof part.text === 'string').map((part) => part.text)
+            : [];
+    const text = typedText(texts);
+    const toolsListed = (Array.isArray(body.tools) && body.tools.length > 0) || (Array.isArray(body.functions) && body.functions.length > 0);
+    return text ? { text, toolsListed } : null;
+}
+export function buildLocalReply(params) {
+    const { text, stream, model, usage } = params;
+    const id = `chatcmpl-slmgate-${crypto.randomUUID().replace(/-/g, '')}`;
+    const created = Math.floor(Date.now() / 1000);
+    const tokens = { prompt_tokens: usage.inputTokens, completion_tokens: usage.outputTokens, total_tokens: usage.inputTokens + usage.outputTokens };
+    if (!stream) {
+        return {
+            contentType: 'application/json',
+            body: JSON.stringify({
+                id,
+                object: 'chat.completion',
+                created,
+                model,
+                choices: [{ index: 0, message: { role: 'assistant', content: text }, logprobs: null, finish_reason: 'stop' }],
+                usage: tokens,
+            }),
+        };
+    }
+    const chunk = (delta, finishReason, extra = {}) => `data: ${JSON.stringify({ id, object: 'chat.completion.chunk', created, model, choices: [{ index: 0, delta, logprobs: null, finish_reason: finishReason }], ...extra })}\n\n`;
+    return {
+        contentType: 'text/event-stream; charset=utf-8',
+        // Usage rides on the final chunk, so clients that asked for it get it and the rest ignore it.
+        body: chunk({ role: 'assistant', content: '' }, null) + chunk({ content: text }, null) + chunk({}, 'stop', { usage: tokens }) + 'data: [DONE]\n\n',
+    };
+}