freddie 0.0.84 → 0.0.86

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freddie",
-  "version": "0.0.84",
+  "version": "0.0.86",
   "type": "module",
   "description": "Open JS agent harness built on pi-mono, floosie, xstate, and anentrypoint-design",
   "bin": {
@@ -26,8 +26,8 @@
     "plugsdk": "^1.0.15",
     "xstate": "^5.31.0",
     "zod": "^4.0.0",
-    "anentrypoint-design": "^0.0.91",
-    "acptoapi": "^1.0.50"
+    "anentrypoint-design": "^0.0.93",
+    "acptoapi": "^1.0.51"
   },
   "optionalDependencies": {
     "@libsql/darwin-arm64": "0.3.19",

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

@@ -1,4 +1,5 @@
 import { resolveCallLLM } from '../../src/agent/llm_resolver.js'
+import { flattenForOpenAI } from '../../src/agent/model-discovery.js'
 import { logger } from '../../src/observability/log.js'
 
 const log = logger('gui-llm-passthrough')
@@ -7,7 +8,9 @@ export default {
     name: 'gui-llm-passthrough', surfaces: 'gui',
     register({ gui }) {
         gui.route('GET', '/v1/models', (_, res) => {
-            res.json({ object: 'list', data: [{ id: 'freddie/auto', object: 'model', created: Math.floor(Date.now() / 1000), owned_by: 'freddie' }] })
+            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('POST', '/v1/chat/completions', async (req, res) => {
             const { model, messages, tools, stream } = req.body || {}

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

@@ -1,6 +1,7 @@
 import { discoverAndPersist, listKnownProviders } from '../../src/agent/model-discovery.js'
 import { PROVIDER_KEYS, DEFAULTS } from '../../src/agent/llm_resolver.js'
-import { getConfigValue } from '../../src/config.js'
+import { getConfigValue, saveConfigValue } from '../../src/config.js'
+import { getStatus } from '../../src/agent/model-sampler.js'
 
 export default {
     name: 'gui-models-discover', surfaces: 'gui',
@@ -11,5 +12,21 @@ 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('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' })
+            const queues = getConfigValue('agent.model_queues', {}) || {}
+            queues[name] = entries
+            saveConfigValue('agent.model_queues', queues)
+            res.json({ name, entries })
+        })
+        gui.route('DELETE', '/api/models/queues/:name', (req, res) => {
+            const queues = getConfigValue('agent.model_queues', {}) || {}
+            delete queues[req.params.name]
+            saveConfigValue('agent.model_queues', queues)
+            res.json({ ok: true })
+        })
+        gui.route('GET', '/api/models/sampler', (_, res) => res.json({ status: getStatus() }))
     },
 }

package/src/agent/llm_resolver.js

@@ -6,10 +6,60 @@ import { resolveKey } from './credential_sources.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: 'x-ai/grok-code-fast-1:optimized: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) }] }
+    if (b.providerID === 'opencode') body.model = { providerID: 'opencode', modelID: model || b.defaultModel }
+    else { body.providerID = 'kilo'; body.modelID = model || b.defaultModel }
+    await fetch(`${b.base}/session/${sessionId}/message`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body), signal: AbortSignal.timeout(120000) })
+    let content = ''
+    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 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.properties?.part?.type === 'text' && ev.properties.part.text) content += ev.properties.part.text
+                if (ev.event === 'session.complete' || ev.properties?.complete) return { content: content.trim(), tool_calls: [], raw: { provider: prefix, model } }
+            } catch {}
+        }
+    }
+    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: {} } } }))
@@ -28,6 +78,8 @@ async function directOpenAICompatChat(url, apiKey, model, messages, tools) {
 }
 
 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 }))
@@ -51,6 +103,7 @@ async function sdkChat(provider, model, input) {
 function tryParseJson(s) { try { return typeof s === 'string' ? JSON.parse(s) : (s || {}) } catch { return {} } }
 
 async function hasKey(provider) {
+    if (provider === 'claude-cli' || provider === 'kilo' || provider === 'opencode') return true
     const resolved = await resolveKey(provider).catch(() => ({ value: null }))
     return !!resolved.value
 }
@@ -59,8 +112,28 @@ function defaultModel(provider) {
     return DEFAULTS[provider] || ''
 }
 
+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}`) }
+    }
+    if (errors.length) throw new Error(`chain exhausted: ${errors.join('; ')}`)
+    throw new Error('chain empty: no available providers')
+}
+
 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)) {

package/src/agent/model-discovery.js

@@ -1,44 +1,94 @@
 import { createRequire } from 'module'
-import { PROVIDER_KEYS } from './llm_resolver.js'
 import { resolveKey } from './credential_sources.js'
 import { saveConfigValue, getConfigValue } from '../config.js'
 import { logger } from '../observability/log.js'
 
 const _require = createRequire(import.meta.url)
-const sdk = _require('acptoapi')
+const { createModelProber } = _require('acptoapi/lib/model-prober')
+const { BRANDS } = _require('acptoapi/lib/openai-brands')
 const log = logger('model-discovery')
 
-const ENDPOINTS = {
-    anthropic: { url: 'https://api.anthropic.com/v1/models', auth: k => ({ 'x-api-key': k, 'anthropic-version': '2023-06-01' }), pick: j => (j.data || []).map(m => m.id) },
-    openai: { url: 'https://api.openai.com/v1/models', auth: k => ({ authorization: `Bearer ${k}` }), pick: j => (j.data || []).map(m => m.id) },
-    openrouter: { url: 'https://openrouter.ai/api/v1/models', auth: k => ({ authorization: `Bearer ${k}` }), pick: j => (j.data || []).map(m => m.id) },
-    groq: { url: 'https://api.groq.com/openai/v1/models', auth: k => ({ authorization: `Bearer ${k}` }), pick: j => (j.data || []).map(m => m.id) },
-    xai: { url: 'https://api.x.ai/v1/models', auth: k => ({ authorization: `Bearer ${k}` }), pick: j => (j.data || []).map(m => m.id) },
-    gemini: { url: 'https://generativelanguage.googleapis.com/v1beta/models', auth: () => ({}), keyParam: 'key', pick: j => (j.models || []).map(m => m.name.replace(/^models\//, '')) },
+const EXTRA = {
+    anthropic: { url: 'https://api.anthropic.com/v1/models', envName: 'ANTHROPIC_API_KEY', auth: k => ({ 'x-api-key': k, 'anthropic-version': '2023-06-01' }), pick: j => (j.data || []).map(m => m.id) },
+    gemini: { url: 'https://generativelanguage.googleapis.com/v1beta/models', envName: 'GOOGLE_API_KEY', keyParam: 'key', auth: () => ({}), pick: j => (j.models || []).map(m => (m.name || '').replace(/^models\//, '')).filter(Boolean) },
+    ollama: { url: 'http://localhost:11434/api/tags', envName: null, auth: () => ({}), pick: j => (j.models || []).map(m => m.name || m.model).filter(Boolean) },
 }
+const ACP_BACKENDS = {
+    kilo: { url: 'http://localhost:4780/session', staticModels: ['x-ai/grok-code-fast-1:optimized:free'] },
+    opencode: { url: 'http://localhost:4790/session', staticModels: ['minimax-m2.5-free'] },
+}
+const CLI_BACKENDS = {
+    'claude-cli': { models: ['claude-haiku-4-5', 'claude-sonnet-4-6', 'claude-opus-4-7', 'haiku', 'sonnet', 'opus'] },
+}
+
+const prober = createModelProber()
 
-async function probeProvider(provider) {
-    const ep = ENDPOINTS[provider]
-    if (!ep) return { provider, error: 'no_probe_endpoint' }
+async function probeBrand(provider) {
     const resolved = await resolveKey(provider).catch(() => ({ value: null }))
-    const key = resolved.value || process.env[PROVIDER_KEYS[provider]]
+    const brand = BRANDS[provider]
+    const envKey = brand?.envKey
+    const key = resolved.value || (envKey ? process.env[envKey] : undefined)
     if (!key) return { provider, error: 'no_key' }
+    try {
+        const r = await prober.probe(provider, key)
+        if (r.error) return { provider, error: r.error }
+        return { provider, models: r.models || [], last_ok_at: r.ts }
+    } catch (e) { return { provider, error: String(e.message || e) } }
+}
+
+async function probeExtra(provider) {
+    const ep = EXTRA[provider]
+    if (!ep) return { provider, error: 'no_extra_endpoint' }
+    const resolved = await resolveKey(provider).catch(() => ({ value: null }))
+    const key = resolved.value || (ep.envName ? process.env[ep.envName] : undefined)
+    if (!key && provider !== 'ollama') return { provider, error: 'no_key' }
     try {
         const url = ep.keyParam ? `${ep.url}?${ep.keyParam}=${encodeURIComponent(key)}` : ep.url
         const headers = ep.auth(key)
-        const res = await fetch(url, { method: 'GET', headers, signal: AbortSignal.timeout(15000) })
+        const res = await fetch(url, { method: 'GET', headers, signal: AbortSignal.timeout(8000) })
         if (!res.ok) { const t = await res.text(); return { provider, error: `${res.status}: ${t.slice(0, 200)}` } }
         const json = await res.json()
-        const models = ep.pick(json) || []
-        return { provider, models, last_ok_at: Date.now() }
-    } catch (e) {
-        return { provider, error: String(e.message || e) }
-    }
+        return { provider, models: ep.pick(json) || [], last_ok_at: Date.now() }
+    } catch (e) { return { provider, error: String(e.message || e) } }
+}
+
+async function probeAcp(provider) {
+    const b = ACP_BACKENDS[provider]
+    try {
+        const r = await fetch(b.url, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: '{}', signal: AbortSignal.timeout(2000) })
+        if (!r.ok) return { provider, error: `${r.status}`, models: b.staticModels }
+        return { provider, models: b.staticModels, last_ok_at: Date.now() }
+    } catch (e) { return { provider, error: String(e.message || e), models: b.staticModels } }
+}
+
+async function probeCli(provider) {
+    if (provider !== 'claude-cli') return { provider, error: 'unknown_cli', models: [] }
+    try {
+        const { spawn } = await import('node:child_process')
+        const ok = await new Promise(res => {
+            const p = spawn('claude', ['--version'], { stdio: 'ignore', shell: false })
+            const t = setTimeout(() => { p.kill(); res(false) }, 3000)
+            p.on('exit', c => { clearTimeout(t); res(c === 0) })
+            p.on('error', () => { clearTimeout(t); res(false) })
+        })
+        if (!ok) return { provider, error: 'claude_cli_not_available', models: [] }
+        return { provider, models: CLI_BACKENDS['claude-cli'].models, last_ok_at: Date.now() }
+    } catch (e) { return { provider, error: String(e.message || e), models: [] } }
+}
+
+export function listKnownProviders() {
+    return [...Object.keys(BRANDS), ...Object.keys(EXTRA), ...Object.keys(ACP_BACKENDS), ...Object.keys(CLI_BACKENDS)]
 }
 
 export async function discoverModels({ provider } = {}) {
-    const providers = provider ? [provider] : Object.keys(ENDPOINTS)
-    const results = await Promise.all(providers.map(p => probeProvider(p)))
+    const providers = provider ? [provider] : listKnownProviders()
+    const results = await Promise.all(providers.map(p => {
+        if (BRANDS[p]) return probeBrand(p)
+        if (EXTRA[p]) return probeExtra(p)
+        if (ACP_BACKENDS[p]) return probeAcp(p)
+        if (CLI_BACKENDS[p]) return probeCli(p)
+        return Promise.resolve({ provider: p, error: 'unknown_provider' })
+    }))
     const byProvider = {}
     for (const r of results) byProvider[r.provider] = r
     log.info('discovered', { count: results.length, ok: results.filter(r => !r.error).length })
@@ -51,12 +101,23 @@ export async function discoverAndPersist({ provider } = {}) {
     const merged = { ...existing }
     for (const [p, r] of Object.entries(result)) {
         if (!r.error) merged[p] = { models: r.models, last_ok_at: r.last_ok_at }
-        else merged[p] = { ...(existing[p] || {}), error: r.error, last_error_at: Date.now() }
+        else merged[p] = { ...(existing[p] || {}), models: r.models || (existing[p]?.models) || [], error: r.error, last_error_at: Date.now() }
     }
     saveConfigValue('agent.discovered_models', merged)
     return result
 }
 
-export function listKnownProviders() {
-    return Object.keys(ENDPOINTS)
+export function flattenForOpenAI() {
+    const cached = getConfigValue('agent.discovered_models', {}) || {}
+    const queues = getConfigValue('agent.model_queues', {}) || {}
+    const data = []
+    for (const [provider, info] of Object.entries(cached)) {
+        for (const model of (info.models || [])) {
+            data.push({ id: `${provider}/${model}`, object: 'model', created: Math.floor((info.last_ok_at || Date.now()) / 1000), owned_by: provider })
+        }
+    }
+    for (const name of Object.keys(queues)) {
+        data.push({ id: `queue/${name}`, object: 'model', created: Math.floor(Date.now() / 1000), owned_by: 'queue' })
+    }
+    return data
 }

package/src/config.js

@@ -4,9 +4,9 @@ import yaml from 'js-yaml'
 import { getFreddieHome } from './home.js'
 
 export const DEFAULT_CONFIG = {
-    _config_version: 2,
+    _config_version: 3,
     display: { skin: 'default', tool_progress_command: false, background_process_notifications: 'all' },
-    agent: { provider: 'anthropic', model: '', max_iterations: 90, fallback_model: null, save_trajectories: false, model_preference: [] },
+    agent: { provider: 'anthropic', model: '', max_iterations: 90, fallback_model: null, save_trajectories: false, model_preference: [], model_queues: {}, discovered_models: {} },
     memory: { provider: null },
     skills: { config: {} },
     terminal: { cwd: null },
@@ -18,6 +18,7 @@ export const DEFAULT_CONFIG = {
 const MIGRATIONS = {
     1: cfg => cfg,
     2: cfg => { if (!cfg.agent) cfg.agent = {}; if (!Array.isArray(cfg.agent.model_preference)) cfg.agent.model_preference = []; return cfg },
+    3: cfg => { if (!cfg.agent) cfg.agent = {}; if (!cfg.agent.model_queues || typeof cfg.agent.model_queues !== 'object') cfg.agent.model_queues = {}; if (!cfg.agent.discovered_models || typeof cfg.agent.discovered_models !== 'object') cfg.agent.discovered_models = {}; return cfg },
 }
 
 export function configPath() { return path.join(getFreddieHome(), 'config.yaml') }