pikiloom 0.4.12 → 0.4.14

package/dist/model/injector.js

@@ -9,6 +9,7 @@
 import { resolveCredential } from '../core/secrets/index.js';
 import { getActiveProfile, getProvider } from './store.js';
 import { peekProviderModelInfo, prefetchProviderModels } from './provider-models.js';
+import { ensureResponsesBridge, upstreamToken } from './responses-bridge.js';
 const EMPTY = { env: {}, argvAppend: [], detail: '' };
 // ---------------------------------------------------------------------------
 // Shared host-based provider identification
@@ -53,7 +54,13 @@ function providerSlug(provider) {
         return 'doubao';
     if (host.includes('openrouter'))
         return 'openrouter';
-    return 'openrouter';
+    // Unknown host: derive a stable slug from the hostname's leading label. (The
+    // old `return 'openrouter'` fallback mis-slugged every unrecognised provider —
+    // including localhost Ollama — as openrouter.) This never collides with
+    // codex's reserved built-in `openai`/`oss`/`ollama` ids, which are routed
+    // before we ever reach providerSlug.
+    const label = host.replace(/:\d+$/, '').replace(/^(www|api)\./, '').split('.')[0].replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+    return label || 'byok';
 }
 /**
  * Canonical env-var name(s) carrying the credential for a provider. Returned
@@ -152,6 +159,24 @@ function claudeAnthropicBaseURL(provider) {
     }
     return raw.replace(/\/v1$/, '');
 }
+/**
+ * First-party Anthropic = the official API host (`api.anthropic.com` / any
+ * `*.anthropic.com`). A Claude route counts as "direct" when it lands here —
+ * both the subscription path and an own-key BYOK profile pointed at
+ * api.anthropic.com. Everything else (OpenRouter, DeepSeek, domestic series, a
+ * self-hosted relay, localhost) is a third-party proxy. Unparseable → treat as
+ * proxy (safe default: suppressing attribution is harmless, churning isn't).
+ */
+function isFirstPartyAnthropic(baseURL) {
+    let host;
+    try {
+        host = new URL(baseURL).hostname.toLowerCase();
+    }
+    catch {
+        return false;
+    }
+    return host === 'anthropic.com' || host.endsWith('.anthropic.com');
+}
 /**
  * Claude Code respects `ANTHROPIC_BASE_URL` + `ANTHROPIC_API_KEY` (or
  * `ANTHROPIC_AUTH_TOKEN`) as a BYOK route. The CLI itself is unchanged.
@@ -170,50 +195,159 @@ const claudeInjector = (provider, profile, apiKey) => {
             detail: `Claude BYOK requires Anthropic or OpenAI-compatible (Anthropic-API-shaped) provider; got ${provider.kind}.`,
         };
     }
+    const baseURL = claudeAnthropicBaseURL(provider);
+    const env = {
+        ANTHROPIC_BASE_URL: baseURL,
+        ANTHROPIC_API_KEY: apiKey,
+        ANTHROPIC_AUTH_TOKEN: apiKey,
+    };
+    // Claude Code >= 2.1.36 stamps a per-request `x-anthropic-billing-header`
+    // (cc_version / cc_entrypoint / cch=… — the cch token churns every turn).
+    // Third-party proxies (OpenRouter, DeepSeek /anthropic, domestic series, any
+    // OpenAI-compat or self-hosted Anthropic-shaped front) often key their
+    // prefix/KV cache on request headers, so the churn forces a full prompt
+    // reprocess every turn — slow and expensive. `0` makes claude omit the header
+    // (env-bool: 0/false/no/off). Only on proxy routes: first-party Anthropic
+    // (api.anthropic.com — subscription OR own-key direct) is left exactly as
+    // shipped; its cache is content/breakpoint based, so attribution is irrelevant
+    // there and we don't touch it.
+    if (!isFirstPartyAnthropic(baseURL)) {
+        env.CLAUDE_CODE_ATTRIBUTION_HEADER = '0';
+    }
     return {
-        env: {
-            ANTHROPIC_BASE_URL: claudeAnthropicBaseURL(provider),
-            ANTHROPIC_API_KEY: apiKey,
-            ANTHROPIC_AUTH_TOKEN: apiKey,
-        },
+        env,
         argvAppend: [],
         modelOverride: profile.modelId,
         detail: `Claude BYOK → ${provider.name} / ${profile.modelId}`,
     };
 };
+function providerHostname(provider) {
+    try {
+        return new URL(provider.baseURL).hostname.toLowerCase();
+    }
+    catch {
+        return '';
+    }
+}
+/** True for localhost endpoints (Ollama / LM Studio / llama.cpp). */
+function isLocalProvider(provider) {
+    const h = providerHostname(provider);
+    return h === 'localhost' || h === '127.0.0.1' || h === '0.0.0.0' || h === '::1';
+}
+/** Providers that natively implement the OpenAI Responses API (codex talks to them directly). */
+function isResponsesNativeProvider(provider) {
+    return providerHost(provider).includes('openrouter');
+}
+/** codex's built-in local provider id for a localhost endpoint. */
+function codexLocalProvider(provider) {
+    let port = '';
+    try {
+        port = new URL(provider.baseURL).port;
+    }
+    catch { /* ignore */ }
+    if (port === '1234' || /lm\s*studio/i.test(provider.name))
+        return 'lmstudio';
+    return 'ollama';
+}
 /**
- * Codex CLI honours `model_providers.<slug>` definitions in `config.toml`.
- * Setting `OPENAI_BASE_URL` alone is not enough — Codex still routes through
- * the default `openai` provider's auth flow. The robust path is to declare a
- * one-shot `model_providers.<slug>` via `-c` overrides and bind it via
- * `model_provider="<slug>"`. The credential lives in the env var named by
- * `env_key`, picked host-aware (e.g. `OPENROUTER_API_KEY` for openrouter.ai).
+ * Decide how codex should reach a provider. Codex 0.140+ speaks ONLY the
+ * Responses API, so the route depends on what the provider implements:
+ *   openai-native   genuine OpenAI            → built-in `openai` provider
+ *   local-oss       localhost Ollama/LMStudio → built-in `ollama`/`lmstudio` (responses)
+ *   responses-native OpenRouter, …            → custom provider, responses direct
+ *   bridge          chat-only (DeepSeek, Kimi, MiniMax, 豆包, Qwen, Zhipu, …)
+ *                                             → local Responses↔Chat bridge
+ */
+function codexRoute(provider) {
+    if (provider.kind === 'openai')
+        return 'openai-native';
+    if (isLocalProvider(provider))
+        return 'local-oss';
+    if (isResponsesNativeProvider(provider))
+        return 'responses-native';
+    return 'bridge';
+}
+/**
+ * Codex CLI honours `model_providers.<slug>` definitions in `config.toml` and
+ * binds the active one via `model_provider="<slug>"`. The credential lives in
+ * the env var named by `env_key`, picked host-aware (e.g. `DEEPSEEK_API_KEY`).
  *
- * Note on `wire_api`: codex 0.130 dropped `"chat"` ("no longer supported"); we
- * omit the field entirely so codex picks its current default (`responses`),
- * which OpenRouter and other major OpenAI-compatible providers accept.
+ * Codex 0.140+ dropped Chat Completions (`wire_api = "chat"` is rejected at
+ * config load) — it speaks ONLY the Responses API. So this injector routes per
+ * `codexRoute()`: responses-capable providers (OpenAI, OpenRouter, local
+ * Ollama/LM Studio) are reached directly with the default `responses` wire;
+ * chat-only providers (DeepSeek and the domestic series) are routed through the
+ * in-process Responses↔Chat bridge, which codex sees as just another
+ * responses-speaking provider on localhost.
  */
-const codexInjector = (provider, profile, apiKey) => {
+const codexInjector = async (provider, profile, apiKey) => {
     if (provider.kind !== 'openai' && provider.kind !== 'openai-compatible') {
         return {
             ...EMPTY,
-            detail: `Codex BYOK requires OpenAI-compatible provider; got ${provider.kind}.`,
+            detail: `Codex BYOK requires an OpenAI-compatible provider; got ${provider.kind}.`,
+        };
+    }
+    const model = profile.modelId;
+    const route = codexRoute(provider);
+    // Local Ollama / LM Studio: codex's built-in provider already speaks the
+    // Responses API to the local server. Just select it — no custom provider, no
+    // API key. (Defining `model_providers.<built-in>` is rejected: "Built-in
+    // providers cannot be overridden.")
+    if (route === 'local-oss') {
+        const local = codexLocalProvider(provider);
+        return {
+            env: {}, argvAppend: [],
+            codexConfigOverrides: [`model_provider="${local}"`],
+            modelOverride: model,
+            detail: `Codex local → ${provider.name} / ${model} (built-in ${local}, responses)`,
+        };
+    }
+    // Genuine OpenAI: use the built-in `openai` provider; inject the key (+ base).
+    if (route === 'openai-native') {
+        const env = { OPENAI_API_KEY: apiKey };
+        if (provider.baseURL)
+            env.OPENAI_BASE_URL = provider.baseURL;
+        return {
+            env, argvAppend: [],
+            codexConfigOverrides: ['model_provider="openai"'],
+            modelOverride: model,
+            detail: `Codex BYOK → OpenAI / ${model}`,
         };
     }
     const slug = providerSlug(provider);
     const envKey = codexEnvKey(provider);
-    const overrides = [
-        `model_providers.${slug}.name="${tomlEscape(provider.name)}"`,
-        `model_providers.${slug}.base_url="${tomlEscape(provider.baseURL)}"`,
-        `model_providers.${slug}.env_key="${envKey}"`,
-        `model_provider="${slug}"`,
-    ];
+    // Chat-only providers: route through the local Responses↔Chat bridge. Codex
+    // forwards `Authorization: Bearer <key>` (from env_key) to the bridge, which
+    // relays it to the upstream chat endpoint — the bridge never stores secrets.
+    if (route === 'bridge') {
+        const port = await ensureResponsesBridge();
+        const base = `http://127.0.0.1:${port}/u/${upstreamToken(provider.baseURL)}`;
+        return {
+            env: { [envKey]: apiKey },
+            argvAppend: [],
+            codexConfigOverrides: [
+                `model_providers.${slug}.name="${tomlEscape(provider.name)}"`,
+                `model_providers.${slug}.base_url="${tomlEscape(base)}"`,
+                `model_providers.${slug}.env_key="${envKey}"`,
+                `model_provider="${slug}"`,
+            ],
+            modelOverride: model,
+            detail: `Codex BYOK → ${provider.name} / ${model} via Responses↔Chat bridge (provider=${slug})`,
+        };
+    }
+    // responses-native (OpenRouter, …): point codex straight at the provider's
+    // Responses endpoint (wire_api omitted ⇒ codex default `responses`).
     return {
         env: { [envKey]: apiKey },
         argvAppend: [],
-        codexConfigOverrides: overrides,
-        modelOverride: profile.modelId,
-        detail: `Codex BYOK → ${provider.name} / ${profile.modelId} (provider=${slug})`,
+        codexConfigOverrides: [
+            `model_providers.${slug}.name="${tomlEscape(provider.name)}"`,
+            `model_providers.${slug}.base_url="${tomlEscape(provider.baseURL)}"`,
+            `model_providers.${slug}.env_key="${envKey}"`,
+            `model_provider="${slug}"`,
+        ],
+        modelOverride: model,
+        detail: `Codex BYOK → ${provider.name} / ${model} (provider=${slug}, native responses)`,
     };
 };
 /** Gemini CLI accepts `GEMINI_API_KEY` but does not allow custom baseURL. */
@@ -289,12 +423,17 @@ export async function resolveAgentInjection(agentId) {
     const injector = AGENT_INJECT_TABLE[agentId];
     if (!injector)
         return null;
-    let apiKey;
+    // Local providers (Ollama / LM Studio / llama.cpp) need no credential — codex
+    // reaches them via its built-in localhost provider with no auth. Don't let a
+    // missing/placeholder key block an otherwise-valid local binding.
+    let apiKey = '';
     try {
         apiKey = await resolveCredential(provider.credential);
     }
     catch (e) {
-        throw new Error(`Failed to resolve credential for ${provider.name}: ${e?.message || e}`);
+        if (!isLocalProvider(provider)) {
+            throw new Error(`Failed to resolve credential for ${provider.name}: ${e?.message || e}`);
+        }
     }
     const result = await injector(provider, profile, apiKey);
     // Attach the provider display name so renders can surface "via <provider>"

package/dist/model/responses-bridge.js

@@ -0,0 +1,366 @@
+/**
+ * Responses↔Chat bridge.
+ *
+ * Codex 0.140+ speaks ONLY the OpenAI Responses API (`wire_api = "chat"` was
+ * removed). Many OpenAI-compatible providers — DeepSeek, Kimi/Moonshot,
+ * MiniMax, 豆包/Doubao, Qwen/DashScope, Zhipu, … — implement ONLY the Chat
+ * Completions API. This in-process HTTP server bridges the two so codex can
+ * drive any chat-only provider:
+ *
+ *   codex ──(Responses API)──▶ bridge ──(Chat Completions)──▶ upstream provider
+ *
+ * One server instance routes every upstream: the upstream base URL is encoded
+ * (base64url) into the request path (`/u/<token>/responses`). The caller's
+ * Authorization header is forwarded verbatim, so the bridge never reads or
+ * stores credentials — codex injects `Authorization: Bearer <key>` from the
+ * provider's `env_key`, and we relay it upstream.
+ *
+ * Translation is intentionally NON-incremental: we call the upstream with
+ * `stream:false`, then synthesise a complete, spec-shaped Responses SSE stream.
+ * Codex rebuilds a turn from `response.output_item.done` items plus the final
+ * `response.completed`, so a fully-populated terminal payload is authoritative;
+ * this sidesteps fragile per-token delta bookkeeping while still surfacing
+ * assistant text AND tool/function calls (apply_patch, shell, MCP tools).
+ */
+import http from 'node:http';
+import { writeScopedLog } from '../core/logging.js';
+const SCOPE = 'model-bridge';
+const log = (m) => { writeScopedLog(SCOPE, m); };
+const warn = (m) => { writeScopedLog(SCOPE, m, { level: 'warn', stream: 'stderr' }); };
+let server = null;
+let listenPort = 0;
+let starting = null;
+let idCounter = 0;
+function genId(prefix) {
+    idCounter += 1;
+    return `${prefix}_${Date.now().toString(36)}${idCounter.toString(36)}`;
+}
+function num(v) { return typeof v === 'number' && Number.isFinite(v) ? v : 0; }
+/** base64url-encode an upstream base URL so it survives as a single path segment. */
+export function upstreamToken(baseURL) {
+    return Buffer.from(baseURL, 'utf8').toString('base64url');
+}
+function decodeUpstream(token) {
+    try {
+        return Buffer.from(token, 'base64url').toString('utf8') || null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Start (or reuse) the singleton bridge server; resolves to its localhost port. */
+export async function ensureResponsesBridge() {
+    if (server && listenPort)
+        return listenPort;
+    if (starting)
+        return starting;
+    starting = new Promise((resolve, reject) => {
+        const srv = http.createServer(handleRequest);
+        srv.on('error', err => { warn(`server error: ${err?.message || err}`); reject(err); });
+        srv.listen(0, '127.0.0.1', () => {
+            server = srv;
+            const addr = srv.address();
+            listenPort = typeof addr === 'object' && addr ? addr.port : 0;
+            log(`listening on 127.0.0.1:${listenPort}`);
+            resolve(listenPort);
+        });
+    });
+    try {
+        return await starting;
+    }
+    finally {
+        starting = null;
+    }
+}
+export function shutdownResponsesBridge() {
+    try {
+        server?.close();
+    }
+    catch { /* ignore */ }
+    server = null;
+    listenPort = 0;
+}
+// ---------------------------------------------------------------------------
+// HTTP handling
+// ---------------------------------------------------------------------------
+function handleRequest(req, res) {
+    const url = new URL(req.url || '/', 'http://127.0.0.1');
+    const m = url.pathname.match(/^\/u\/([^/]+)\/(responses|models)$/);
+    if (!m) {
+        res.writeHead(404).end('not found');
+        return;
+    }
+    const upstreamBase = decodeUpstream(m[1]);
+    if (!upstreamBase) {
+        res.writeHead(400).end('bad upstream token');
+        return;
+    }
+    if (m[2] === 'models') {
+        // Codex's model-catalog refresh is best-effort; an empty list keeps it quiet
+        // and never blocks the turn.
+        res.writeHead(200, { 'content-type': 'application/json' });
+        res.end(JSON.stringify({ object: 'list', data: [], models: [] }));
+        return;
+    }
+    if (req.method !== 'POST') {
+        res.writeHead(405).end('method not allowed');
+        return;
+    }
+    const chunks = [];
+    req.on('data', c => chunks.push(c));
+    req.on('end', () => {
+        let body = {};
+        try {
+            body = JSON.parse(Buffer.concat(chunks).toString('utf8') || '{}');
+        }
+        catch {
+            body = {};
+        }
+        handleResponses(req, res, upstreamBase, body).catch(err => {
+            warn(`handler error: ${err?.message || err}`);
+            sendResponsesError(res, `bridge error: ${err?.message || err}`);
+        });
+    });
+}
+async function handleResponses(req, res, upstreamBase, body) {
+    const chatReq = toChatRequest(body);
+    const auth = req.headers['authorization'];
+    const upstreamUrl = chatCompletionsUrl(upstreamBase);
+    log(`-> ${upstreamUrl} model=${chatReq.model} msgs=${chatReq.messages.length} tools=${chatReq.tools?.length ?? 0}`);
+    let upstreamResp;
+    try {
+        upstreamResp = await fetch(upstreamUrl, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                ...(auth ? { authorization: Array.isArray(auth) ? auth[0] : auth } : {}),
+            },
+            body: JSON.stringify(chatReq),
+        });
+    }
+    catch (e) {
+        sendResponsesError(res, `upstream fetch failed: ${e?.message || e}`);
+        return;
+    }
+    const raw = await upstreamResp.text();
+    if (!upstreamResp.ok) {
+        warn(`upstream ${upstreamResp.status}: ${raw.slice(0, 300)}`);
+        sendResponsesError(res, `upstream ${upstreamResp.status}: ${raw.slice(0, 500)}`);
+        return;
+    }
+    let chat;
+    try {
+        chat = JSON.parse(raw);
+    }
+    catch {
+        sendResponsesError(res, `bad upstream JSON: ${raw.slice(0, 200)}`);
+        return;
+    }
+    const events = buildResponsesEvents(chat, chatReq.model);
+    res.writeHead(200, {
+        'content-type': 'text/event-stream',
+        'cache-control': 'no-cache',
+        connection: 'keep-alive',
+    });
+    for (const ev of events) {
+        res.write(`event: ${ev.type}\n`);
+        res.write(`data: ${JSON.stringify(ev)}\n\n`);
+    }
+    res.end();
+}
+function sendResponsesError(res, message) {
+    if (res.headersSent) {
+        try {
+            res.end();
+        }
+        catch { /* ignore */ }
+        return;
+    }
+    res.writeHead(200, {
+        'content-type': 'text/event-stream',
+        'cache-control': 'no-cache',
+        connection: 'keep-alive',
+    });
+    const id = genId('resp');
+    let seq = 0;
+    const emit = (e) => { res.write(`event: ${e.type}\n`); res.write(`data: ${JSON.stringify({ ...e, sequence_number: seq++ })}\n\n`); };
+    emit({ type: 'response.created', response: { id, object: 'response', status: 'in_progress', output: [] } });
+    emit({ type: 'response.failed', response: { id, object: 'response', status: 'failed', error: { code: 'bridge_error', message }, output: [] } });
+    res.end();
+}
+// ---------------------------------------------------------------------------
+// Request translation: Responses → Chat Completions
+// ---------------------------------------------------------------------------
+function asText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((c) => (typeof c === 'string' ? c : (typeof c?.text === 'string' ? c.text : '')))
+            .join('');
+    }
+    return '';
+}
+function toChatRequest(body) {
+    const messages = [];
+    if (typeof body.instructions === 'string' && body.instructions.trim()) {
+        messages.push({ role: 'system', content: body.instructions });
+    }
+    const input = Array.isArray(body.input) ? body.input : (body.input != null ? [body.input] : []);
+    for (const item of input) {
+        if (typeof item === 'string') {
+            messages.push({ role: 'user', content: item });
+            continue;
+        }
+        const type = item?.type;
+        if (type === 'message' || (!type && item?.role)) {
+            const role = item.role === 'assistant' ? 'assistant' : item.role === 'system' ? 'system' : 'user';
+            messages.push({ role, content: asText(item.content) });
+        }
+        else if (type === 'function_call') {
+            messages.push({
+                role: 'assistant',
+                content: typeof item.text === 'string' ? item.text : null,
+                tool_calls: [{
+                        id: item.call_id || item.id,
+                        type: 'function',
+                        function: {
+                            name: item.name,
+                            arguments: typeof item.arguments === 'string' ? item.arguments : JSON.stringify(item.arguments ?? {}),
+                        },
+                    }],
+            });
+        }
+        else if (type === 'function_call_output') {
+            const out = item.output;
+            messages.push({
+                role: 'tool',
+                tool_call_id: item.call_id,
+                content: typeof out === 'string' ? out : JSON.stringify(out ?? ''),
+            });
+        }
+        else if (type === 'reasoning') {
+            // Chat models cannot ingest prior reasoning items — drop.
+        }
+    }
+    const tools = Array.isArray(body.tools)
+        ? body.tools.map(toChatTool).filter((t) => t)
+        : undefined;
+    const req = { model: body.model, messages, stream: false };
+    if (tools && tools.length)
+        req.tools = tools;
+    if (body.tool_choice != null)
+        req.tool_choice = toChatToolChoice(body.tool_choice);
+    if (typeof body.temperature === 'number')
+        req.temperature = body.temperature;
+    if (typeof body.top_p === 'number')
+        req.top_p = body.top_p;
+    if (typeof body.max_output_tokens === 'number')
+        req.max_tokens = body.max_output_tokens;
+    if (typeof body.parallel_tool_calls === 'boolean' && req.tools)
+        req.parallel_tool_calls = body.parallel_tool_calls;
+    return req;
+}
+function toChatTool(t) {
+    if (!t)
+        return null;
+    if (t.type === 'function') {
+        if (t.function && typeof t.function === 'object')
+            return { type: 'function', function: t.function };
+        return {
+            type: 'function',
+            function: {
+                name: t.name,
+                description: t.description,
+                parameters: t.parameters || { type: 'object', properties: {} },
+            },
+        };
+    }
+    // Codex built-in custom tools (e.g. local_shell) and web_search aren't
+    // expressible as chat functions — drop; codex falls back to its function tools.
+    return null;
+}
+function toChatToolChoice(tc) {
+    if (typeof tc === 'string')
+        return tc; // auto | none | required
+    if (tc?.type === 'function' && tc.name)
+        return { type: 'function', function: { name: tc.name } };
+    if (tc?.type === 'function' && tc.function)
+        return tc;
+    return 'auto';
+}
+// ---------------------------------------------------------------------------
+// Response synthesis: Chat Completion → Responses SSE events
+// ---------------------------------------------------------------------------
+function buildResponsesEvents(chat, model) {
+    const choice = chat?.choices?.[0] || {};
+    const msg = choice.message || {};
+    const items = [];
+    const text = typeof msg.content === 'string'
+        ? msg.content
+        : (Array.isArray(msg.content) ? msg.content.map((c) => c?.text || '').join('') : '');
+    if (text && text.trim()) {
+        items.push({ type: 'message', role: 'assistant', content: [{ type: 'output_text', text }] });
+    }
+    const toolCalls = Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
+    for (const tc of toolCalls) {
+        const fn = tc.function || {};
+        items.push({
+            type: 'function_call',
+            name: fn.name,
+            arguments: typeof fn.arguments === 'string' ? fn.arguments : JSON.stringify(fn.arguments ?? {}),
+            call_id: tc.id || genId('call'),
+        });
+    }
+    // Always emit at least one item so codex sees a well-formed turn.
+    if (!items.length)
+        items.push({ type: 'message', role: 'assistant', content: [{ type: 'output_text', text: '' }] });
+    const respId = genId('resp');
+    const usage = chat?.usage || {};
+    const usageOut = {
+        input_tokens: num(usage.prompt_tokens),
+        output_tokens: num(usage.completion_tokens),
+        total_tokens: num(usage.total_tokens) || (num(usage.prompt_tokens) + num(usage.completion_tokens)),
+    };
+    const responseObj = (status, output) => ({
+        id: respId, object: 'response', created_at: Math.floor(Date.now() / 1000),
+        status, model, output, usage: usageOut,
+    });
+    let seq = 0;
+    const events = [];
+    const push = (e) => { events.push({ ...e, sequence_number: seq++ }); };
+    push({ type: 'response.created', response: responseObj('in_progress', []) });
+    push({ type: 'response.in_progress', response: responseObj('in_progress', []) });
+    const finalItems = [];
+    items.forEach((item, idx) => {
+        const id = genId(item.type === 'function_call' ? 'fc' : 'msg');
+        const full = { ...item, id };
+        finalItems.push(full);
+        push({ type: 'response.output_item.added', output_index: idx, item: skeleton(full) });
+        if (item.type === 'message') {
+            const t = item.content?.[0]?.text || '';
+            if (t) {
+                push({ type: 'response.output_text.delta', item_id: id, output_index: idx, content_index: 0, delta: t });
+                push({ type: 'response.output_text.done', item_id: id, output_index: idx, content_index: 0, text: t });
+            }
+        }
+        else if (item.type === 'function_call') {
+            push({ type: 'response.function_call_arguments.delta', item_id: id, output_index: idx, delta: item.arguments });
+            push({ type: 'response.function_call_arguments.done', item_id: id, output_index: idx, arguments: item.arguments });
+        }
+        push({ type: 'response.output_item.done', output_index: idx, item: full });
+    });
+    push({ type: 'response.completed', response: responseObj('completed', finalItems) });
+    return events;
+}
+function skeleton(item) {
+    if (item.type === 'message')
+        return { id: item.id, type: 'message', role: item.role, content: [], status: 'in_progress' };
+    if (item.type === 'function_call')
+        return { id: item.id, type: 'function_call', name: item.name, arguments: '', call_id: item.call_id, status: 'in_progress' };
+    return item;
+}
+function chatCompletionsUrl(base) {
+    const b = base.replace(/\/+$/, '');
+    return b.endsWith('/chat/completions') ? b : `${b}/chat/completions`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pikiloom",
-  "version": "0.4.12",
+  "version": "0.4.14",
   "description": "Put the world's smartest AI agents in your pocket. Command local Claude & Gemini via IM. | 让最好用的 IM 变成你电脑上的顶级 Agent 控制台",
   "type": "module",
   "bin": {