freddie 0.0.87 → 0.0.88

package/CHANGELOG.md

@@ -1,6 +1,18 @@
 ## [Unreleased]
 
 ### Fixed
+- `src/agent/llm_resolver.js`: assistant tool_calls returning to provider on the second turn were missing OpenAI's required `type:"function"` and `function:{name,arguments:string}` wrapping. Added `toOpenAIMessages()` that wraps assistant tool_calls and stringifies tool message content. Witnessed: mistral previously errored 422 `messages.2.tool_calls.0.type : property "type" is missing`; after fix returns `Emperor Penguin` through full PLAN → EXECUTE → VERIFY → COMPLETE loop. Trajectory artifact at `penguins/.freddie/trajectories/2026-05-12T15-54-49-902-...json`.
+- `plugins/core-cli/plugin.js`: `freddie exec` now uses `resolveCallLLM` instead of hardcoded acptoapi `callLLM` — previously failed `fetch failed` when acptoapi daemon wasn't running, even with valid `--model` and provider key. Added `--provider`, `--skill`, `--cwd` flags; auto-parses `provider/model` from `--model`.
+
+### Added
+- `src/agent/machine.js`: `writeTrajectory()` writes per-turn JSON to `$FREDDIE_HOME/trajectories/<ts>-<slug>.json` when `agent.save_trajectories=true`. Records prompt, provider, model, cwd, iterations, result, error, state_transitions (PLAN/EXECUTE/VERIFY/COMPLETE), tool_calls, full messages. Filled gap: config flag existed but had no implementation.
+- `scripts/validate-llm-providers.js`: rewritten to dynamically enumerate `.env` keys × acptoapi `PROVIDER_KEYS`. Emits `.gm/llm-validation.log` + `.gm/llm-validation.json`. Live witnessed run: 5/15 REAL_OK across groq, mistral, openrouter, sambanova, claude-cli.
+
+### Witnessed broken (documented honestly, not fixed)
+- opencode `serve --port 4790` listens but every HTTP endpoint times out — likely needs `OPENCODE_SERVER_PASSWORD` or non-HTTP transport.
+- kilo ACP `POST /session` returns 200 but `GET /event` hangs in SSE reader.
+- nvidia/cerebras default models in `acptoapi/lib/auto-chain.js` are stale.
+
 - `src/agent/llm_resolver.js`: fixed tool-calling for all openai-compat providers (groq, mistral, cerebras, openrouter, nvidia, etc.) — `sdk.chat()` was internally using `from:'openai'` format which stripped `url` and `apiKey` before sending to the provider, causing "Failed to parse URL from undefined"; replaced with direct `fetch()` for openai-compat, bypassing the sdk format pipeline entirely
 - `src/agent/llm_resolver.js`: tool schemas (from `getEnabledToolSchemas`) were never passed to the LLM API — `tools: undefined` was hardcoded; now converts freddie tool schemas to OpenAI `{type:'function', function:{...}}` format and passes them in the request body
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freddie",
-  "version": "0.0.87",
+  "version": "0.0.88",
   "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.93",
+    "anentrypoint-design": "^0.0.94",
     "acptoapi": "^1.0.51"
   },
   "optionalDependencies": {

package/plugins/core-cli/plugin.js

@@ -49,10 +49,12 @@ export default {
             try { ({ callLLM } = await import('../../src/agent/pi-bridge.js')) } catch {}
             await interactive({ callLLM })
         } })
-        C({ name: 'exec', description: 'Run a single prompt through the agent and exit', options: [{ flag: '--prompt <prompt>', required: true }, { flag: '--model <model>', default: '' }, { flag: '--timeout <ms>', default: '60000' }], action: async (opts) => {
+        C({ name: 'exec', description: 'Run a single prompt through the agent and exit', options: [{ flag: '--prompt <prompt>', required: true }, { flag: '--model <model>', default: '' }, { flag: '--provider <provider>', default: '' }, { flag: '--skill <skill>', default: '' }, { flag: '--cwd <cwd>', default: '' }, { flag: '--timeout <ms>', default: '60000' }], action: async (opts) => {
             const { runTurn } = await import('../../src/agent/machine.js')
-            const { callLLM } = await import('../../src/agent/acptoapi-bridge.js')
-            const out = await runTurn({ prompt: opts.prompt, callLLM, model: opts.model || undefined, timeoutMs: Number(opts.timeout) })
+            let provider = opts.provider || undefined
+            let model = opts.model || undefined
+            if (!provider && model && /^[a-z][a-z0-9-]*\//.test(model)) { provider = model.split('/')[0]; model = model.slice(provider.length + 1) }
+            const out = await runTurn({ prompt: opts.prompt, provider, model, skill: opts.skill || undefined, cwd: opts.cwd || undefined, timeoutMs: Number(opts.timeout) })
             if (out.error) { console.error('error:', out.error); process.exit(1) }
             console.log(out.result || out.messages?.at(-1)?.content || '')
             process.exit(0)

package/src/agent/llm_resolver.js

@@ -65,8 +65,18 @@ function toOpenAITools(schemas) {
     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, ...(tools?.length ? { 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}` },
@@ -90,7 +100,7 @@ async function sdkChat(provider, model, input) {
         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: input.messages, apiKey, ...(openaiTools ? { tools: openaiTools } : {}) })
+        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 : ''
@@ -156,23 +166,7 @@ export function resolveCallLLM({ provider, model } = {}) {
 
         const preference = getConfigValue('agent.model_preference', [])
         if (Array.isArray(preference) && preference.length > 0) {
-            const errors = []
-            for (const pref of preference) {
-                const p = pref.provider
-                const m = pref.model || model || input.model || defaultModel(p)
-                if (!await hasKey(p)) continue
-                if (!isAvailable(p)) continue
-                try {
-                    return await sdkChat(p, m, input)
-                } catch (e) {
-                    markFailed(p)
-                    errors.push(`${p}: ${e.message}`)
-                }
-            }
-            if (errors.length) {
-                const status = getStatus().map(s => `${s.provider}(ok=${s.ok},fails=${s.failCount})`).join(', ')
-                throw new Error(`all preference providers failed: ${errors.join('; ')} | sampler: ${status}`)
-            }
+            try { return await tryChain(preference, input, model) } catch (e) { if (!/chain empty/.test(e.message)) throw e }
         }
 
         const links = sdk.buildAutoChain(model || input.model)

package/src/agent/machine.js

@@ -85,6 +85,35 @@ export function createAgentMachine({ provider, model, maxIterations = 90, callLL
     })
 }
 
+async function writeTrajectory(out, { prompt, provider, model, skill, cwd }) {
+    try {
+        const { getConfigValue } = await import('../config.js')
+        if (!getConfigValue('agent.save_trajectories', false)) return
+        const { getFreddieHome } = await import('../home.js')
+        const fs = await import('node:fs')
+        const path = await import('node:path')
+        const dir = path.join(getFreddieHome(), 'trajectories')
+        fs.mkdirSync(dir, { recursive: true })
+        const states = []
+        const toolCalls = []
+        for (const m of out.messages || []) {
+            if (m.role === 'assistant' && m.tool_calls?.length) { states.push('EXECUTE'); for (const tc of m.tool_calls) toolCalls.push({ name: tc.name || tc.function?.name, arguments: tc.arguments || tc.function?.arguments || {} }) }
+            else if (m.role === 'user') states.push('PLAN')
+            else if (m.role === 'assistant') states.push('COMPLETE')
+            else if (m.role === 'tool') states.push('VERIFY')
+        }
+        const ts = new Date().toISOString().replace(/[:.]/g, '-').replace(/Z$/, '')
+        const slug = (prompt || 'turn').slice(0, 40).replace(/[^a-zA-Z0-9-]+/g, '-').replace(/^-+|-+$/g, '').toLowerCase()
+        const file = path.join(dir, `${ts}-${slug}.json`)
+        fs.writeFileSync(file, JSON.stringify({
+            ts, prompt, provider, model, skill, cwd,
+            iterations: out.iterations, result: out.result, error: out.error,
+            state_transitions: states, tool_calls: toolCalls,
+            messages: out.messages,
+        }, null, 2))
+    } catch (_) {}
+}
+
 export async function runTurn({ prompt, messages = [], model, provider, callLLM, enabledToolsets, disabledToolsets, maxIterations = 90, timeoutMs = 30000, cwd, skill } = {}) {
     const initMessages = [...messages]
     const systemParts = []
@@ -104,7 +133,7 @@ export async function runTurn({ prompt, messages = [], model, provider, callLLM,
         actor.subscribe(snap => {
             if (snap.status === 'done') {
                 clearTimeout(t)
-                resolve(snap.output)
+                writeTrajectory(snap.output, { prompt, provider, model, skill, cwd }).finally(() => resolve(snap.output))
             }
         })
     })