pikiloom 0.4.30 → 0.4.32

package/dist/agent/index.js

@@ -4,7 +4,7 @@ import './drivers/gemini.js';
 import './drivers/hermes.js';
 export { IMAGE_EXTS } from './types.js';
 export { attachAgentImage, attachInlineImage, materializeImage, rewriteAttachmentBlocksForTransport, attachmentUrl, resolveAllowedAttachmentPath, allowedAttachmentRoots, decodeAttachmentPathParam, sessionAttachmentsDir, codexHome, } from './images.js';
-export { deliverArtifact, readDeliveredArtifacts, deliveredArtifactBlocks, mimeForArtifact, } from './artifacts.js';
+export { deliverArtifact, readDeliveredArtifacts, deliveredArtifactBlocks, latestDeliveredTaskId, mimeForArtifact, } from './artifacts.js';
 export { Q, agentLog, agentWarn, agentError, dedupeStrings, numberOrNull, normalizeStreamPreviewPlan, parseTodoWriteAsPlan, normalizeActivityLine, pushRecentActivity, detectClaudeApiError, isRetryableClaudeApiError, detectClaudeModelError, claudeModelErrorMessage, firstNonEmptyLine, shortValue, normalizeErrorMessage, joinErrorMessages, appendSystemPrompt, mimeForExt, computeContext, buildStreamPreviewMeta, summarizeClaudeToolUse, summarizeClaudeToolResult, previewToolCallInput, previewToolCallResult, roundPercent, toIsoFromEpochSeconds, normalizeUsageStatus, labelFromWindowMinutes, usageWindowFromRateLimit, parseJsonTail, modelFamily, normalizeClaudeModelId, emptyUsage, readTailLines, stripInjectedPrompts, sanitizeSessionUserPreviewText, SESSION_PREVIEW_IMAGE_PLACEHOLDER_RE, CLAUDE_AT_MENTION_IMAGE_RE, extractClaudeAtMentionImagePaths, stripClaudeAtMentionImages, isPendingSessionId, emitSessionIdUpdate, sessionListDisplayTitle, } from './utils.js';
 export { updateSessionMeta, promoteSessionId, recordFork, resolveCanonicalSessionId, getSessionPromotions, listPikiloomSessions, findPikiloomSession, getSessionStoredConfig, ensureManagedSession, findManagedThreadSession, stageSessionFiles, mergeManagedAndNativeSessions, managedRecordToSessionInfo, getSessions, getSessionTail, getSessionMessages, applyTurnWindow, applyTurnFilter, classifySession, deriveUserStatus, exportSession, importSession, deleteAgentSession, isProcessAlive, isRunningSessionStale, reconcileOrphanedRunningSessions, } from './session.js';
 export { detectAgentBin, listAgents, resolveDefaultAgent, run, doStream, listModels, resolveAgentModels, getUsage, getAgentBoundModelId, setAgentBoundModelId, } from './stream.js';

package/dist/bot/bot.js

@@ -418,7 +418,10 @@ export class Bot {
                 if (!sid || isPendingSessionId(sid))
                     return result;
                 const kind = sendOpts?.kind === 'photo' ? 'photo' : 'document';
-                const record = deliverArtifact(agent, sid, filePath, { kind, caption: sendOpts?.caption });
+                const taskId = sessionKey
+                    ? this.streamSnapshots.get(this.resolveSessionKey(sessionKey))?.taskId
+                    : undefined;
+                const record = deliverArtifact(agent, sid, filePath, { kind, caption: sendOpts?.caption, ...(taskId ? { taskId } : {}) });
                 if (record && sessionKey) {
                     this.emitStream(this.resolveSessionKey(sessionKey), {
                         type: 'artifact',

package/dist/catalog/mcp-servers.js

@@ -212,6 +212,30 @@ export const MCP_SERVERS = [
         iconSlug: 'lark',
         homepage: 'https://open.feishu.cn/document/mcp',
     },
+    {
+        id: 'gmail',
+        name: 'Gmail',
+        description: 'Read, search, send, and manage Gmail messages, threads, and labels. One-time sign-in via `npx @gongrzhe/server-gmail-autoauth-mcp auth`.',
+        descriptionZh: '读取、搜索、发送和管理 Gmail 邮件、会话与标签。首次需运行 `npx @gongrzhe/server-gmail-autoauth-mcp auth` 完成 Google 授权。',
+        category: 'communication',
+        recommendedScope: 'global',
+        transport: { type: 'stdio', command: 'npx', args: ['-y', '@gongrzhe/server-gmail-autoauth-mcp'] },
+        auth: { type: 'none' },
+        iconSlug: 'gmail',
+        homepage: 'https://github.com/GongRzhe/Gmail-MCP-Server',
+    },
+    {
+        id: 'outlook',
+        name: 'Outlook',
+        description: 'Microsoft 365 / Outlook email via Microsoft Graph — read, search, send, and organize mail. One-time device-code sign-in via `npx @softeria/ms-365-mcp-server --login`.',
+        descriptionZh: '通过 Microsoft Graph 访问 Microsoft 365 / Outlook 邮箱 — 读取、搜索、发送和整理邮件。首次需运行 `npx @softeria/ms-365-mcp-server --login` 完成设备码登录。',
+        category: 'communication',
+        recommendedScope: 'global',
+        transport: { type: 'stdio', command: 'npx', args: ['-y', '@softeria/ms-365-mcp-server', '--preset', 'mail'] },
+        auth: { type: 'none' },
+        iconSlug: 'outlook',
+        homepage: 'https://github.com/softeria/ms-365-mcp-server',
+    },
     {
         id: 'stripe',
         name: 'Stripe',

package/dist/core/utils.js

@@ -16,13 +16,19 @@ export function ensureGitignore(dir) {
             '.claude/skills/',
             '.agents/skills/',
         ]);
-        const rawLines = fs.readFileSync(gi, 'utf8').split(/\r?\n/);
-        const normalized = rawLines.filter(line => {
-            const trimmed = line.trim();
-            return trimmed && !managedLines.includes(trimmed) && !legacyLines.has(trimmed);
-        });
-        const next = [...normalized, ...managedLines, ''].join('\n');
         const current = fs.readFileSync(gi, 'utf8');
+        const rawLines = current.split(/\r?\n/);
+        const kept = rawLines.filter(line => !legacyLines.has(line.trim()));
+        const present = new Set(kept.map(line => line.trim()));
+        const missing = managedLines.filter(line => !present.has(line));
+        if (kept.length === rawLines.length && missing.length === 0)
+            return;
+        let next = kept.join('\n');
+        if (missing.length) {
+            if (next.length && !next.endsWith('\n'))
+                next += '\n';
+            next += missing.join('\n') + '\n';
+        }
         if (current === next)
             return;
         fs.writeFileSync(gi, next);

package/dist/dashboard/routes/agents.js

@@ -172,6 +172,10 @@ async function buildAgentStatusResponse(config = loadUserConfig(), agentOptions
         const activeProfile = getActiveProfile(agentId);
         const byokProvider = activeProfile ? getProvider(activeProfile.providerId) : null;
         const byokProviderName = byokProvider?.name || null;
+        const byokProfileName = activeProfile
+            && activeProfile.name.trim().toLowerCase() !== activeProfile.modelId.trim().toLowerCase()
+            ? activeProfile.name
+            : null;
         const nativeSelectedModel = runtimeSelectedModel || nativeConfig?.model || null;
         const nativeSelectedEffort = runtimeSelectedEffort || nativeConfig?.effort || null;
         const selectedModel = activeProfile?.modelId || nativeSelectedModel;
@@ -202,6 +206,7 @@ async function buildAgentStatusResponse(config = loadUserConfig(), agentOptions
             nativeConfig,
             byokProviderName,
             byokModels,
+            byokProfileName,
             capabilities: getDriverCapabilities(agentId),
             latestVersion: updateState?.latestVersion || null,
             updateAvailable: updateState?.updateAvailable || false,

package/dist/dashboard/routes/local-models.js

@@ -190,6 +190,123 @@ async function ensureProviderForBackend(spec) {
         return null;
     }
 }
+const OLLAMA_QUANT_FACTOR = 0.7;
+export function parseOllamaSizeToParamsB(token) {
+    const t = token.trim().toLowerCase();
+    let m = t.match(/^(\d+(?:\.\d+)?)x(\d+(?:\.\d+)?)b$/);
+    if (m)
+        return parseFloat(m[1]) * parseFloat(m[2]);
+    m = t.match(/^e(\d+(?:\.\d+)?)b$/);
+    if (m)
+        return parseFloat(m[1]);
+    m = t.match(/^(\d+(?:\.\d+)?)m$/);
+    if (m)
+        return parseFloat(m[1]) / 1000;
+    m = t.match(/^(\d+(?:\.\d+)?)b$/);
+    if (m)
+        return parseFloat(m[1]);
+    return null;
+}
+export function estimateOllamaDiskGb(paramsB) {
+    return Math.round(paramsB * OLLAMA_QUANT_FACTOR * 10) / 10;
+}
+export function estimateOllamaMinRamGb(paramsB) {
+    return Math.max(4, Math.round(paramsB * OLLAMA_QUANT_FACTOR * 1.5 + 4));
+}
+function decodeEntities(s) {
+    return s
+        .replace(/ /g, ' ')
+        .replace(/&/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#0?39;|&#x27;/gi, "'")
+        .replace(/&#(\d+);/g, (_, n) => String.fromCodePoint(Number(n)));
+}
+function allGroups(src, re) {
+    const out = [];
+    let m;
+    while ((m = re.exec(src)))
+        out.push(m[1]);
+    return out;
+}
+export function parseOllamaLibrary(html) {
+    const blocks = html.split('<li x-test-model').slice(1);
+    const out = [];
+    for (const b of blocks) {
+        const name = b.match(/title="([^"]+)"/)?.[1]?.trim();
+        if (!name)
+            continue;
+        const descRaw = b.match(/<p[^>]*max-w-lg[^>]*>([\s\S]*?)<\/p>/)?.[1] ?? '';
+        const description = decodeEntities(descRaw.replace(/<[^>]+>/g, '')).trim();
+        const capabilities = allGroups(b, /x-test-capability[^>]*>([^<]+)</g).map(s => s.trim());
+        const sizes = allGroups(b, /x-test-size[^>]*>([^<]+)</g).map(raw => {
+            const tag = raw.trim();
+            const paramsB = parseOllamaSizeToParamsB(tag);
+            if (paramsB == null)
+                return { tag, paramsB: 0, diskGb: 0, minRamGb: 0 };
+            return { tag, paramsB, diskGb: estimateOllamaDiskGb(paramsB), minRamGb: estimateOllamaMinRamGb(paramsB) };
+        });
+        const pulls = (b.match(/x-test-pull-count[^>]*>([^<]+)</)?.[1] ?? '').trim();
+        const updated = (b.match(/x-test-updated[^>]*>([^<]+)</)?.[1] ?? '').trim();
+        out.push({ name, description, capabilities, sizes, pulls, updated, url: `https://ollama.com/library/${name}` });
+    }
+    return out;
+}
+const OLLAMA_LIBRARY_URL = 'https://ollama.com/library?sort=popular';
+const OLLAMA_LIBRARY_TTL_MS = 6 * 60 * 60 * 1000;
+const OLLAMA_LIBRARY_TIMEOUT_MS = 12000;
+let libraryCache = null;
+let libraryInflight = null;
+async function fetchOllamaLibrary() {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), OLLAMA_LIBRARY_TIMEOUT_MS);
+    try {
+        const res = await fetch(OLLAMA_LIBRARY_URL, {
+            signal: controller.signal,
+            headers: { 'user-agent': 'Mozilla/5.0 (pikiloom local-models)' },
+        });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status}`);
+        const models = parseOllamaLibrary(await res.text());
+        if (!models.length)
+            throw new Error('no models parsed from Ollama library');
+        return models;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function getOllamaLibrary(force) {
+    const fresh = libraryCache && Date.now() - libraryCache.at < OLLAMA_LIBRARY_TTL_MS;
+    if (libraryCache && fresh && !force) {
+        return { models: libraryCache.models, fetchedAt: libraryCache.at, stale: false };
+    }
+    if (!libraryInflight) {
+        libraryInflight = fetchOllamaLibrary()
+            .then(models => { libraryCache = { at: Date.now(), models }; return models; })
+            .finally(() => { libraryInflight = null; });
+    }
+    try {
+        const models = await libraryInflight;
+        return { models, fetchedAt: libraryCache.at, stale: false };
+    }
+    catch (e) {
+        if (libraryCache)
+            return { models: libraryCache.models, fetchedAt: libraryCache.at, stale: true };
+        throw e;
+    }
+}
+router.get('/api/local-models/ollama-library', async (c) => {
+    try {
+        const force = c.req.query('refresh') === '1';
+        const { models, fetchedAt, stale } = await getOllamaLibrary(force);
+        return c.json({ ok: true, models, fetchedAt, stale });
+    }
+    catch (e) {
+        return c.json({ ok: false, error: e?.message || String(e) }, 502);
+    }
+});
 router.get('/api/local-models/probe', async (c) => {
     try {
         const initialProviders = listProviders();

package/dist/dashboard/routes/sessions.js

@@ -4,7 +4,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { Readable } from 'node:stream';
 import { loadUserConfig } from '../../core/config/user-config.js';
-import { listAgents, listSkills, decodeAttachmentPathParam, resolveAllowedAttachmentPath, rewriteAttachmentBlocksForTransport, deliveredArtifactBlocks, mimeForArtifact, } from '../../agent/index.js';
+import { listAgents, listSkills, decodeAttachmentPathParam, resolveAllowedAttachmentPath, rewriteAttachmentBlocksForTransport, deliveredArtifactBlocks, latestDeliveredTaskId, mimeForArtifact, } from '../../agent/index.js';
 import { getSessionStatusForBot } from '../../bot/session-status.js';
 import { findPikiloomSession } from '../../agent/session.js';
 import { readAwaitResume } from '../../agent/await-resume.js';
@@ -405,7 +405,12 @@ function prepareSessionMessagesForDashboard(result, agent, sessionId) {
     }));
     const includesTail = !result.window || !result.window.hasNewer;
     if (includesTail) {
-        const delivered = rewriteAttachmentBlocksForTransport(deliveredArtifactBlocks(agent, sessionId), { agent, sessionId });
+        // Only surface the latest turn's delivered files. Artifacts are persisted in a
+        // session-wide manifest, so without this scope every file ever sent in the session
+        // would be re-appended onto the latest reply (cross-turn image bleed). Legacy
+        // artifacts predating taskId tagging fall back to the full set.
+        const latestTask = latestDeliveredTaskId(agent, sessionId);
+        const delivered = rewriteAttachmentBlocksForTransport(deliveredArtifactBlocks(agent, sessionId, latestTask ? (a => a.taskId === latestTask) : undefined), { agent, sessionId });
         if (delivered.length) {
             const text = deliveredSummaryText(delivered);
             richMessages.push({ role: 'assistant', text, blocks: delivered });

package/dist/model/anthropic-bridge.js

@@ -0,0 +1,419 @@
+import http from 'node:http';
+import { writeScopedLog } from '../core/logging.js';
+const SCOPE = 'anthropic-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; }
+function decodeUpstream(token) {
+    try {
+        return Buffer.from(token, 'base64url').toString('utf8') || null;
+    }
+    catch {
+        return null;
+    }
+}
+function chatCompletionsUrl(base) {
+    const b = base.replace(/\/+$/, '');
+    return b.endsWith('/chat/completions') ? b : `${b}/chat/completions`;
+}
+export async function ensureAnthropicBridge() {
+    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 shutdownAnthropicBridge() {
+    try {
+        server?.close();
+    }
+    catch { }
+    server = null;
+    listenPort = 0;
+}
+function readBearer(req) {
+    const xkey = req.headers['x-api-key'];
+    if (typeof xkey === 'string' && xkey)
+        return xkey;
+    const auth = req.headers['authorization'];
+    const a = Array.isArray(auth) ? auth[0] : auth;
+    if (typeof a === 'string')
+        return a.replace(/^Bearer\s+/i, '');
+    return '';
+}
+function handleRequest(req, res) {
+    const url = new URL(req.url || '/', 'http://127.0.0.1');
+    const m = url.pathname.match(/^\/u\/([^/]+)\/v1\/(messages|messages\/count_tokens|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;
+    }
+    const route = m[2];
+    if (route === 'models') {
+        res.writeHead(200, { 'content-type': 'application/json' });
+        res.end(JSON.stringify({ data: [], has_more: false }));
+        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 = {};
+        }
+        if (route === 'messages/count_tokens') {
+            res.writeHead(200, { 'content-type': 'application/json' });
+            res.end(JSON.stringify({ input_tokens: estimateTokens(body) }));
+            return;
+        }
+        handleMessages(req, res, upstreamBase, body).catch(err => {
+            warn(`handler error: ${err?.message || err}`);
+            sendError(res, `bridge error: ${err?.message || err}`);
+        });
+    });
+}
+async function handleMessages(req, res, upstreamBase, body) {
+    const wantStream = body.stream === true;
+    const chatReq = anthropicToChatRequest(body, wantStream);
+    const key = readBearer(req);
+    const upstreamUrl = chatCompletionsUrl(upstreamBase);
+    log(`-> ${upstreamUrl} model=${chatReq.model} msgs=${chatReq.messages.length} tools=${chatReq.tools?.length ?? 0} stream=${wantStream}`);
+    let upstreamResp;
+    try {
+        upstreamResp = await fetch(upstreamUrl, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json', ...(key ? { authorization: `Bearer ${key}` } : {}) },
+            body: JSON.stringify(chatReq),
+        });
+    }
+    catch (e) {
+        sendError(res, `upstream fetch failed: ${e?.message || e}`);
+        return;
+    }
+    if (!upstreamResp.ok || !upstreamResp.body) {
+        const raw = await upstreamResp.text().catch(() => '');
+        warn(`upstream ${upstreamResp.status}: ${raw.slice(0, 300)}`);
+        sendError(res, `upstream ${upstreamResp.status}: ${raw.slice(0, 500)}`, upstreamResp.status >= 400 ? upstreamResp.status : 502);
+        return;
+    }
+    if (!wantStream) {
+        const data = await upstreamResp.json().catch(() => null);
+        res.writeHead(200, { 'content-type': 'application/json' });
+        res.end(JSON.stringify(chatCompletionToAnthropic(data, chatReq.model)));
+        return;
+    }
+    res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-cache', connection: 'keep-alive' });
+    res.flushHeaders?.();
+    const emit = (type, data) => {
+        res.write(`event: ${type}\n`);
+        res.write(`data: ${JSON.stringify({ type, ...data })}\n\n`);
+    };
+    const msgId = genId('msg');
+    emit('message_start', {
+        message: {
+            id: msgId, type: 'message', role: 'assistant', model: chatReq.model,
+            content: [], stop_reason: null, stop_sequence: null,
+            usage: { input_tokens: 0, output_tokens: 0 },
+        },
+    });
+    let textOpen = false;
+    let textEver = false;
+    const tools = new Map();
+    let usage = null;
+    let finish = null;
+    const reader = upstreamResp.body.getReader();
+    const dec = new TextDecoder();
+    let buf = '';
+    try {
+        for (;;) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            buf += dec.decode(value, { stream: true });
+            let nl;
+            while ((nl = buf.indexOf('\n')) >= 0) {
+                const line = buf.slice(0, nl).trim();
+                buf = buf.slice(nl + 1);
+                if (!line.startsWith('data:'))
+                    continue;
+                const dataStr = line.slice(5).trim();
+                if (dataStr === '[DONE]') {
+                    buf = '';
+                    break;
+                }
+                let chunk;
+                try {
+                    chunk = JSON.parse(dataStr);
+                }
+                catch {
+                    continue;
+                }
+                if (chunk.usage)
+                    usage = chunk.usage;
+                const choice = chunk.choices?.[0];
+                if (!choice)
+                    continue;
+                if (choice.finish_reason)
+                    finish = choice.finish_reason;
+                const delta = choice.delta || {};
+                if (typeof delta.content === 'string' && delta.content) {
+                    if (!textOpen) {
+                        emit('content_block_start', { index: 0, content_block: { type: 'text', text: '' } });
+                        textOpen = true;
+                        textEver = true;
+                    }
+                    emit('content_block_delta', { index: 0, delta: { type: 'text_delta', text: delta.content } });
+                }
+                if (Array.isArray(delta.tool_calls)) {
+                    for (const tc of delta.tool_calls) {
+                        const idx = typeof tc.index === 'number' ? tc.index : 0;
+                        let st = tools.get(idx);
+                        if (!st) {
+                            st = { id: tc.id || genId('toolu'), name: '', args: '' };
+                            tools.set(idx, st);
+                        }
+                        if (tc.id)
+                            st.id = tc.id;
+                        if (tc.function?.name)
+                            st.name += tc.function.name;
+                        if (typeof tc.function?.arguments === 'string')
+                            st.args += tc.function.arguments;
+                    }
+                }
+            }
+        }
+    }
+    catch (e) {
+        warn(`stream read error: ${e?.message || e}`);
+    }
+    if (textOpen)
+        emit('content_block_stop', { index: 0 });
+    if (!textEver && tools.size === 0) {
+        emit('content_block_start', { index: 0, content_block: { type: 'text', text: '' } });
+        emit('content_block_stop', { index: 0 });
+        textEver = true;
+    }
+    let idx = textEver ? 1 : 0;
+    for (const st of tools.values()) {
+        emit('content_block_start', { index: idx, content_block: { type: 'tool_use', id: st.id, name: st.name, input: {} } });
+        emit('content_block_delta', { index: idx, delta: { type: 'input_json_delta', partial_json: st.args.trim() ? st.args : '{}' } });
+        emit('content_block_stop', { index: idx });
+        idx += 1;
+    }
+    const stopReason = tools.size ? 'tool_use' : mapStop(finish);
+    emit('message_delta', {
+        delta: { stop_reason: stopReason, stop_sequence: null },
+        usage: { input_tokens: num(usage?.prompt_tokens), output_tokens: num(usage?.completion_tokens) },
+    });
+    emit('message_stop', {});
+    res.end();
+}
+function sendError(res, message, status = 502) {
+    if (res.headersSent) {
+        try {
+            res.write(`event: error\n`);
+            res.write(`data: ${JSON.stringify({ type: 'error', error: { type: 'api_error', message } })}\n\n`);
+            res.end();
+        }
+        catch { }
+        return;
+    }
+    res.writeHead(status, { 'content-type': 'application/json' });
+    res.end(JSON.stringify({ type: 'error', error: { type: 'api_error', message } }));
+}
+function blockText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((b) => (typeof b === 'string' ? b : (b?.type === 'text' && typeof b.text === 'string' ? b.text : '')))
+            .join('');
+    }
+    return '';
+}
+function anthropicToChatRequest(body, wantStream) {
+    const messages = [];
+    if (body.system) {
+        const sys = typeof body.system === 'string' ? body.system : blockText(body.system);
+        if (sys.trim())
+            messages.push({ role: 'system', content: sys });
+    }
+    for (const m of (Array.isArray(body.messages) ? body.messages : [])) {
+        const role = m?.role;
+        const content = m?.content;
+        if (typeof content === 'string') {
+            messages.push({ role: role === 'assistant' ? 'assistant' : 'user', content });
+            continue;
+        }
+        if (!Array.isArray(content))
+            continue;
+        if (role === 'assistant') {
+            let text = '';
+            const toolCalls = [];
+            for (const b of content) {
+                if (b?.type === 'text')
+                    text += b.text || '';
+                else if (b?.type === 'tool_use') {
+                    toolCalls.push({
+                        id: b.id,
+                        type: 'function',
+                        function: { name: b.name, arguments: JSON.stringify(b.input ?? {}) },
+                    });
+                }
+            }
+            const msg = { role: 'assistant', content: text || null };
+            if (toolCalls.length)
+                msg.tool_calls = toolCalls;
+            messages.push(msg);
+        }
+        else {
+            const toolMsgs = [];
+            const parts = [];
+            for (const b of content) {
+                if (b?.type === 'text')
+                    parts.push({ type: 'text', text: b.text || '' });
+                else if (b?.type === 'image' && b.source) {
+                    const src = b.source;
+                    let url = '';
+                    if (src.type === 'base64' && src.data)
+                        url = `data:${src.media_type || 'image/png'};base64,${src.data}`;
+                    else if (src.type === 'url' && src.url)
+                        url = src.url;
+                    if (url)
+                        parts.push({ type: 'image_url', image_url: { url } });
+                }
+                else if (b?.type === 'tool_result') {
+                    const trText = typeof b.content === 'string' ? b.content : blockText(b.content);
+                    toolMsgs.push({ role: 'tool', tool_call_id: b.tool_use_id, content: trText });
+                }
+            }
+            for (const tm of toolMsgs)
+                messages.push(tm);
+            if (parts.length) {
+                const onlyText = parts.every(p => p.type === 'text');
+                messages.push({ role: 'user', content: onlyText ? parts.map(p => p.text).join('') : parts });
+            }
+        }
+    }
+    const tools = Array.isArray(body.tools) ? body.tools.map(anthropicToolToChat).filter(Boolean) : undefined;
+    const req = { model: body.model, messages, stream: wantStream };
+    if (wantStream)
+        req.stream_options = { include_usage: true };
+    if (tools && tools.length)
+        req.tools = tools;
+    if (body.tool_choice) {
+        const tc = anthropicToolChoiceToChat(body.tool_choice);
+        if (tc)
+            req.tool_choice = tc;
+    }
+    if (typeof body.max_tokens === 'number')
+        req.max_tokens = body.max_tokens;
+    if (typeof body.temperature === 'number')
+        req.temperature = body.temperature;
+    if (typeof body.top_p === 'number')
+        req.top_p = body.top_p;
+    return req;
+}
+function anthropicToolToChat(t) {
+    if (!t || typeof t.name !== 'string' || !t.name)
+        return null;
+    return {
+        type: 'function',
+        function: {
+            name: t.name,
+            description: typeof t.description === 'string' ? t.description : '',
+            parameters: t.input_schema && typeof t.input_schema === 'object' ? t.input_schema : { type: 'object', properties: {} },
+        },
+    };
+}
+function anthropicToolChoiceToChat(tc) {
+    if (!tc || typeof tc !== 'object')
+        return undefined;
+    if (tc.type === 'auto')
+        return 'auto';
+    if (tc.type === 'any')
+        return 'required';
+    if (tc.type === 'tool' && tc.name)
+        return { type: 'function', function: { name: tc.name } };
+    return 'auto';
+}
+function chatCompletionToAnthropic(data, model) {
+    const choice = data?.choices?.[0];
+    const msg = choice?.message || {};
+    const content = [];
+    if (typeof msg.content === 'string' && msg.content)
+        content.push({ type: 'text', text: msg.content });
+    if (Array.isArray(msg.tool_calls)) {
+        for (const tc of msg.tool_calls) {
+            let input = {};
+            try {
+                input = JSON.parse(tc.function?.arguments || '{}');
+            }
+            catch {
+                input = {};
+            }
+            content.push({ type: 'tool_use', id: tc.id || genId('toolu'), name: tc.function?.name || '', input });
+        }
+    }
+    if (!content.length)
+        content.push({ type: 'text', text: '' });
+    const stop = msg.tool_calls?.length ? 'tool_use' : mapStop(choice?.finish_reason || 'stop');
+    return {
+        id: genId('msg'), type: 'message', role: 'assistant', model,
+        content, stop_reason: stop, stop_sequence: null,
+        usage: { input_tokens: num(data?.usage?.prompt_tokens), output_tokens: num(data?.usage?.completion_tokens) },
+    };
+}
+function mapStop(finish) {
+    switch (finish) {
+        case 'length': return 'max_tokens';
+        case 'tool_calls': return 'tool_use';
+        case 'content_filter': return 'end_turn';
+        default: return 'end_turn';
+    }
+}
+function estimateTokens(body) {
+    let chars = 0;
+    if (body?.system)
+        chars += (typeof body.system === 'string' ? body.system : blockText(body.system)).length;
+    for (const m of (Array.isArray(body?.messages) ? body.messages : [])) {
+        chars += blockText(m?.content).length;
+    }
+    return Math.max(1, Math.ceil(chars / 4));
+}