freddie 0.0.83 → 0.0.84

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freddie",
-  "version": "0.0.83",
+  "version": "0.0.84",
   "type": "module",
   "description": "Open JS agent harness built on pi-mono, floosie, xstate, and anentrypoint-design",
   "bin": {
@@ -26,7 +26,7 @@
     "plugsdk": "^1.0.15",
     "xstate": "^5.31.0",
     "zod": "^4.0.0",
-    "anentrypoint-design": "^0.0.88",
+    "anentrypoint-design": "^0.0.91",
     "acptoapi": "^1.0.50"
   },
   "optionalDependencies": {

package/plugins/core-cli/plugin.js

@@ -73,6 +73,15 @@ export default {
             const out = await runBatch({ prompts, concurrency: Number(opts.concurrency), model: opts.model })
             console.log('batch:', out.id, '\nfile:', out.file, '\nresults:', out.results.length)
         } })
+        C({ name: 'models', description: 'Discover working models per provider key', args: [{ name: 'action', default: 'discover' }, { name: 'provider' }], action: async (action, provider) => {
+            const { discoverAndPersist, listKnownProviders } = await import('../../src/agent/model-discovery.js')
+            if (action === 'providers') { for (const p of listKnownProviders()) console.log(p); return }
+            const result = await discoverAndPersist({ provider })
+            for (const [p, r] of Object.entries(result)) {
+                if (r.error) console.log(`${p.padEnd(12)} ✗ ${r.error}`)
+                else console.log(`${p.padEnd(12)} ✓ ${r.models.length} models — ${r.models.slice(0, 5).join(', ')}${r.models.length > 5 ? ', …' : ''}`)
+            }
+        } })
         C({ name: 'dashboard', description: 'Boot web dashboard', options: [{ flag: '--port <port>', default: '0' }, { flag: '--cwd <dir>', default: '' }], action: async (opts) => {
             if (opts.cwd) { const p = process.platform === 'win32' ? opts.cwd.replace(/^\/([a-z])\//i, '$1:/') : opts.cwd; process.chdir(p) }
             const { createDashboard } = await import('../../src/web/server.js')

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

@@ -0,0 +1,41 @@
+import { resolveCallLLM } from '../../src/agent/llm_resolver.js'
+import { logger } from '../../src/observability/log.js'
+
+const log = logger('gui-llm-passthrough')
+
+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' }] })
+        })
+        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' }
+                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`)
+                    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.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' } })
+            }
+        })
+    },
+}

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

@@ -0,0 +1,15 @@
+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'
+
+export default {
+    name: 'gui-models-discover', surfaces: 'gui',
+    register({ gui }) {
+        gui.route('GET', '/api/models/providers', (_, res) => res.json({ providers: listKnownProviders(), keys: PROVIDER_KEYS, defaults: DEFAULTS }))
+        gui.route('GET', '/api/models/cached', (_, res) => res.json(getConfigValue('agent.discovered_models', {}) || {}))
+        gui.route('POST', '/api/models/discover', async (req, res) => {
+            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) }) }
+        })
+    },
+}

package/src/agent/model-discovery.js

@@ -0,0 +1,62 @@
+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 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\//, '')) },
+}
+
+async function probeProvider(provider) {
+    const ep = ENDPOINTS[provider]
+    if (!ep) return { provider, error: 'no_probe_endpoint' }
+    const resolved = await resolveKey(provider).catch(() => ({ value: null }))
+    const key = resolved.value || process.env[PROVIDER_KEYS[provider]]
+    if (!key) 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) })
+        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) }
+    }
+}
+
+export async function discoverModels({ provider } = {}) {
+    const providers = provider ? [provider] : Object.keys(ENDPOINTS)
+    const results = await Promise.all(providers.map(p => probeProvider(p)))
+    const byProvider = {}
+    for (const r of results) byProvider[r.provider] = r
+    log.info('discovered', { count: results.length, ok: results.filter(r => !r.error).length })
+    return byProvider
+}
+
+export async function discoverAndPersist({ provider } = {}) {
+    const result = await discoverModels({ provider })
+    const existing = getConfigValue('agent.discovered_models', {}) || {}
+    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() }
+    }
+    saveConfigValue('agent.discovered_models', merged)
+    return result
+}
+
+export function listKnownProviders() {
+    return Object.keys(ENDPOINTS)
+}