freddie 0.0.116 → 0.0.117

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freddie",
-  "version": "0.0.116",
+  "version": "0.0.117",
   "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', {

package/src/agent/machine.js

@@ -172,16 +172,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) })
         })
     })
 }