freddie 0.0.96 → 0.0.98

package/README.md

@@ -136,6 +136,8 @@ v0.1.1 complete and witnessed: 12/12 named tests passing, dashboard + website bo
 
 **LLM providers**: anthropic, openai, groq, openrouter, cerebras, google, mistral, codestral, cloudflare-workers-ai, xai, zai, opencode, nvidia, sambanova, qwen — plus acptoapi localhost bridge. Set `agent.model_preference` in `~/.freddie/config.yaml` for ordered failover with exponential backoff.
 
+**Model availability matrix**: `scripts/build-model-availability.js` cross-probes every (provider × model × access_mode) cell across 7 modes (`direct_api`, `acptoapi_passthrough`, `freddie_v1`, `kilo_acp`, `opencode_acp`, `claude_cli`, `freddie_agent_loop`). Sampler-aware on both `probeDirect` and `probeAgentLoop` — failures feed acptoapi's per-provider exponential backoff (5-step 30s→480s). Output: `.gm/model-availability.json` with `{timestamp, config, daemons, providers[].models[].modes{}, sampler, summary}`. Three dashboard endpoints in `plugins/gui-models-discover/plugin.js`: `GET /api/models/availability` (full JSON or 404), `GET /api/models/availability/summary` (timestamp+daemons+summary only), `POST /api/models/availability/rebuild` (202 background spawn). See AGENTS.md for full schema + skipped-reason taxonomy.
+
 What's not in the box yet (residual, see AGENTS.md): real credentials per platform / memory backend; modal / daytona / singularity environments; bedrock / codex provider adapters.
 
 ## Testing

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freddie",
-  "version": "0.0.96",
+  "version": "0.0.98",
   "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.59"
   },
   "optionalDependencies": {
     "@libsql/darwin-arm64": "0.3.19",

package/src/agent/llm_resolver.js

@@ -1,198 +1,57 @@
 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'
 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 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 : ''))
     }
 }