freddie 0.0.41

package/src/agent/compress/tokens.js

@@ -0,0 +1,31 @@
+export const CHARS_PER_TOKEN = 4
+export const IMAGE_TOKEN_ESTIMATE = 1600
+export const IMAGE_CHAR_EQUIVALENT = IMAGE_TOKEN_ESTIMATE * CHARS_PER_TOKEN
+
+const IMAGE_TYPES = new Set(['image_url', 'input_image', 'image'])
+
+export function contentLengthForBudget(content) {
+    if (typeof content === 'string') return content.length
+    if (!Array.isArray(content)) return String(content || '').length
+    let total = 0
+    for (const part of content) {
+        if (typeof part === 'string') { total += part.length; continue }
+        if (!part || typeof part !== 'object') { total += String(part || '').length; continue }
+        if (IMAGE_TYPES.has(part.type)) { total += IMAGE_CHAR_EQUIVALENT; continue }
+        if (typeof part.text === 'string') { total += part.text.length; continue }
+        total += JSON.stringify(part).length
+    }
+    return total
+}
+
+export function estimateMessageTokens(message) {
+    const contentChars = contentLengthForBudget(message?.content)
+    const toolCallsChars = message?.tool_calls ? JSON.stringify(message.tool_calls).length : 0
+    return Math.ceil((contentChars + toolCallsChars + 8) / CHARS_PER_TOKEN)
+}
+
+export function estimateMessagesTokens(messages = []) {
+    let total = 0
+    for (const m of messages) total += estimateMessageTokens(m)
+    return total
+}

package/src/agent/context_references.js

@@ -0,0 +1,40 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { getMessages } from '../sessions.js'
+
+const REF_RE = /@(file:|url:|session:)?(\S+)/g
+
+export async function resolveReferences(text, { cwd = process.cwd(), maxFile = 50_000 } = {}) {
+    if (!text || typeof text !== 'string') return text
+    const refs = [...text.matchAll(REF_RE)]
+    if (!refs.length) return text
+    let out = text
+    for (const r of refs) {
+        const kind = (r[1] || '').replace(':', '') || guessKind(r[2])
+        const target = r[2]
+        const expansion = await expand(kind, target, { cwd, maxFile })
+        if (expansion) out = out.replace(r[0], `${r[0]}\n\n\`\`\`\n${expansion}\n\`\`\``)
+    }
+    return out
+}
+function guessKind(t) {
+    if (/^https?:\/\//.test(t)) return 'url'
+    if (/^[a-f0-9-]{8,}$/.test(t)) return 'session'
+    return 'file'
+}
+async function expand(kind, target, { cwd, maxFile }) {
+    if (kind === 'file') {
+        const p = path.resolve(cwd, target.replace(/^\.\/?/, ''))
+        if (!fs.existsSync(p)) return null
+        const buf = fs.readFileSync(p, 'utf8')
+        return buf.length > maxFile ? buf.slice(0, maxFile) + '\n…[truncated]' : buf
+    }
+    if (kind === 'url') {
+        try { const r = await fetch(target); return (await r.text()).slice(0, maxFile) } catch (e) { return null }
+    }
+    if (kind === 'session') {
+        const msgs = getMessages(target)
+        return msgs.map(m => `[${m.role}] ${m.content}`).join('\n').slice(0, maxFile)
+    }
+    return null
+}

package/src/agent/copilot_acp_client.js

@@ -0,0 +1,6 @@
+export class CopilotAcpClient {
+    constructor({ url, token } = {}) { this.url = url || process.env.COPILOT_ACP_URL; this.token = token || process.env.COPILOT_TOKEN }
+    headers() { return this.token ? { authorization: 'Bearer ' + this.token } : {} }
+    async listModels() { if (!this.url) throw new Error('COPILOT_ACP_URL required'); return await (await fetch(this.url + '/models', { headers: this.headers() })).json() }
+    async chat({ messages, model }) { if (!this.url) throw new Error('COPILOT_ACP_URL required'); return await (await fetch(this.url + '/chat', { method: 'POST', headers: { ...this.headers(), 'content-type': 'application/json' }, body: JSON.stringify({ messages, model }) })).json() }
+}

package/src/agent/credential_pool.js

@@ -0,0 +1,30 @@
+import { parseEnvKeyList } from '../utils.js'
+
+const COOLDOWN_MS = 60_000
+const _state = new Map()
+
+function entry(provider) {
+    if (_state.has(provider)) return _state.get(provider)
+    const keys = parseEnvKeyList(provider.toUpperCase() + '_API_KEYS')
+    const single = process.env[provider.toUpperCase() + '_API_KEY']
+    const all = keys.length ? keys : (single ? [single] : [])
+    const e = { keys: all, idx: 0, blacklist: new Map() }
+    _state.set(provider, e)
+    return e
+}
+export function next(provider) {
+    const e = entry(provider)
+    if (!e.keys.length) return null
+    for (let i = 0; i < e.keys.length; i++) {
+        const k = e.keys[(e.idx + i) % e.keys.length]
+        const until = e.blacklist.get(k) || 0
+        if (Date.now() >= until) { e.idx = (e.idx + i + 1) % e.keys.length; return k }
+    }
+    return null
+}
+export function markFailure(provider, key) {
+    entry(provider).blacklist.set(key, Date.now() + COOLDOWN_MS)
+}
+export function clearBlacklist(provider) { entry(provider).blacklist.clear() }
+export function listKeys(provider) { return [...entry(provider).keys] }
+export function resetForTests() { _state.clear() }

package/src/agent/credential_sources.js

@@ -0,0 +1,18 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { getFophHome } from '../home.js'
+import { getAuthStore } from '../auth.js'
+const ENV_MAP = { anthropic: 'ANTHROPIC_API_KEY', openai: 'OPENAI_API_KEY', groq: 'GROQ_API_KEY', xai: 'XAI_API_KEY', openrouter: 'OPENROUTER_API_KEY', mistral: 'MISTRAL_API_KEY', deepseek: 'DEEPSEEK_API_KEY' }
+export async function resolveKey(provider) {
+    const env = ENV_MAP[provider] || (provider.toUpperCase() + '_API_KEY')
+    if (process.env[env]) return { source: 'env', value: process.env[env] }
+    const stored = await getAuthStore().getCredential(env)
+    if (stored?.value) return { source: 'auth-store', value: stored.value }
+    const dotEnv = path.join(getFophHome(), '.env')
+    if (fs.existsSync(dotEnv)) {
+        const m = fs.readFileSync(dotEnv, 'utf8').match(new RegExp('^' + env + '=(.+)$', 'm'))
+        if (m) return { source: 'dotenv', value: m[1].replace(/^["']|["']$/g, '') }
+    }
+    return { source: 'none', value: null }
+}
+export function listProviders() { return Object.keys(ENV_MAP) }

package/src/agent/curator.js

@@ -0,0 +1,5 @@
+import { db } from '../sessions.js'
+function init() { const d = db(); d.exec(`CREATE TABLE IF NOT EXISTS curated (id INTEGER PRIMARY KEY AUTOINCREMENT, kind TEXT, key TEXT, value TEXT, ts INTEGER NOT NULL)`); return d }
+export function add(kind, key, value) { init().prepare(`INSERT INTO curated (kind, key, value, ts) VALUES (?, ?, ?, ?)`).run(kind, key, JSON.stringify(value), Date.now()); return { added: true } }
+export function list(kind) { return init().prepare(`SELECT * FROM curated WHERE kind = ? ORDER BY id DESC`).all(kind).map(r => ({ ...r, value: JSON.parse(r.value) })) }
+export function clear(kind) { init().prepare(`DELETE FROM curated WHERE kind = ?`).run(kind); return { cleared: kind } }

package/src/agent/display.js

@@ -0,0 +1,23 @@
+import { getActiveSkin } from '../skin/engine.js'
+
+const FRAMES_PER_SECOND = 8
+
+export function spinnerFrames() {
+    const skin = getActiveSkin()
+    return [...skin.spinner.waiting_faces, ...skin.spinner.thinking_faces]
+}
+export function activityPrefix() { return getActiveSkin().tool_prefix || '┊' }
+export function renderActivity(line) { return `${activityPrefix()} ${line}` }
+export function renderResponseLabel() { return getActiveSkin().branding.response_label }
+
+export function startSpinner({ output = process.stdout, label = '' } = {}) {
+    const frames = spinnerFrames()
+    let i = 0
+    const t = setInterval(() => {
+        const f = frames[i++ % frames.length]
+        output.write(`\r${f}  ${label}${' '.repeat(8)}`)
+    }, Math.floor(1000 / FRAMES_PER_SECOND))
+    return {
+        stop() { clearInterval(t); output.write('\r' + ' '.repeat(40 + label.length) + '\r') },
+    }
+}

package/src/agent/error_classifier.js

@@ -0,0 +1,15 @@
+const CLASSES = [
+    [/rate.?limit|429|too many requests/i, 'rate_limit', true],
+    [/context.?length|maximum.?context|token.?limit/i, 'context_overflow', false],
+    [/api.?key|unauthor|401|403/i, 'auth', false],
+    [/timeout|timed out|ETIMEDOUT/i, 'timeout', true],
+    [/connection|ENETUNREACH|ECONNREFUSED|ECONNRESET/i, 'network', true],
+    [/invalid.?json|malformed/i, 'parse', false],
+    [/server error|5\d\d/i, 'server', true],
+]
+export function classifyError(e) {
+    const msg = String(e?.message || e || '')
+    for (const [re, kind, retryable] of CLASSES) if (re.test(msg)) return { kind, retryable, message: msg }
+    return { kind: 'unknown', retryable: false, message: msg }
+}
+export function isRetryable(e) { return classifyError(e).retryable }

package/src/agent/file_safety.js

@@ -0,0 +1,9 @@
+import path from 'node:path'
+const FORBIDDEN_PATTERNS = [/(^|[\\/])etc[\\/]passwd$/i, /(^|[\\/])etc[\\/]shadow$/i, /[\\/]\.ssh[\\/]id_/i, /[\\/]\.aws[\\/]credentials$/i, /[\\/]\.docker[\\/]config\.json$/i, /[\\/]\.npmrc$/i, /[\\/]\.pypirc$/i]
+export function checkFileSafety(p, { cwd = process.cwd(), op = 'read' } = {}) {
+    const abs = path.resolve(cwd, p)
+    const norm = abs.replace(/\\/g, '/')
+    for (const re of FORBIDDEN_PATTERNS) if (re.test(norm)) return { safe: false, reason: 'matches forbidden pattern: ' + re.source }
+    if (op === 'write' && /^\/(bin|usr|etc|sys|proc)\//i.test(norm)) return { safe: false, reason: 'system path write blocked' }
+    return { safe: true, abs }
+}

package/src/agent/gemini_cloudcode_adapter.js

@@ -0,0 +1,9 @@
+import { resolveKey } from './credential_sources.js'
+const ENDPOINT = 'https://cloudcode-pa.googleapis.com/v1internal:generateContent'
+export async function chat({ messages, model = 'gemini-2.5-pro' } = {}) {
+    const k = await resolveKey('google_oauth')
+    if (!k.value) throw new Error('GOOGLE_OAUTH_TOKEN required for cloudcode')
+    const r = await fetch(ENDPOINT, { method: 'POST', headers: { authorization: 'Bearer ' + k.value, 'content-type': 'application/json' }, body: JSON.stringify({ model, messages }) })
+    return await r.json()
+}
+export const provider = 'gemini_cloudcode'

package/src/agent/gemini_native_adapter.js

@@ -0,0 +1,11 @@
+import { resolveKey } from './credential_sources.js'
+import { adaptToolForGemini, adaptMessagesForGemini } from './gemini_schema.js'
+export async function chat({ messages, model = 'gemini-2.5-flash', tools = [] } = {}) {
+    const k = await resolveKey('google')
+    if (!k.value) throw new Error('GOOGLE_API_KEY required')
+    const url = 'https://generativelanguage.googleapis.com/v1beta/models/' + model + ':generateContent?key=' + k.value
+    const body = { contents: adaptMessagesForGemini(messages), ...(tools.length ? { tools: [{ function_declarations: tools.map(adaptToolForGemini) }] } : {}) }
+    const r = await fetch(url, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) })
+    return await r.json()
+}
+export const provider = 'google'

package/src/agent/gemini_schema.js

@@ -0,0 +1,19 @@
+function clean(o) {
+    if (Array.isArray(o)) return o.map(clean)
+    if (!o || typeof o !== 'object') return o
+    const out = {}
+    for (const [k, v] of Object.entries(o)) {
+        if (k === '$schema' || k === 'additionalProperties' || k === '$ref' || k === 'oneOf' || k === 'anyOf') continue
+        out[k] = clean(v)
+    }
+    return out
+}
+export function adaptToolForGemini(tool) {
+    return { name: tool.name, description: tool.description || '', parameters: clean(tool.input_schema || tool.parameters || { type: 'object', properties: {} }) }
+}
+export function adaptMessagesForGemini(messages) {
+    return messages.filter(m => m.role !== 'system').map(m => ({
+        role: m.role === 'assistant' ? 'model' : 'user',
+        parts: typeof m.content === 'string' ? [{ text: m.content }] : (Array.isArray(m.content) ? m.content.map(p => p.text ? { text: p.text } : p) : [{ text: JSON.stringify(m.content) }]),
+    }))
+}

package/src/agent/google_code_assist.js

@@ -0,0 +1,8 @@
+import { getToken } from './google_oauth.js'
+const ENDPOINT = 'https://cloudcode-pa.googleapis.com/v1internal'
+export async function complete({ prompt, language = 'auto' } = {}) {
+    const t = (await getToken()).value
+    if (!t) throw new Error('GOOGLE_OAUTH_TOKEN required')
+    const r = await fetch(ENDPOINT + ':complete', { method: 'POST', headers: { authorization: 'Bearer ' + t, 'content-type': 'application/json' }, body: JSON.stringify({ prompt, language }) })
+    return await r.json()
+}

package/src/agent/google_oauth.js

@@ -0,0 +1,21 @@
+import { getAuthStore } from '../auth.js'
+const KEY = 'GOOGLE_OAUTH_TOKEN'
+const REFRESH_KEY = 'GOOGLE_OAUTH_REFRESH'
+export async function getToken() {
+    if (process.env.GOOGLE_OAUTH_TOKEN) return { source: 'env', value: process.env.GOOGLE_OAUTH_TOKEN }
+    const stored = await getAuthStore().getCredential(KEY)
+    return stored?.value ? { source: 'auth-store', value: stored.value } : { source: 'none', value: null }
+}
+export async function setToken(token, refreshToken = null) {
+    await getAuthStore().setCredential(KEY, token)
+    if (refreshToken) await getAuthStore().setCredential(REFRESH_KEY, refreshToken)
+    return { stored: true }
+}
+export async function refresh({ clientId, clientSecret } = {}) {
+    const refreshToken = (await getAuthStore().getCredential(REFRESH_KEY))?.value
+    if (!refreshToken) return { error: 'no refresh token' }
+    const r = await fetch('https://oauth2.googleapis.com/token', { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' }, body: new URLSearchParams({ grant_type: 'refresh_token', refresh_token: refreshToken, client_id: clientId, client_secret: clientSecret }).toString() })
+    const j = await r.json()
+    if (j.access_token) await setToken(j.access_token)
+    return j
+}

package/src/agent/image_gen_provider.js

@@ -0,0 +1,8 @@
+import { resolveKey } from './credential_sources.js'
+const PROVIDERS = {
+    openai: async ({ prompt, size, model }) => { const k = (await resolveKey('openai')).value; const r = await fetch('https://api.openai.com/v1/images/generations', { method: 'POST', headers: { authorization: 'Bearer ' + k, 'content-type': 'application/json' }, body: JSON.stringify({ model: model || 'gpt-image-1', prompt, size }) }); return await r.json() },
+    replicate: async ({ prompt, model }) => { const k = process.env.REPLICATE_API_TOKEN; const r = await fetch('https://api.replicate.com/v1/predictions', { method: 'POST', headers: { authorization: 'Token ' + k, 'content-type': 'application/json' }, body: JSON.stringify({ version: model || 'black-forest-labs/flux-schnell', input: { prompt } }) }); return await r.json() },
+    stability: async ({ prompt, model }) => { const k = process.env.STABILITY_API_KEY; const r = await fetch('https://api.stability.ai/v2beta/stable-image/generate/' + (model || 'core'), { method: 'POST', headers: { authorization: 'Bearer ' + k, accept: 'application/json' }, body: (() => { const fd = new FormData(); fd.append('prompt', prompt); return fd })() }); return await r.json() },
+}
+export async function generate({ provider = 'openai', ...args } = {}) { const fn = PROVIDERS[provider]; if (!fn) throw new Error('unknown image provider: ' + provider); return await fn(args) }
+export function listProviders() { return Object.keys(PROVIDERS) }

package/src/agent/image_gen_registry.js

@@ -0,0 +1,6 @@
+import { generate, listProviders } from './image_gen_provider.js'
+const _generations = []
+export async function generateAndRecord(args) { const out = await generate(args); _generations.push({ ts: Date.now(), provider: args.provider || 'openai', prompt: args.prompt, result: out }); return out }
+export function listGenerations(limit = 50) { return _generations.slice(-limit).reverse() }
+export function clearGenerations() { _generations.length = 0 }
+export { listProviders }

package/src/agent/image_routing.js

@@ -0,0 +1,13 @@
+const ROUTERS = {
+    anthropic: (parts) => parts.map(p => p.type === 'image_url' ? { type: 'image', source: { type: 'base64', media_type: p.image_url?.media_type || 'image/png', data: p.image_url?.url?.split(',').pop() || '' } } : p),
+    openai: (parts) => parts.map(p => p.type === 'image' ? { type: 'image_url', image_url: { url: typeof p.source === 'string' ? p.source : ('data:' + (p.source?.media_type || 'image/png') + ';base64,' + (p.source?.data || '')) } } : p),
+    google: (parts) => parts.map(p => p.type === 'image_url' ? { inline_data: { mime_type: p.image_url?.media_type || 'image/png', data: p.image_url?.url?.split(',').pop() || '' } } : p),
+}
+export function routeImagesNative(messages, provider = 'anthropic') {
+    const router = ROUTERS[provider] || ((p) => p)
+    return messages.map(m => {
+        if (!Array.isArray(m.content)) return m
+        return { ...m, content: router(m.content) }
+    })
+}
+export function listImageProviders() { return Object.keys(ROUTERS) }

package/src/agent/insights.js

@@ -0,0 +1,9 @@
+import { db } from '../sessions.js'
+import { calculateCost } from './usage_pricing.js'
+export function modelInsights() {
+    const rows = db().prepare(`SELECT model, SUM(prompt_tokens) AS p, SUM(completion_tokens) AS c, SUM(cost_usd) AS cost, COUNT(*) AS calls FROM account_usage GROUP BY model`).all()
+    return rows.map(r => ({ ...r, has_pricing: calculateCost({ model: r.model, prompt_tokens: 1, completion_tokens: 1 }) > 0 }))
+}
+export function sessionInsights(sessionId) {
+    return db().prepare(`SELECT model, SUM(prompt_tokens) AS p, SUM(completion_tokens) AS c, SUM(cost_usd) AS cost FROM account_usage WHERE session_id = ? GROUP BY model`).all(sessionId)
+}

package/src/agent/llm_resolver.js

@@ -0,0 +1,21 @@
+import { callLLM as acptoapiCall, isReachable as acptoapiReachable } from './acptoapi-bridge.js'
+import { callLLM as piCall } from './pi-bridge.js'
+
+const KEYS = { anthropic: 'ANTHROPIC_API_KEY', openai: 'OPENAI_API_KEY', groq: 'GROQ_API_KEY', openrouter: 'OPENROUTER_API_KEY' }
+
+export function resolveCallLLM({ provider, model } = {}) {
+    return async (input) => {
+        const explicitProvider = provider || input.provider
+        const explicitKey = explicitProvider && KEYS[explicitProvider] ? process.env[KEYS[explicitProvider]] : null
+        if (explicitProvider && explicitKey) {
+            return await piCall({ ...input, provider: explicitProvider, model: model || input.model })
+        }
+        if (await acptoapiReachable()) {
+            return await acptoapiCall({ ...input, model: model || input.model })
+        }
+        for (const [p, k] of Object.entries(KEYS)) {
+            if (process.env[k]) return await piCall({ ...input, provider: p, model: model || input.model })
+        }
+        throw new Error('no LLM backend reachable: start acptoapi (http://127.0.0.1:4800/v1) or set ANTHROPIC_API_KEY/OPENAI_API_KEY/GROQ_API_KEY/OPENROUTER_API_KEY')
+    }
+}

package/src/agent/lmstudio_reasoning.js

@@ -0,0 +1,13 @@
+export function extractReasoning(content) {
+    const tags = [/<think>([\s\S]*?)<\/think>/g, /<reasoning>([\s\S]*?)<\/reasoning>/g]
+    const reasoning = []
+    let cleaned = String(content || '')
+    for (const re of tags) {
+        for (const m of cleaned.matchAll(re)) reasoning.push(m[1])
+        cleaned = cleaned.replace(re, '')
+    }
+    return { reasoning: reasoning.join('\n').trim(), content: cleaned.trim() }
+}
+export function isLmStudio(provider, baseUrl) {
+    return provider === 'lmstudio' || /(^|\.)lmstudio\.|:1234\b|:8000\b/.test(String(baseUrl || ''))
+}

package/src/agent/machine.js

@@ -0,0 +1,102 @@
+import { createMachine, createActor, assign, fromPromise } from 'xstate'
+import { registry } from '../tools/registry.js'
+import { getEnabledToolSchemas } from '../toolsets.js'
+import { logger } from '../observability/log.js'
+import { resolveCallLLM } from './llm_resolver.js'
+
+const log = logger('agent')
+
+export function createAgentMachine({ provider, model, maxIterations = 90, callLLM, enabledToolsets = ['core'], disabledToolsets = [] } = {}) {
+    const llm = callLLM || resolveCallLLM({ provider, model })
+    return createMachine({
+        id: 'freddie-agent',
+        initial: 'idle',
+        output: ({ context }) => ({ messages: context.messages, result: context.lastResult, error: context.error, iterations: context.iterations }),
+        context: ({ input }) => ({
+            messages: input?.messages ? [...input.messages] : [],
+            iterations: 0,
+            maxIterations,
+            interrupt: false,
+            lastResult: null,
+            error: null,
+            provider, model,
+            enabledToolsets, disabledToolsets,
+        }),
+        states: {
+            idle: {
+                on: {
+                    SUBMIT: {
+                        target: 'prompting',
+                        actions: assign({
+                            messages: ({ context, event }) => [...context.messages, { role: 'user', content: event.prompt }],
+                            iterations: 0, interrupt: false, error: null,
+                        }),
+                    },
+                    INTERRUPT: { actions: assign({ interrupt: true }) },
+                },
+            },
+            prompting: {
+                invoke: {
+                    src: fromPromise(async ({ input }) => {
+                        const schemas = await getEnabledToolSchemas(input.enabledToolsets, input.disabledToolsets)
+                        return llm({ messages: input.messages, tools: schemas, model: input.model, provider: input.provider })
+                    }),
+                    input: ({ context }) => ({ messages: context.messages, model: context.model, provider: context.provider, enabledToolsets: context.enabledToolsets, disabledToolsets: context.disabledToolsets }),
+                    onDone: [
+                        { guard: ({ event }) => Array.isArray(event.output?.tool_calls) && event.output.tool_calls.length > 0, target: 'tool_calls', actions: assign({ messages: ({ context, event }) => [...context.messages, { role: 'assistant', content: event.output.content || '', tool_calls: event.output.tool_calls }] }) },
+                        { target: 'done', actions: assign({ messages: ({ context, event }) => [...context.messages, { role: 'assistant', content: event.output.content || '' }], lastResult: ({ event }) => event.output.content || '' }) },
+                    ],
+                    onError: { target: 'done', actions: assign({ error: ({ event }) => String(event.error?.message || event.error) }) },
+                },
+            },
+            tool_calls: {
+                always: [
+                    { guard: ({ context }) => context.iterations >= context.maxIterations, target: 'done', actions: assign({ error: 'iteration budget exhausted' }) },
+                    { guard: ({ context }) => context.interrupt, target: 'done', actions: assign({ error: 'interrupted' }) },
+                    { target: 'executing_tools' },
+                ],
+            },
+            executing_tools: {
+                invoke: {
+                    src: fromPromise(async ({ input }) => {
+                        const last = input.messages[input.messages.length - 1]
+                        const calls = last.tool_calls || []
+                        const results = []
+                        for (const call of calls) {
+                            const res = await registry.dispatch(call.name || call.function?.name, call.arguments || call.function?.arguments || {})
+                            results.push({ tool_call_id: call.id || call.tool_call_id, content: res })
+                        }
+                        return results
+                    }),
+                    input: ({ context }) => ({ messages: context.messages }),
+                    onDone: { target: 'prompting', actions: assign({
+                        messages: ({ context, event }) => [...context.messages, ...event.output.map(r => ({ role: 'tool', tool_call_id: r.tool_call_id, content: r.content }))],
+                        iterations: ({ context }) => context.iterations + 1,
+                    }) },
+                    onError: { target: 'done', actions: assign({ error: ({ event }) => String(event.error?.message || event.error) }) },
+                },
+            },
+            done: {
+                type: 'final',
+                output: ({ context }) => ({ messages: context.messages, result: context.lastResult, error: context.error, iterations: context.iterations }),
+            },
+        },
+    })
+}
+
+export async function runTurn({ prompt, messages = [], model, provider, callLLM, enabledToolsets, disabledToolsets, maxIterations = 90, timeoutMs = 30000 } = {}) {
+    const machine = createAgentMachine({ model, provider, callLLM, enabledToolsets, disabledToolsets, maxIterations })
+    const actor = createActor(machine, { input: { messages } })
+    actor.start()
+    actor.send({ type: 'SUBMIT', prompt })
+    return await new Promise((resolve, reject) => {
+        const t = setTimeout(() => { try { actor.stop() } catch {} reject(new Error('agent turn timeout')) }, timeoutMs)
+        actor.subscribe(snap => {
+            if (snap.status === 'done') {
+                clearTimeout(t)
+                resolve(snap.output)
+            }
+        })
+    })
+}
+

package/src/agent/manual_compression_feedback.js

@@ -0,0 +1,5 @@
+import { db } from '../sessions.js'
+function init() { const d = db(); d.exec(`CREATE TABLE IF NOT EXISTS compression_feedback (id INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT, summary TEXT, rating INTEGER, notes TEXT, ts INTEGER NOT NULL)`); return d }
+export function record({ sessionId, summary, rating, notes = '' }) { init().prepare(`INSERT INTO compression_feedback (session_id, summary, rating, notes, ts) VALUES (?, ?, ?, ?, ?)`).run(sessionId, summary || '', rating, notes, Date.now()); return { recorded: true } }
+export function listForSession(sessionId) { return init().prepare(`SELECT * FROM compression_feedback WHERE session_id = ? ORDER BY id DESC`).all(sessionId) }
+export function aggregate() { return init().prepare(`SELECT AVG(rating) AS avg, COUNT(*) AS n FROM compression_feedback`).get() }

package/src/agent/memory_manager.js

@@ -0,0 +1,14 @@
+import { createMemoryProvider, listMemoryProviders } from '../plugins/memory/provider.js'
+import { getConfigValue } from '../config.js'
+let _provider = null
+export function getMemoryProvider() {
+    if (_provider) return _provider
+    const name = getConfigValue('memory.provider')
+    if (!name) return null
+    try { _provider = createMemoryProvider(name, getConfigValue('memory.options', {})) } catch { _provider = null }
+    return _provider
+}
+export async function syncTurnIfConfigured(messages) { const p = getMemoryProvider(); if (p) try { return await p.syncTurn(messages) } catch (e) { return { error: String(e.message || e) } } return null }
+export async function prefetchIfConfigured(query) { const p = getMemoryProvider(); if (p) try { return await p.prefetch(query) } catch { return { items: [] } } return { items: [] } }
+export function listAvailable() { return listMemoryProviders() }
+export function resetForTests() { _provider = null }

package/src/agent/memory_provider.js

@@ -0,0 +1 @@
+export { MemoryProvider, registerMemoryProvider, listMemoryProviders, createMemoryProvider } from '../plugins/memory/provider.js'

package/src/agent/model_metadata.js

@@ -0,0 +1,28 @@
+export const MINIMUM_CONTEXT_LENGTH = 8000
+const TABLE = {
+    'claude-opus-4-7': 1_000_000, 'claude-sonnet-4-6': 200_000, 'claude-haiku-4-5': 200_000,
+    'claude-3-5-sonnet': 200_000, 'claude-3-5-haiku': 200_000, 'claude-3-opus': 200_000,
+    'gpt-5': 400_000, 'gpt-5-mini': 400_000, 'gpt-4o': 128_000, 'gpt-4o-mini': 128_000, 'gpt-4-turbo': 128_000,
+    'o1': 200_000, 'o1-mini': 128_000, 'o3': 200_000, 'o3-mini': 200_000,
+    'gemini-2.5-pro': 2_000_000, 'gemini-2.5-flash': 1_000_000, 'gemini-2.0-flash': 1_000_000,
+    'llama-3.3-70b': 128_000, 'llama-3.1-405b': 128_000,
+    'grok-2': 128_000, 'grok-3': 1_000_000, 'grok-4': 256_000,
+    'deepseek-v3': 64_000, 'deepseek-r1': 128_000,
+    'qwen-2.5-72b': 128_000, 'qwen-3-coder': 256_000,
+}
+export function getModelContextLength(model) {
+    if (!model) return MINIMUM_CONTEXT_LENGTH
+    if (TABLE[model]) return TABLE[model]
+    for (const [k, v] of Object.entries(TABLE)) if (model.startsWith(k)) return v
+    return MINIMUM_CONTEXT_LENGTH
+}
+export function estimateMessagesTokensRough(messages = []) {
+    let chars = 0
+    for (const m of messages) {
+        const c = m?.content
+        if (typeof c === 'string') chars += c.length
+        else if (Array.isArray(c)) for (const p of c) chars += typeof p === 'string' ? p.length : (p?.text?.length || 100)
+        if (m?.tool_calls) chars += JSON.stringify(m.tool_calls).length
+    }
+    return Math.ceil(chars / 4)
+}

package/src/agent/models_dev.js

@@ -0,0 +1,13 @@
+let _cache = null
+const ENDPOINT = 'https://models.dev/api/models.json'
+export async function fetchModels({ refresh = false } = {}) {
+    if (_cache && !refresh) return _cache
+    try { const r = await fetch(ENDPOINT); _cache = await r.json(); return _cache } catch { return _cache || {} }
+}
+export async function findModel(slug) {
+    const data = await fetchModels()
+    if (Array.isArray(data)) return data.find(m => m.slug === slug || m.id === slug) || null
+    if (data && typeof data === 'object') return data[slug] || null
+    return null
+}
+export function clearCache() { _cache = null }

package/src/agent/moonshot_schema.js

@@ -0,0 +1,11 @@
+export function adaptToolSchema(tool) {
+    const s = { type: 'function', function: { name: tool.name, description: tool.description, parameters: tool.input_schema || tool.parameters || { type: 'object', properties: {} } } }
+    if (s.function.parameters.required && !s.function.parameters.required.length) delete s.function.parameters.required
+    return s
+}
+export function adaptMessages(messages) {
+    return messages.map(m => {
+        if (m.role === 'tool') return { role: 'tool', tool_call_id: m.tool_call_id, content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content) }
+        return m
+    })
+}

package/src/agent/oauth_endpoints.js

@@ -0,0 +1,79 @@
+import { decodeJwtClaims } from '../auth.js'
+
+const KIMI_BASE_URLS = {
+    intl: 'https://api.moonshot.ai/v1',
+    cn: 'https://api.moonshot.cn/v1',
+}
+
+const ZAI_BASE_URLS = {
+    bigmodel: 'https://open.bigmodel.cn/api/paas/v4',
+    z: 'https://api.z.ai/api/paas/v4',
+}
+
+export function resolveKimiBaseUrl({ region } = {}) {
+    if (process.env.KIMI_BASE_URL) return process.env.KIMI_BASE_URL
+    const r = (region || process.env.KIMI_REGION || 'intl').toLowerCase()
+    return KIMI_BASE_URLS[r] || KIMI_BASE_URLS.intl
+}
+
+export function resolveZaiBaseUrl({ endpoint } = {}) {
+    if (process.env.ZAI_BASE_URL) return process.env.ZAI_BASE_URL
+    const e = (endpoint || process.env.ZAI_ENDPOINT || '').toLowerCase()
+    if (e.includes('z.ai')) return ZAI_BASE_URLS.z
+    if (e.includes('bigmodel')) return ZAI_BASE_URLS.bigmodel
+    return ZAI_BASE_URLS.bigmodel
+}
+
+export async function detectZaiEndpoint(apiKey) {
+    if (!apiKey) return 'bigmodel'
+    for (const [name, base] of Object.entries(ZAI_BASE_URLS)) {
+        try {
+            const res = await fetch(base + '/models', { headers: { authorization: 'Bearer ' + apiKey }, signal: AbortSignal.timeout(3000) })
+            if (res.ok) return name
+        } catch {}
+    }
+    return 'bigmodel'
+}
+
+export function isCodexAccessTokenExpiring(token, { skewSeconds = 60 } = {}) {
+    const claims = decodeJwtClaims(typeof token === 'string' ? token : (token?.access_token || ''))
+    if (!claims) return true
+    if (!claims.exp) return false
+    return claims.exp - Math.floor(Date.now() / 1000) < skewSeconds
+}
+
+export async function refreshOauthToken({ tokenUrl, clientId, refreshToken, clientSecret } = {}) {
+    if (!tokenUrl || !refreshToken) throw new Error('tokenUrl and refreshToken required')
+    const body = new URLSearchParams({ grant_type: 'refresh_token', refresh_token: refreshToken })
+    if (clientId) body.set('client_id', clientId)
+    if (clientSecret) body.set('client_secret', clientSecret)
+    const res = await fetch(tokenUrl, { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' }, body: body.toString() })
+    if (!res.ok) throw new Error('refresh failed: ' + res.status + ' ' + await res.text())
+    const j = await res.json()
+    if (j.expires_in && !j.expires_at) j.expires_at = Math.floor(Date.now() / 1000) + j.expires_in
+    return j
+}
+
+export function buildAuthorizeUrl({ authorizeUrl, clientId, redirectUri, scope, state, codeChallenge, codeChallengeMethod = 'S256' } = {}) {
+    const u = new URL(authorizeUrl)
+    u.searchParams.set('response_type', 'code')
+    u.searchParams.set('client_id', clientId)
+    u.searchParams.set('redirect_uri', redirectUri)
+    if (scope) u.searchParams.set('scope', scope)
+    if (state) u.searchParams.set('state', state)
+    if (codeChallenge) { u.searchParams.set('code_challenge', codeChallenge); u.searchParams.set('code_challenge_method', codeChallengeMethod) }
+    return u.toString()
+}
+
+export async function exchangeCodeForToken({ tokenUrl, clientId, code, redirectUri, codeVerifier, clientSecret } = {}) {
+    const body = new URLSearchParams({ grant_type: 'authorization_code', code, redirect_uri: redirectUri, client_id: clientId })
+    if (codeVerifier) body.set('code_verifier', codeVerifier)
+    if (clientSecret) body.set('client_secret', clientSecret)
+    const res = await fetch(tokenUrl, { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' }, body: body.toString() })
+    if (!res.ok) throw new Error('token exchange failed: ' + res.status + ' ' + await res.text())
+    const j = await res.json()
+    if (j.expires_in && !j.expires_at) j.expires_at = Math.floor(Date.now() / 1000) + j.expires_in
+    return j
+}
+
+export { KIMI_BASE_URLS, ZAI_BASE_URLS }

package/src/agent/onboarding.js

@@ -0,0 +1,16 @@
+import { getConfigValue, saveConfigValue } from '../config.js'
+import { getAuthStore } from '../auth.js'
+const STEPS = ['provider', 'api-key', 'model', 'skin', 'memory']
+export async function isOnboardingComplete() { return Boolean(getConfigValue('onboarding.completed')) }
+export async function nextStep() {
+    if (!getConfigValue('agent.provider')) return 'provider'
+    const provider = getConfigValue('agent.provider')
+    const env = (provider || '').toUpperCase() + '_API_KEY'
+    if (!process.env[env] && !(await getAuthStore().getCredential(env))) return 'api-key'
+    if (!getConfigValue('agent.model')) return 'model'
+    if (!getConfigValue('display.skin')) return 'skin'
+    if (!getConfigValue('memory.provider')) return 'memory'
+    return null
+}
+export async function markComplete() { saveConfigValue('onboarding.completed', Date.now()) }
+export const ONBOARDING_STEPS = STEPS