freddie 0.0.116 → 0.0.118

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freddie",
-  "version": "0.0.116",
+  "version": "0.0.118",
   "type": "module",
   "description": "Open JS agent harness built on pi-mono, floosie, xstate, and anentrypoint-design",
   "bin": {

package/plugins/core-cli/plugin.js

@@ -62,9 +62,15 @@ export default {
             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), witnessPath: opts.witness || undefined })
-            if (out.error) { console.error('error:', out.error); process.exit(1) }
-            console.log(out.result || out.messages?.at(-1)?.content || '')
-            process.exit(0)
+            console.log(out.error ? '' : (out.result || out.messages?.at(-1)?.content || ''))
+            if (out.error) console.error('error:', out.error)
+            // Tear down cleanly instead of process.exit(): force-closing the
+            // process while undici keep-alive sockets and a pending setImmediate
+            // are still live makes libuv double-close its async handle and assert
+            // UV_HANDLE_CLOSING on Windows. Close the HTTP dispatcher's sockets,
+            // then set exitCode and let the event loop drain on its own.
+            try { const u = await import('undici'); await u.getGlobalDispatcher()?.close?.() } catch {}
+            process.exitCode = out.error ? 1 : 0
         } })
         C({ name: 'cron', description: 'Manage cron jobs', args: [{ name: 'action', default: 'list' }, { name: 'a1' }, { name: 'a2' }], action: async (action, a1, a2) => {
             const { listJobs, createJob, cancelJob, deleteJob, tick } = await import('../../src/cron/scheduler.js')

package/src/agent/acptoapi-bridge.js

@@ -2,6 +2,32 @@ import { logger } from '../observability/log.js'
 
 const log = logger('acptoapi')
 
+// acptoapi may take minutes to answer when it serially walks dead providers
+// (each ~90s timeout) before a live one responds. Node's default undici
+// headersTimeout/bodyTimeout (~300s) would throw UND_ERR_HEADERS_TIMEOUT
+// mid-walk, so we raise them to 0 (disabled) on the global dispatcher and let
+// our AbortController be the single source of truth for the overall deadline
+// (default 240s, override via FREDDIE_LLM_TIMEOUT_MS). Use setGlobalDispatcher
+// once rather than a per-request Agent so we don't leak a dispatcher per call.
+const ACPTOAPI_TIMEOUT_MS = Number(process.env.FREDDIE_LLM_TIMEOUT_MS) || 240000
+let _dispatcherSet = false
+async function ensureLongTimeoutDispatcher() {
+    if (_dispatcherSet) return
+    _dispatcherSet = true
+    try {
+        const undici = await import('undici')
+        // headersTimeout/bodyTimeout 0: tolerate acptoapi's minutes-long walk.
+        // keepAlive*Timeout 1ms: close the socket right after the response so no
+        // keep-alive socket lingers between calls.
+        undici.setGlobalDispatcher(new undici.Agent({
+            headersTimeout: 0,
+            bodyTimeout: 0,
+            keepAliveTimeout: 1,
+            keepAliveMaxTimeout: 1,
+        }))
+    } catch { /* undici not available — rely on AbortController + defaults */ }
+}
+
 export function getAcptoapiUrl() {
     return process.env.FREDDIE_LLM_URL || 'http://127.0.0.1:4800/v1'
 }
@@ -36,8 +62,9 @@ export async function callLLM({ messages, tools = [], model } = {}) {
     // Network Access headers so cross-origin loopback (gh-pages → localhost)
     // succeeds when acptoapi is running. The earlier preemptive loopback
     // refusal caused false negatives on reachable endpoints.
+    await ensureLongTimeoutDispatcher()
     const _ac = new AbortController()
-    const _tid = setTimeout(() => _ac.abort(new Error('acptoapi fetch timeout')), 60000)
+    const _tid = setTimeout(() => _ac.abort(new Error('acptoapi fetch timeout')), ACPTOAPI_TIMEOUT_MS)
     let res
     try {
         res = await fetch(base.replace(/\/$/, '') + '/chat/completions', {
@@ -94,7 +121,7 @@ function adaptResponse(r) {
 
 function tryParseJson(s) { try { return typeof s === 'string' ? JSON.parse(s) : (s || {}) } catch { return {} } }
 
-export async function isReachable(timeoutMs = 2000) {
+export async function isReachable(timeoutMs = 10000) {
     try {
         const controller = new AbortController()
         const timeoutId = setTimeout(() => controller.abort(), timeoutMs)

package/src/agent/machine.js

@@ -55,7 +55,18 @@ export function createAgentMachine({ provider, model, maxIterations = 90, callLL
                     input: ({ context }) => ({ messages: context.messages, model: context.model, provider: context.provider, enabledToolsets: context.enabledToolsets, disabledToolsets: context.disabledToolsets }),
                     onDone: [
                         { guard: ({ event }) => Array.isArray(event.output?.tool_calls) && event.output.tool_calls.length > 0, target: 'tool_calls', actions: assign({ messages: ({ context, event }) => [...context.messages, { role: 'assistant', content: event.output.content || '', tool_calls: event.output.tool_calls }] }) },
-                        { target: 'done', actions: assign({ messages: ({ context, event }) => [...context.messages, { role: 'assistant', content: event.output.content || '' }], lastResult: ({ event }) => event.output.content || '' }) },
+                        { target: 'done', actions: assign({ messages: ({ context, event }) => [...context.messages, { role: 'assistant', content: event.output.content || '' }], lastResult: ({ context, event }) => {
+                            // Prefer this turn's content, but if the model ended with empty
+                            // text (it may have put its answer in an earlier turn alongside a
+                            // tool_call), fall back to the last non-empty assistant message so
+                            // the caller never gets an empty result after a successful run.
+                            if (event.output.content && event.output.content.trim()) return event.output.content;
+                            for (let i = context.messages.length - 1; i >= 0; i--) {
+                                const m = context.messages[i];
+                                if (m.role === 'assistant' && typeof m.content === 'string' && m.content.trim()) return m.content;
+                            }
+                            return event.output.content || '';
+                        } }) },
                     ],
                     onError: { target: 'done', actions: assign({ error: ({ event }) => String(event.error?.message || event.error) }) },
                 },
@@ -172,16 +183,22 @@ export async function runTurn({ prompt, messages = [], model, provider, callLLM,
     const machine = createAgentMachine({ model, provider, callLLM, enabledToolsets, disabledToolsets, maxIterations, events })
     const actor = createActor(machine, { input: { messages: initMessages } }); actor.start(); actor.send({ type: 'SUBMIT', prompt })
     return await new Promise((resolve, reject) => {
-        const t = setTimeout(() => { try { actor.stop() } catch {} reject(new Error('agent turn timeout')) }, timeoutMs)
-        actor.subscribe(snap => { if (snap.status !== 'done') return; clearTimeout(t)
+        let sub
+        const cleanup = () => { try { sub?.unsubscribe() } catch {} try { actor.stop() } catch {} }
+        const t = setTimeout(() => { cleanup(); reject(new Error('agent turn timeout')) }, timeoutMs)
+        sub = actor.subscribe(snap => { if (snap.status !== 'done') return; clearTimeout(t)
             ;(async () => {
                 const out = snap.output
                 const outbound = await h.hooks.invoke('onMessageOutbound', { content: out?.result || '' })
                 if (outbound?.systemMessage || outbound?.additionalContext) out.messages = mergeHookExtras(out.messages || [], outbound, 'onMessageOutbound')
                 await h.hooks.invoke('onSessionEnd', { reason: out?.error ? 'error' : 'ok', iterations: out?.iterations })
                 const errorStack = out?.error ? (events.find(e => e.type === 'llm_call' && !e.ok)?.stack || null) : null
-                await writeTrajectory(out, { prompt, provider, model, skill, cwd, events, errorStack, witnessPath }); resolve(out)
-            })().catch(reject)
+                await writeTrajectory(out, { prompt, provider, model, skill, cwd, events, errorStack, witnessPath })
+                // Unsubscribe + stop the actor once the turn is done — a finished
+                // actor should not be left running with live subscriptions/handles.
+                cleanup()
+                resolve(out)
+            })().catch(e => { cleanup(); reject(e) })
         })
     })
 }