freddie 0.0.97 → 0.0.99

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freddie",
-  "version": "0.0.97",
+  "version": "0.0.99",
   "type": "module",
   "description": "Open JS agent harness built on pi-mono, floosie, xstate, and anentrypoint-design",
   "bin": {
@@ -27,7 +27,7 @@
     "xstate": "^5.31.0",
     "zod": "^4.0.0",
     "anentrypoint-design": "^0.0.94",
-    "acptoapi": "^1.0.56"
+    "acptoapi": "^1.0.61"
   },
   "optionalDependencies": {
     "@libsql/darwin-arm64": "0.3.19",

package/plugins/gui-llm-passthrough/plugin.js

@@ -1,44 +1,44 @@
-import { resolveCallLLM } from '../../src/agent/llm_resolver.js'
+import { createRequire } from 'module'
+import { getConfigValue } from '../../src/config.js'
+import { MATRIX_FILE } from '../../src/agent/model-matrix.js'
 import { flattenForOpenAI } from '../../src/agent/model-discovery.js'
 import { logger } from '../../src/observability/log.js'
 
+const _require = createRequire(import.meta.url)
+const sdk = _require('acptoapi')
 const log = logger('gui-llm-passthrough')
 
+function matrixSource() { return process.env.FREDDIE_MATRIX_URL || MATRIX_FILE }
+
 export default {
     name: 'gui-llm-passthrough', surfaces: 'gui',
     register({ gui }) {
-        gui.route('GET', '/v1/models', (_, res) => {
-            const data = flattenForOpenAI()
-            if (data.length === 0) data.push({ id: 'freddie/auto', object: 'model', created: Math.floor(Date.now() / 1000), owned_by: 'freddie' })
-            res.json({ object: 'list', data })
+        gui.route('GET', '/v1/models', async (_, res) => {
+            try {
+                const rows = await sdk.listAllModelsAndQueues({ queuesMap: getConfigValue('agent.model_queues', {}) || {}, matrixSource: matrixSource() })
+                const local = flattenForOpenAI()
+                const seen = new Set(rows.map(r => r.id))
+                for (const r of local) if (!seen.has(r.id)) rows.push(r)
+                if (rows.length === 0) rows.push({ id: 'freddie/auto', object: 'model', created: Math.floor(Date.now() / 1000), owned_by: 'freddie' })
+                res.json({ object: 'list', data: rows })
+            } catch (e) { log.error('list-models-failed', { error: String(e.message || e) }); res.json({ object: 'list', data: flattenForOpenAI() }) }
         })
         gui.route('POST', '/v1/chat/completions', async (req, res) => {
             const { model, messages, tools, stream } = req.body || {}
             if (!Array.isArray(messages) || messages.length === 0) return res.status(400).json({ error: { message: 'messages required' } })
             try {
-                let provider, mdl
-                if (typeof model === 'string' && model.includes('/')) {
-                    const idx = model.indexOf('/'); provider = model.slice(0, idx); mdl = model.slice(idx + 1)
-                }
-                const call = resolveCallLLM({ provider, model: mdl })
-                const out = await call({ messages, tools: tools?.map(t => ({ name: t.function?.name, description: t.function?.description, parameters: t.function?.parameters })) || [], model: mdl })
-                const id = 'chatcmpl-' + Math.random().toString(36).slice(2, 12)
-                const created = Math.floor(Date.now() / 1000)
-                const choice = { index: 0, message: { role: 'assistant', content: out.content || '', ...(out.tool_calls?.length ? { tool_calls: out.tool_calls.map(tc => ({ id: tc.id, type: 'function', function: { name: tc.name, arguments: JSON.stringify(tc.arguments || {}) } })) } : {}) }, finish_reason: 'stop' }
+                const out = await sdk.chat({ model: model || 'freddie/auto', messages, tools, queuesMap: getConfigValue('agent.model_queues', {}) || {}, matrixSource: matrixSource(), output: 'openai' })
                 if (stream) {
-                    res.setHeader('content-type', 'text/event-stream')
-                    res.setHeader('cache-control', 'no-cache')
-                    res.write(`data: ${JSON.stringify({ id, object: 'chat.completion.chunk', created, model: model || 'freddie/auto', choices: [{ index: 0, delta: { role: 'assistant', content: out.content || '' }, finish_reason: null }] })}\n\n`)
+                    const id = 'chatcmpl-' + Math.random().toString(36).slice(2, 12)
+                    const created = Math.floor(Date.now() / 1000)
+                    const content = out?.choices?.[0]?.message?.content || ''
+                    res.setHeader('content-type', 'text/event-stream'); res.setHeader('cache-control', 'no-cache')
+                    res.write(`data: ${JSON.stringify({ id, object: 'chat.completion.chunk', created, model: model || 'freddie/auto', choices: [{ index: 0, delta: { role: 'assistant', content }, finish_reason: null }] })}\n\n`)
                     res.write(`data: ${JSON.stringify({ id, object: 'chat.completion.chunk', created, model: model || 'freddie/auto', choices: [{ index: 0, delta: {}, finish_reason: 'stop' }] })}\n\n`)
-                    res.write('data: [DONE]\n\n')
-                    res.end()
-                    return
+                    res.write('data: [DONE]\n\n'); res.end(); return
                 }
-                res.json({ id, object: 'chat.completion', created, model: model || 'freddie/auto', choices: [choice], usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 } })
-            } catch (e) {
-                log.error('chat-completions-failed', { error: String(e.message || e) })
-                res.status(500).json({ error: { message: String(e.message || e), type: 'upstream_error' } })
-            }
+                res.json(out)
+            } catch (e) { log.error('chat-completions-failed', { error: String(e.message || e) }); res.status(500).json({ error: { message: String(e.message || e), type: 'upstream_error' } }) }
         })
     },
 }

package/plugins/gui-models-discover/plugin.js

@@ -1,10 +1,12 @@
+import { createRequire } from 'module'
 import { discoverAndPersist, listKnownProviders } from '../../src/agent/model-discovery.js'
-import { PROVIDER_KEYS, DEFAULTS } from '../../src/agent/llm_resolver.js'
 import { getConfigValue, saveConfigValue } from '../../src/config.js'
-import { getStatus } from '../../src/agent/model-sampler.js'
+import { MATRIX_FILE } from '../../src/agent/model-matrix.js'
 import fs from 'node:fs'
 import path from 'node:path'
 import { spawn } from 'node:child_process'
+const _require = createRequire(import.meta.url)
+const { PROVIDER_KEYS, PROVIDER_DEFAULTS: DEFAULTS, getStatus, peekStatus, listAllQueues } = _require('acptoapi')
 
 const MATRIX_PATH = path.resolve(new URL('.', import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, '$1'), '..', '..', '.gm', 'model-availability.json')
 let _rebuildInFlight = null
@@ -18,7 +20,19 @@ export default {
             try { const provider = req.body?.provider; const result = await discoverAndPersist({ provider }); res.json(result) }
             catch (e) { res.status(500).json({ error: String(e.message || e) }) }
         })
-        gui.route('GET', '/api/models/queues', (_, res) => res.json(getConfigValue('agent.model_queues', {}) || {}))
+        gui.route('GET', '/api/models/queues', (_, res) => {
+            const local = getConfigValue('agent.model_queues', {}) || {}
+            try {
+                const all = listAllQueues({ queuesMap: local })
+                const merged = { ...local }
+                for (const q of all) if (!merged[q.name]) merged[q.name] = q.links.map(m => ({ model: m, source: q.source }))
+                res.json(merged)
+            } catch { res.json(local) }
+        })
+        gui.route('GET', '/api/models/sampler/peek/:provider', (req, res) => {
+            try { res.json(peekStatus(req.params.provider)) }
+            catch (e) { res.status(500).json({ error: String(e.message || e) }) }
+        })
         gui.route('POST', '/api/models/queues', (req, res) => {
             const { name, entries } = req.body || {}
             if (!name || !Array.isArray(entries)) return res.status(400).json({ error: 'name and entries[] required' })

package/plugins/gui-profiles-commands-health/plugin.js

@@ -2,11 +2,9 @@ import { createRequire } from 'module'
 import { listAllProfiles } from '../../src/commands/profile.js'
 import { COMMAND_REGISTRY } from '../../src/commands/registry.js'
 import { getFreddieHome } from '../../src/home.js'
-import { PROVIDER_KEYS, DEFAULTS } from '../../src/agent/llm_resolver.js'
-import { getStatus } from '../../src/agent/model-sampler.js'
 import { resolveKey } from '../../src/agent/credential_sources.js'
 const _require = createRequire(import.meta.url)
-const { probeModels, getCachedModels } = _require('acptoapi')
+const { probeModels, getCachedModels, PROVIDER_KEYS, PROVIDER_DEFAULTS: DEFAULTS, getStatus, peekStatus } = _require('acptoapi')
 export default {
     name: 'gui-profiles-commands-health', surfaces: 'gui',
     register({ gui }) {

package/src/agent/llm_resolver.js

@@ -1,198 +1,60 @@
 import { createRequire } from 'module'
-import { callLLM as acptoapiCall, isReachable as acptoapiReachable } from './acptoapi-bridge.js'
-import { isAvailable, markFailed, getStatus } from './model-sampler.js'
 import { getConfigValue } from '../config.js'
-import { resolveKey } from './credential_sources.js'
-import { matrixUsable } from './model-matrix.js'
+import { MATRIX_FILE } from './model-matrix.js'
+import { callLLM as bridgeCall, isReachable as bridgeReachable } from './acptoapi-bridge.js'
 export { matrixUsable } from './model-matrix.js'
 
 const _require = createRequire(import.meta.url)
 const sdk = _require('acptoapi')
-const { streamClaude, CLAUDE_DEFAULT } = _require('acptoapi/lib/claude-client')
-
 export const PROVIDER_KEYS = sdk.PROVIDER_KEYS
 export const DEFAULTS = sdk.PROVIDER_DEFAULTS
 
-const ACP_BACKENDS = {
-    kilo: { base: 'http://localhost:4780', providerID: 'kilo', defaultModel: 'openrouter/free' },
-    opencode: { base: 'http://localhost:4790', providerID: 'opencode', defaultModel: 'minimax-m2.5-free' },
-}
-
-async function claudeCliChat(model, input) {
-    const userMsg = input.messages.filter(m => m.role === 'user').slice(-1)[0]?.content
-    const systemMsg = input.messages.filter(m => m.role === 'system').map(m => m.content).join('\n\n') || undefined
-    const prompt = typeof userMsg === 'string' ? userMsg : JSON.stringify(userMsg || '')
-    let content = ''; const ctrl = new AbortController(); const t = setTimeout(() => ctrl.abort(), 120000)
-    try {
-        for await (const ev of streamClaude({ prompt, model: model || CLAUDE_DEFAULT, systemPrompt: systemMsg, signal: ctrl.signal })) {
-            if (ev.type === 'assistant' && Array.isArray(ev.message?.content)) for (const part of ev.message.content) { if (part.type === 'text' && part.text) content += part.text }
-            if (ev.type === 'result' && typeof ev.result === 'string') content = ev.result
-        }
-    } finally { clearTimeout(t) }
-    return { content: content.trim(), tool_calls: [], raw: { provider: 'claude-cli', model } }
-}
-
-async function acpChat(prefix, model, input) {
-    const b = ACP_BACKENDS[prefix]; if (!b) throw new Error(`unknown acp backend: ${prefix}`)
-    const sessRes = await fetch(`${b.base}/session`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: '{}', signal: AbortSignal.timeout(5000) })
-    if (!sessRes.ok) throw new Error(`ACP ${prefix} /session ${sessRes.status}`)
-    const sessionId = (await sessRes.json()).id
-    const userMsg = input.messages.filter(m => m.role === 'user').slice(-1)[0]?.content || ''
-    const body = { parts: [{ type: 'text', text: String(userMsg) }], model: { providerID: b.providerID, modelID: model || b.defaultModel } }
-    const evRes = await fetch(`${b.base}/event`, { method: 'GET', signal: AbortSignal.timeout(120000) })
-    if (!evRes.ok) throw new Error(`ACP ${prefix} /event ${evRes.status}`)
-    const msgRes = await fetch(`${b.base}/session/${sessionId}/message`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body), signal: AbortSignal.timeout(120000) })
-    if (!msgRes.ok) throw new Error(`ACP ${prefix} /message ${msgRes.status}: ${(await msgRes.text()).slice(0,200)}`)
-    let content = ''; let sawAssistantText = false
-    const reader = evRes.body.getReader(); const dec = new TextDecoder(); let buf = ''
-    while (true) {
-        const { value, done } = await reader.read(); if (done) break
-        buf += dec.decode(value, { stream: true }); let idx
-        while ((idx = buf.indexOf('\n\n')) >= 0) {
-            const raw = buf.slice(0, idx); buf = buf.slice(idx + 2)
-            if (!raw.startsWith('data: ')) continue
-            try { const ev = JSON.parse(raw.slice(6))
-                if (ev.properties?.sessionID && ev.properties.sessionID !== sessionId) continue
-                if (ev.type === 'message.part.updated' && ev.properties?.part?.type === 'text' && ev.properties.part.text) { content = ev.properties.part.text; sawAssistantText = true }
-                if (ev.type === 'session.error') throw new Error(`ACP ${prefix} session.error: ${JSON.stringify(ev.properties?.error || {}).slice(0,200)}`)
-                if (ev.type === 'session.idle') return { content: content.trim(), tool_calls: [], raw: { provider: prefix, model } }
-            } catch (e) { if (/session.error/.test(e.message)) throw e }
-        }
-    }
-    return { content: content.trim(), tool_calls: [], raw: { provider: prefix, model } }
-}
-
-function toOpenAITools(schemas) {
-    if (!schemas?.length) return undefined
-    return schemas.map(s => ({ type: 'function', function: { name: s.name, description: s.description || '', parameters: s.parameters || { type: 'object', properties: {} } } }))
-}
-
-function toOpenAIMessages(messages) {
-    return messages.map(m => {
-        if (m.role === 'assistant' && Array.isArray(m.tool_calls) && m.tool_calls.length) {
-            return { role: 'assistant', content: m.content || '', tool_calls: m.tool_calls.map(tc => ({ id: tc.id, type: 'function', function: { name: tc.name || tc.function?.name, arguments: typeof (tc.arguments || tc.function?.arguments) === 'string' ? (tc.arguments || tc.function?.arguments) : JSON.stringify(tc.arguments || tc.function?.arguments || {}) } })) }
-        }
-        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
-    })
-}
-
-async function directOpenAICompatChat(url, apiKey, model, messages, tools) {
-    const body = { model, messages: toOpenAIMessages(messages), ...(tools?.length ? { tools } : {}) }
-    const res = await fetch(url, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
-        body: JSON.stringify(body),
-        signal: AbortSignal.timeout(120000),
-    })
-    if (!res.ok) { const t = await res.text(); throw new Error(`${res.status} ${t.slice(0, 200)}`) }
-    return res.json()
-}
-
-async function sdkChat(provider, model, input) {
-    if (provider === 'claude-cli') return await claudeCliChat(model, input)
-    if (provider === 'kilo' || provider === 'opencode') return await acpChat(provider, model, input)
-    const { resolveModel } = sdk
-    const r = resolveModel(`${provider}/${model}`)
-    const resolved = await resolveKey(provider).catch(() => ({ value: null }))
-    const apiKey = resolved.value || (r.env ? process.env[r.env] : undefined)
-    const openaiTools = toOpenAITools(input.tools)
-    let result
-    if (r.provider === 'openai-compat') {
-        result = await directOpenAICompatChat(r.url, apiKey, r.model, input.messages, openaiTools)
-    } else {
-        const { buffer: sdkBuffer } = sdk
-        result = await sdkBuffer({ from: null, to: 'openai', provider: r.provider, model: r.model, messages: toOpenAIMessages(input.messages), apiKey, ...(openaiTools ? { tools: openaiTools } : {}) })
-    }
-    const choice = result?.choices?.[0]?.message || {}
-    const content = typeof choice.content === 'string' ? choice.content : ''
-    const tool_calls = Array.isArray(choice.tool_calls)
-        ? choice.tool_calls.map(tc => ({ id: tc.id, name: tc.function?.name, arguments: tryParseJson(tc.function?.arguments) }))
-        : []
-    return { content, tool_calls, raw: result }
-}
+const toTools = s => s?.length ? s.map(t => ({ type: 'function', function: { name: t.name, description: t.description || '', parameters: t.parameters || { type: 'object', properties: {} } } })) : undefined
 
-function tryParseJson(s) { try { return typeof s === 'string' ? JSON.parse(s) : (s || {}) } catch { return {} } }
+const toMsgs = ms => ms.map(m => {
+    if (m.role === 'assistant' && Array.isArray(m.tool_calls) && m.tool_calls.length) return { role: 'assistant', content: m.content || '', tool_calls: m.tool_calls.map(tc => ({ id: tc.id, type: 'function', function: { name: tc.name || tc.function?.name, arguments: typeof (tc.arguments || tc.function?.arguments) === 'string' ? (tc.arguments || tc.function?.arguments) : JSON.stringify(tc.arguments || tc.function?.arguments || {}) } })) }
+    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
+})
 
-async function hasKey(provider) {
-    if (provider === 'claude-cli' || provider === 'kilo' || provider === 'opencode') return true
-    const resolved = await resolveKey(provider).catch(() => ({ value: null }))
-    if (!resolved.value) return false
-    if (provider === 'cloudflare' && !process.env.CLOUDFLARE_ACCOUNT_ID) return false
-    return true
-}
+const tryJson = s => { try { return typeof s === 'string' ? JSON.parse(s) : (s || {}) } catch { return {} } }
 
-function defaultModel(provider) {
-    return DEFAULTS[provider] || ''
+function adapt(result) {
+    const c = result?.choices?.[0]?.message || {}
+    return { content: typeof c.content === 'string' ? c.content : '', tool_calls: Array.isArray(c.tool_calls) ? c.tool_calls.map(tc => ({ id: tc.id, name: tc.function?.name, arguments: tryJson(tc.function?.arguments) })) : [], raw: result }
 }
 
-async function tryChain(entries, input, model) {
-    const errors = []
-    for (const pref of entries) {
-        const p = pref.provider; const m = pref.model || model || input.model || (DEFAULTS[p] || '')
-        if (!await hasKey(p) || !isAvailable(p)) continue
-        try { return await sdkChat(p, m, input) } catch (e) { markFailed(p); errors.push(`${p}: ${e.message}`) }
+function buildModel({ provider, model, inputModel }) {
+    if (provider) return `${provider}/${model || DEFAULTS[provider] || ''}`.replace(/\/$/, '')
+    if (model) return model
+    if (inputModel) return inputModel
+    const pref = getConfigValue('agent.model_preference', [])
+    if (Array.isArray(pref) && pref.length) {
+        const links = pref.map(p => `${p.provider}/${p.model || DEFAULTS[p.provider] || ''}`.replace(/\/$/, '')).filter(s => s.includes('/'))
+        if (links.length) return links.join(', ')
     }
-    if (errors.length) throw new Error(`chain exhausted: ${errors.join('; ')}`)
-    throw new Error('chain empty: no available providers')
+    const auto = sdk.buildAutoChain(undefined)
+    const keyed = Array.isArray(auto) ? auto.filter(l => { const p = l.model.split('/')[0]; const env = PROVIDER_KEYS[p]; return env && process.env[env] }) : []
+    if (keyed.length) return keyed.map(l => l.model).join(', ')
+    return null
 }
 
 export function resolveCallLLM({ provider, model } = {}) {
     return async (input) => {
-        const mdl = model || input.model
-        const queueMatch = typeof mdl === 'string' && /^queue\//.test(mdl)
-        if (queueMatch) {
-            const name = mdl.slice('queue/'.length)
-            const queues = getConfigValue('agent.model_queues', {}) || {}
-            const entries = Array.isArray(queues[name]) ? queues[name] : null
-            if (!entries || entries.length === 0) throw new Error(`queue not found or empty: ${name}`)
-            return await tryChain(entries, input, undefined)
-        }
-        const explicitProvider = provider || input.provider
-
-        if (explicitProvider && await hasKey(explicitProvider)) {
-            const m = model || input.model || defaultModel(explicitProvider)
-            if (!isAvailable(explicitProvider)) {
-                const status = getStatus().map(s => `${s.provider}(ok=${s.ok},fails=${s.failCount})`).join(', ')
-                throw new Error(`provider ${explicitProvider} is in backoff | sampler: ${status}`)
-            }
-            try {
-                return await sdkChat(explicitProvider, m, input)
-            } catch (e) {
-                markFailed(explicitProvider)
-                throw e
-            }
+        const m = buildModel({ provider, model, inputModel: input.model })
+        if (!m) {
+            const status = sdk.getStatus().map(s => `${s.provider}(ok=${s.ok},fails=${s.failCount})`).join(', ')
+            throw new Error('no LLM backend reachable: set a provider API key or start acptoapi (http://127.0.0.1:4800/v1)' + (status ? ' | sampler: ' + status : ''))
+        }
+        try {
+            const isSimple = typeof m === 'string' && !m.includes(',') && !/^queue\//.test(m)
+            if (isSimple && await bridgeReachable()) return await bridgeCall({ ...input, model: m })
+            const r = await sdk.chat({ model: m, messages: toMsgs(input.messages), tools: toTools(input.tools), queuesMap: getConfigValue('agent.model_queues', {}) || {}, matrixSource: process.env.FREDDIE_MATRIX_URL || MATRIX_FILE, onFallback: input.onFallback, output: 'openai' })
+            return adapt(r)
+        } catch (e) {
+            if (/queue not found or empty/i.test(e.message)) throw e
+            if (e.chainHistory || /All chain links failed|chain\(\) requires/i.test(e.message)) throw new Error(`chain exhausted: ${(e.attempted || []).map(a => `${a.model}:${a.reason || 'ok'}`).join('; ') || e.message}`)
+            throw e
         }
-
-        if (await acptoapiReachable()) {
-            return await acptoapiCall({ ...input, model: model || input.model })
-        }
-
-        const preference = getConfigValue('agent.model_preference', [])
-        if (Array.isArray(preference) && preference.length > 0) {
-            try { return await tryChain(preference, input, model) } catch (e) { if (!/chain empty/.test(e.message)) throw e }
-        }
-
-        const links = sdk.buildAutoChain(model || input.model)
-        const availableLinks = (await Promise.all(links.map(async l => {
-            const prefix = l.model.split('/')[0]
-            if (!(await hasKey(prefix)) || !isAvailable(prefix)) return null
-            const mu = matrixUsable(prefix, l.model.replace(/^[^/]+\//, ''))
-            if (mu === false) return null
-            return l
-        }))).filter(Boolean)
-
-        for (const link of availableLinks) {
-            const prefix = link.model.split('/')[0]
-            const m = link.model.replace(/^[^/]+\//, '')
-            try {
-                return await sdkChat(prefix, m, input)
-            } catch (e) {
-                markFailed(prefix)
-            }
-        }
-
-        const status = getStatus().map(s => `${s.provider}(ok=${s.ok},fails=${s.failCount})`).join(', ')
-        throw new Error('no LLM backend reachable: set a provider API key or start acptoapi (http://127.0.0.1:4800/v1)' + (status ? ' | sampler: ' + status : ''))
     }
 }