pikiloom 0.4.31 → 0.4.33

package/dist/agent/stream.js

@@ -167,6 +167,7 @@ export async function run(cmd, opts, parseLine, parseStderrLine) {
         contextWindow: byokWindow,
         byokContextWindow: byokWindow,
         byokProviderName: byokProvider,
+        byokProfileName: (opts.byokProfileName || null),
         contextUsedTokens: null,
         codexCumulative: null,
         stopReason: null, activity: '',
@@ -473,8 +474,13 @@ export async function doStream(opts) {
             agentLog(`[byok] ${injection.detail}`);
         }
         const activeProfile = getActiveProfile(prepared.agent);
-        if (activeProfile?.effort) {
-            prepared.thinkingEffort = activeProfile.effort;
+        if (activeProfile) {
+            if (activeProfile.effort)
+                prepared.thinkingEffort = activeProfile.effort;
+            const profileLabel = activeProfile.name?.trim();
+            if (profileLabel && profileLabel !== activeProfile.modelId) {
+                prepared.byokProfileName = profileLabel;
+            }
         }
     }
     catch (e) {
@@ -500,6 +506,8 @@ export async function doStream(opts) {
         await awaitAgentUpdateIdle(prepared.agent, AGENT_UPDATE_TIMEOUTS.spawnWait);
         const result = await driver.doStream(prepared);
         const finalized = finalizeStreamResult(result, opts.workdir, opts.prompt, session, opts.claudeWorkflowEnabled);
+        finalized.byokProviderName = prepared.byokProviderName ?? null;
+        finalized.byokProfileName = prepared.byokProfileName ?? null;
         if (opts.forkOf && finalized.sessionId) {
             try {
                 recordFork(opts.workdir, {
@@ -537,6 +545,8 @@ export async function doStream(opts) {
             incomplete: true,
             activity: null,
             plan: null,
+            byokProviderName: prepared.byokProviderName ?? null,
+            byokProfileName: prepared.byokProfileName ?? null,
         };
         const failureDisplayPrompt = collapseSkillPrompt(opts.prompt) ?? opts.prompt;
         session.record.lastQuestion = shortValue(failureDisplayPrompt, 500);

package/dist/agent/utils.js

@@ -223,6 +223,8 @@ export function buildStreamPreviewMeta(s) {
         meta.turnOutputTokens = turnOutput;
     if (s.byokProviderName)
         meta.providerName = s.byokProviderName;
+    if (s.byokProfileName)
+        meta.profileName = s.byokProfileName;
     if (s.subAgents && s.subAgents.size > 0)
         meta.subAgents = Array.from(s.subAgents.values());
     if (s.generatingImages && s.generatingImages > 0)

package/dist/bot/bot.js

@@ -4,7 +4,7 @@ import { execSync, spawn } from 'node:child_process';
 import { getActiveUserConfig, loadWorkspaces, onUserConfigChange, resolveUserWorkdir, setUserWorkdir, updateUserConfig } from '../core/config/user-config.js';
 import { doStream, ensureManagedSession, findManagedThreadSession, getSessionStoredConfig, getUsage, initializeProjectSkills, listAgents, resolveAgentModels, resolveDefaultAgent, listSkills, stageSessionFiles, reconcileOrphanedRunningSessions, getAgentBoundModelId, setAgentBoundModelId, collapseSkillPrompt, readGoal, accountTurn, shouldContinueAfterTurn, renderContinuationPrompt, renderBudgetLimitPrompt, bumpContinuationCount, pauseGoal, resumeGoal, setGoal as setGoalState, clearGoal as clearGoalState, setCodexGoal, getCodexGoal, clearCodexGoal, pauseCodexGoal, resumeCodexGoal, getClaudeNativeGoal, buildClaudeSetGoalPrompt, buildClaudeClearGoalPrompt, deliverArtifact, attachmentUrl, isPendingSessionId, } from '../agent/index.js';
 import { compactForHandover, describeHandoverRef } from '../agent/handover.js';
-import { getActiveProfileId, setActiveProfile } from '../model/index.js';
+import { getActiveProfileId, getActiveProfile, setActiveProfile } from '../model/index.js';
 import { querySessions, querySessionTail, updateSession, } from './session-hub.js';
 import { getDriver, hasDriver, allDriverIds, getDriverCapabilities } from '../agent/driver.js';
 import { resolveGuiIntegrationConfig } from '../agent/mcp/bridge.js';
@@ -1689,6 +1689,9 @@ export class Bot {
         this.log(`workflow ${enabled ? 'enabled' : 'disabled'} for ${cs.agent} chat=${chatId}`);
     }
     modelForAgent(agent) {
+        const profile = getActiveProfile(agent);
+        if (profile?.modelId)
+            return profile.modelId;
         if (agent === 'hermes') {
             const bound = getAgentBoundModelId('hermes');
             if (bound)

package/dist/bot/render-shared.js

@@ -48,8 +48,9 @@ function compactModelLabel(model) {
 }
 export function formatFooterParts(agent, elapsedMs, meta, contextPercent, decorations) {
     const identityParts = [agent];
-    if (decorations?.model)
-        identityParts.push(compactModelLabel(decorations.model));
+    const modelLabel = decorations?.profileName ?? meta?.profileName ?? decorations?.model ?? null;
+    if (modelLabel)
+        identityParts.push(compactModelLabel(modelLabel));
     const runtimeParts = [];
     if (decorations?.effort)
         runtimeParts.push(decorations.effort);

package/dist/channels/feishu/render.js

@@ -232,6 +232,8 @@ export function buildFinalReplyRender(agent, result) {
     const footerText = `\n\n${formatFinalFooter(data.footerStatus, agent, data.elapsedMs, result.contextPercent ?? null, {
         model: result.model,
         effort: result.thinkingEffort,
+        provider: result.byokProviderName,
+        profileName: result.byokProfileName,
     })}`;
     let activityText = '';
     let activityNoteText = '';

package/dist/channels/telegram/render.js

@@ -372,6 +372,8 @@ export function buildFinalReplyRender(agent, result) {
     const footerHtml = `\n\n${formatFinalFooterHtml(data.footerStatus, agent, data.elapsedMs, result.contextPercent ?? null, {
         model: result.model,
         effort: result.thinkingEffort,
+        provider: result.byokProviderName,
+        profileName: result.byokProfileName,
     })}`;
     let activityHtml = '';
     let activityNoteHtml = '';

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/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));
+}