freddie 0.0.122 → 0.0.123

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freddie",
-  "version": "0.0.122",
+  "version": "0.0.123",
   "type": "module",
   "description": "Open JS agent harness built on pi-mono, floosie, xstate, and anentrypoint-design",
   "bin": {
@@ -27,7 +27,7 @@
     "@mariozechner/pi-ai": "^0.70.6",
     "@mariozechner/pi-coding-agent": "^0.70.6",
     "@mariozechner/pi-tui": "^0.70.6",
-    "acptoapi": "^1.0.115",
+    "acptoapi": "^1.0.140",
     "anentrypoint-design": "latest",
     "commander": "^14.0.0",
     "express": "^5.0.0",

package/src/agent/acptoapi-bridge.js

@@ -3,47 +3,46 @@ import { parseTextToolCalls } from './tool_call_text.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.
 // Browser-safe env read: this module evaluates in a plain browser context where
 // `process` is undefined (no node shim yet), so a bare process.env throws
 // "process is not defined" and aborts the whole bundle import. envVal() reads
 // live (picks up a late-installed shim) and never throws.
 const envVal = (k) => { try { return (typeof process !== 'undefined' && process.env) ? process.env[k] : undefined } catch { return undefined } }
 const ACPTOAPI_TIMEOUT_MS = Number(envVal('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 envVal('FREDDIE_LLM_URL') || 'http://127.0.0.1:4800/v1'
+    // Retained for callers that still read a URL for display/logging purposes
+    // (the dashboard health row, CLI banner) -- there is no listening port to
+    // reach any more; this is informational only.
+    return envVal('FREDDIE_LLM_URL') || 'in-process (acptoapi)'
 }
 
 export function getAcptoapiModel() {
     return envVal('FREDDIE_LLM_MODEL') || 'claude/haiku'
 }
 
+let _acptoapi = null
+async function getAcptoapi() {
+    if (!_acptoapi) {
+        const mod = await import('acptoapi')
+        // acptoapi is a CJS package; Node's CJS-to-ESM interop only statically
+        // detects a SUBSET of module.exports keys as named exports (witnessed:
+        // `chat` is a real named export, `listAllModelsAndQueues` is not, even
+        // though both are plain keys on the same module.exports object) -- read
+        // through `.default` (the full CJS exports object) so every export is
+        // reachable regardless of which subset the interop happened to pick up.
+        _acptoapi = mod.default && typeof mod.default === 'object' ? mod.default : mod
+    }
+    return _acptoapi
+}
+
+// In-process call: acptoapi's own chat() walks its provider/model resolution
+// (including a comma-list or named chain for multi-model fallback) with no
+// HTTP hop and no separate listening process -- eliminates the standalone
+// acptoapi.js daemon on :4800 entirely, along with its witnessed failure mode
+// (an uncaught ACP-timeout exception crashing the whole bridge process).
 export async function callLLM({ messages, tools = [], model, tool_choice, cwd = null } = {}) {
-    const base = getAcptoapiUrl()
+    const acptoapi = await getAcptoapi()
     const useModel = model || getAcptoapiModel()
     const hasTools = Array.isArray(tools) && tools.length > 0
     const adaptedMessages = messages.map(adaptMessage)
@@ -59,46 +58,40 @@ export async function callLLM({ messages, tools = [], model, tool_choice, cwd =
         if (sysIdx >= 0) adaptedMessages[sysIdx] = { ...adaptedMessages[sysIdx], content: (adaptedMessages[sysIdx].content || '') + cwdNote }
         else adaptedMessages.unshift({ role: 'system', content: cwdNote.trim() })
     }
-    const body = {
-        model: useModel,
-        messages: adaptedMessages,
-        stream: false,
-        max_tokens: 4096,
-    }
-    if (hasTools) body.tools = tools.map(adaptTool)
-    // Forward a forced tool_choice (e.g. 'required') so a caller can compel a tool
-    // call on a turn. Only when tools are present; absent -> the model chooses.
-    if (hasTools && tool_choice) body.tool_choice = tool_choice
-    const headers = { 'content-type': 'application/json', authorization: 'Bearer none' }
-    if (hasTools && cwd) headers['x-cwd'] = cwd
-    // Rely on AbortController timeout. acptoapi v1+ ships CORS + Private
-    // 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')), ACPTOAPI_TIMEOUT_MS)
-    let res
-    try {
-        res = await fetch(base.replace(/\/$/, '') + '/chat/completions', {
-            method: 'POST',
-            headers,
-            body: JSON.stringify(body),
-            signal: _ac.signal,
-        })
-    } finally { clearTimeout(_tid) }
-    if (!res.ok) {
-        const text = await res.text()
-        throw new Error(`acptoapi ${res.status}: ${text.slice(0, 400)}`)
-    }
+    // acptoapi's chat() is a plain Promise with no AbortSignal support (each
+    // underlying provider has its own internal per-call timeout, e.g. the
+    // openai-compat provider's OPENAI_COMPAT_TIMEOUT_MS, default 180s) -- so the
+    // overall deadline here is enforced by racing a timeout, not by aborting the
+    // in-flight call itself.
+    let _timeoutHandle
+    const _timeout = new Promise((_, reject) => {
+        _timeoutHandle = setTimeout(() => reject(new Error('acptoapi call timeout')), ACPTOAPI_TIMEOUT_MS)
+    })
     let json
     try {
-        json = await res.json()
-    } catch (e) {
-        throw new Error(`acptoapi ${res.status}: invalid JSON response: ${String(e)}`)
-    }
+        json = await Promise.race([
+            acptoapi.chat({
+                model: useModel,
+                messages: adaptedMessages,
+                ...(hasTools ? { tools: tools.map(adaptTool) } : {}),
+                max_tokens: 4096,
+            }),
+            _timeout,
+        ])
+    } finally { clearTimeout(_timeoutHandle) }
     log.info('completed', { model: useModel, usage: json.usage })
-    return adaptResponse(json)
+    const adapted = adaptResponse(json)
+    // acptoapi's chat()/toParams() does not forward tool_choice to any provider
+    // (confirmed: a pre-existing gap, not introduced by going in-process -- the
+    // old HTTP path silently dropped it too). Enforce the documented contract
+    // client-side: when the caller forced a tool call and none came back, this
+    // was previously a SILENT no-op -- log loud so the gap is visible instead of
+    // masquerading as "the model chose not to call a tool".
+    const forcedToolChoice = tool_choice === 'required' || tool_choice?.type === 'required'
+    if (forcedToolChoice && hasTools && !adapted.tool_calls.length) {
+        log.warn('tool_choice required but no tool call returned (acptoapi does not enforce tool_choice)', { model: useModel })
+    }
+    return adapted
 }
 
 function adaptMessage(m) {
@@ -145,21 +138,23 @@ function adaptResponse(r) {
 
 function tryParseJson(s) { try { return typeof s === 'string' ? JSON.parse(s) : (s || {}) } catch { return {} } }
 
+// In-process reachability: acptoapi is a library import now, not a port to
+// dial, so there is no cheap side-channel that answers "is the CONFIGURED
+// model reachable" for an arbitrary provider (witnessed: listAllModelsAndQueues
+// only enumerates configured matrix/queue sources, empty by default; the
+// sampler cache starts empty until something actually probes/fails a
+// provider; chatjimmy -- casey's configured model -- is itself a remote
+// hosted proxy at https://chatjimmy.ai with its own internal model list, not
+// exported from acptoapi's top-level API at all). The only generically
+// correct answer is a real minimal call: send a trivial message with a short
+// timeout and treat success as reachable.
 export async function isReachable(timeoutMs = 10000) {
     try {
-        const controller = new AbortController()
-        const timeoutId = setTimeout(() => controller.abort(), timeoutMs)
-        try {
-            const res = await fetch(getAcptoapiUrl().replace(/\/$/, '') + '/models', {
-                headers: { authorization: 'Bearer none' },
-                signal: controller.signal
-            })
-            clearTimeout(timeoutId)
-            if (!res.ok) return false
-            const json = await res.json()
-            return Array.isArray(json.data) && json.data.length > 0
-        } finally {
-            clearTimeout(timeoutId)
-        }
+        const acptoapi = await getAcptoapi()
+        const result = await Promise.race([
+            acptoapi.chat({ model: getAcptoapiModel(), messages: [{ role: 'user', content: 'ping' }], max_tokens: 4 }),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('reachability probe timeout')), timeoutMs)),
+        ])
+        return !!(result && result.choices && result.choices.length)
     } catch { return false }
 }