freddie 0.0.122 → 0.0.124

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freddie",
-  "version": "0.0.122",
+  "version": "0.0.124",
   "type": "module",
   "description": "Open JS agent harness built on pi-mono, floosie, xstate, and anentrypoint-design",
   "bin": {
@@ -18,16 +18,14 @@
     "start": "node bin/freddie.js",
     "test": "node test.js",
     "build:browser": "vite build --config vite.browser.config.js",
+    "build:browser-shim": "node scripts/browser-shim-build/build.mjs",
     "link-local-design": "node scripts/link-local-design.mjs"
   },
   "dependencies": {
-    "@anentrypoint/libsql-plugkit-client": "github:AnEntrypoint/libsql-plugkit-client",
     "@libsql/client": "^0.5.0",
-    "@mariozechner/pi-agent-core": "^0.70.6",
     "@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.144",
     "anentrypoint-design": "latest",
     "commander": "^14.0.0",
     "express": "^5.0.0",
@@ -36,10 +34,8 @@
     "gm-plugkit": "^2.0.1535",
     "gm-skill": "latest",
     "js-yaml": "^4.1.0",
-    "libsql-plugkit-client": "^0.0.10",
     "plugsdk": "^1.0.20",
-    "xstate": "^5.31.0",
-    "zod": "^4.0.0"
+    "xstate": "^5.31.0"
   },
   "optionalDependencies": {
     "@libsql/darwin-arm64": "0.3.19",
@@ -85,6 +81,7 @@
     "xstate"
   ],
   "devDependencies": {
+    "esbuild": "^0.28.0",
     "vite": "^8.0.13"
   }
 }

package/src/agent/acptoapi-bridge.js

@@ -3,47 +3,51 @@ 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'
+    // Returns the configured dialable acptoapi URL, or null when unset. Most
+    // callers (the dashboard health row, CLI banner) treat this as display/logging
+    // only -- there is no listening port required for the in-process callLLM()
+    // path below. However codex_responses_adapter.js, gemini_native_adapter.js,
+    // image_gen_provider.js, and model-discovery.js still fetch() this value as a
+    // live HTTP base and DO require a real dialable URL (FREDDIE_LLM_URL set) --
+    // they must guard against a null return rather than building a request
+    // against a placeholder string.
+    return envVal('FREDDIE_LLM_URL') || null
 }
 
 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 +63,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 +143,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 }
 }

package/src/agent/codex_responses_adapter.js

@@ -4,7 +4,9 @@ import { isCodexModel } from '../cli/codex_models.js'
 
 export async function chat({ input, model = 'o3-mini', tools = [], reasoning_effort = 'medium' } = {}) {
     if (!isCodexModel(model)) console.warn('[codex_responses] non-codex model: ' + model)
-    const base = getAcptoapiUrl().replace(/\/v1\/?$/, '')
+    const url = getAcptoapiUrl()
+    if (!url) throw new Error('FREDDIE_LLM_URL must be set for this adapter (acptoapi is in-process only otherwise)')
+    const base = url.replace(/\/v1\/?$/, '')
     const r = await fetch(base + '/v1/responses', {
         method: 'POST',
         headers: { authorization: 'Bearer none', 'content-type': 'application/json' },

package/src/agent/gemini_native_adapter.js

@@ -3,7 +3,9 @@ import { getAcptoapiUrl } from './acptoapi-bridge.js'
 import { adaptToolForGemini, adaptMessagesForGemini } from './gemini_schema.js'
 
 export async function chat({ messages, model = 'gemini-2.5-flash', tools = [] } = {}) {
-    const base = getAcptoapiUrl().replace(/\/v1\/?$/, '')
+    const acptoapiUrl = getAcptoapiUrl()
+    if (!acptoapiUrl) throw new Error('FREDDIE_LLM_URL must be set for this adapter (acptoapi is in-process only otherwise)')
+    const base = acptoapiUrl.replace(/\/v1\/?$/, '')
     const url = `${base}/v1beta/models/${model}:generateContent`
     const body = { contents: adaptMessagesForGemini(messages), ...(tools.length ? { tools: [{ function_declarations: tools.map(adaptToolForGemini) }] } : {}) }
     const r = await fetch(url, {

package/src/agent/image_gen_provider.js

@@ -5,7 +5,9 @@ const PROVIDERS = ['openai', 'replicate', 'stability']
 
 export async function generate({ provider = 'openai', prompt, size, model } = {}) {
     if (!PROVIDERS.includes(provider)) throw new Error('unknown image provider: ' + provider)
-    const base = getAcptoapiUrl().replace(/\/v1\/?$/, '')
+    const url = getAcptoapiUrl()
+    if (!url) throw new Error('FREDDIE_LLM_URL must be set for this adapter (acptoapi is in-process only otherwise)')
+    const base = url.replace(/\/v1\/?$/, '')
     const body = provider === 'replicate'
         ? { version: model || 'black-forest-labs/flux-schnell', input: { prompt } }
         : { model: model || 'gpt-image-1', prompt, size }

package/src/agent/llm_resolver.js

@@ -5,6 +5,22 @@ import { parseTextToolCalls } from './tool_call_text.js'
 import * as sdkNs from 'acptoapi'
 export { matrixUsable } from './model-matrix.js'
 
+// Reachability memoization: bridgeReachable() now performs a REAL LLM call
+// (acptoapi-bridge.js's isReachable() sends a live 'ping' completion), so
+// calling it on every turn doubles LLM cost/latency. Cache the result for a
+// short TTL so a burst of turns within the window reuses one probe. Does NOT
+// touch acptoapi-bridge.js's exported isReachable -- health-check/dashboard
+// callers still need a live, uncached probe.
+let _lastReachable = { at: 0, ok: false }
+const REACHABLE_TTL_MS = 5000
+async function cachedReachable() {
+    const now = Date.now()
+    if (now - _lastReachable.at < REACHABLE_TTL_MS) return _lastReachable.ok
+    const ok = await bridgeReachable()
+    _lastReachable = { at: now, ok }
+    return ok
+}
+
 // `acptoapi` is externalized by vite (browser) so the host environment
 // supplies it (thebird ships docs/lib/acptoapi-browser.js via importmap).
 // Node CLI gets the real CJS package. Defensive `|| {}` keeps the bundle
@@ -78,7 +94,7 @@ async function buildModel({ provider, model, inputModel }) {
     const keyed = Array.isArray(auto) ? auto.filter(l => { const p = l.model.split('/')[0]; const env = PROVIDER_KEYS[p]; return env && process.env[env] }) : []
     if (keyed.length) return keyed.map(l => l.model).join(', ')
     // No local provider keys — delegate to acptoapi if reachable.
-    if (await bridgeReachable()) return process.env.FREDDIE_LLM_MODEL || 'auto'
+    if (await cachedReachable()) return process.env.FREDDIE_LLM_MODEL || 'auto'
     return null
 }
 
@@ -87,12 +103,12 @@ export function resolveCallLLM({ provider, model } = {}) {
         const m = await buildModel({ provider, model, inputModel: input.model })
         if (!m) {
             const status = typeof sdk.getStatus === 'function' ? sdk.getStatus().map(s => `${s.provider}(ok=${s.ok},fails=${s.failCount})`).join(', ') : ''
-            throw new Error('no LLM backend reachable: set a provider API key or start acptoapi (http://127.0.0.1:4800/v1)' + (status ? ' | sampler: ' + status : ''))
+            throw new Error('no LLM backend reachable: set a provider API key or FREDDIE_LLM_MODEL' + (status ? ' | sampler: ' + status : ''))
         }
         try {
             const isSimple = typeof m === 'string' && !m.includes(',') && !/^queue\//.test(m)
 
-            if (isSimple && await bridgeReachable()) {
+            if (isSimple && await cachedReachable()) {
                 return await bridgeCall({ ...input, model: m })
             }
 
@@ -105,7 +121,9 @@ export function resolveCallLLM({ provider, model } = {}) {
             if (m.includes(',') || /^queue\//.test(m)) opts.matrixSource = process.env.FREDDIE_MATRIX_URL || MATRIX_FILE
 
             if (typeof sdk.chat !== 'function') {
-                // Browser context: no node-side sdk; route via HTTP bridge.
+                // Browser/no-sdk context: fall back to acptoapi-bridge's in-process
+                // call (may be a no-op/broken in true browser bundles since acptoapi
+                // is externalized for vite -- unverified post-rewrite, see build:browser).
                 return await bridgeCall({ ...input, model: m })
             }
             const r = await sdk.chat(opts)

package/src/agent/model-discovery.js

@@ -17,7 +17,9 @@ export function listKnownProviders() {
 }
 
 export async function discoverModels({ provider } = {}) {
-    const base = getAcptoapiUrl().replace(/\/v1\/?$/, '')
+    const url = getAcptoapiUrl()
+    if (!url) throw new Error('FREDDIE_LLM_URL must be set for this adapter (acptoapi is in-process only otherwise)')
+    const base = url.replace(/\/v1\/?$/, '')
     try {
         const r = await fetch(base + '/v1/models', {
             headers: { authorization: 'Bearer none' },

package/src/host/index.js

@@ -5,7 +5,7 @@ import { getFreddieHome } from '../home.js'
 import { applyActiveProjectFromRegistry } from '../projects.js'
 
 let _host = null
-let _loaded = false
+let _loadPromise = null
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const REPO_PLUGINS = path.resolve(__dirname, '..', '..', 'plugins')
@@ -16,18 +16,24 @@ export function host() {
 }
 
 export async function bootHost(extraRoots = []) {
-    const h = host()
-    if (_loaded) return h
-    _loaded = true
-    if (!process.env.FREDDIE_HOME && !process.env.FREDDIE_PROFILE) applyActiveProjectFromRegistry()
-    const roots = [REPO_PLUGINS, path.join(getFreddieHome(), 'plugins'), path.join(process.cwd(), '.freddie', 'plugins'), ...extraRoots]
-    const plugins = await discoverPlugins(roots)
-    await h.load(plugins)
-    const ccRoots = [path.join(getFreddieHome(), 'cc-plugins'), path.join(process.cwd(), '.freddie', 'cc-plugins')]
-    await h.loadCcPlugins(ccRoots)
-    const extra = (process.env.FREDDIE_EXTRA_CC_ROOTS || '').split(path.delimiter).filter(Boolean)
-    for (const r of [__dirname, process.cwd(), ...extra]) await h.loadCcFromNodeModules(r)
-    return h
+    // Memoize the IN-FLIGHT promise, not a boolean flag: a boolean set true
+    // before the awaits below complete let concurrent callers observe a
+    // partially-loaded host. Returning the same promise means every caller
+    // (including ones that arrive mid-load) awaits the exact same completion.
+    if (_loadPromise) return _loadPromise
+    _loadPromise = (async () => {
+        const h = host()
+        if (!process.env.FREDDIE_HOME && !process.env.FREDDIE_PROFILE) applyActiveProjectFromRegistry()
+        const roots = [REPO_PLUGINS, path.join(getFreddieHome(), 'plugins'), path.join(process.cwd(), '.freddie', 'plugins'), ...extraRoots]
+        const plugins = await discoverPlugins(roots)
+        await h.load(plugins)
+        const ccRoots = [path.join(getFreddieHome(), 'cc-plugins'), path.join(process.cwd(), '.freddie', 'cc-plugins')]
+        await h.loadCcPlugins(ccRoots)
+        const extra = (process.env.FREDDIE_EXTRA_CC_ROOTS || '').split(path.delimiter).filter(Boolean)
+        for (const r of [__dirname, process.cwd(), ...extra]) await h.loadCcFromNodeModules(r)
+        return h
+    })()
+    return _loadPromise
 }
 
-export function resetHostForTests() { _host = null; _loaded = false }
+export function resetHostForTests() { _host = null; _loadPromise = null }

package/src/agent/__browser_shims/alias-plugin.mjs

@@ -1,24 +0,0 @@
-
-import path from 'path';
-const F='C:/dev/freddie';
-const R=p=>path.resolve(p);
-const ALIAS={
-  [R(F+'/src/host/index.js')]: R(F+'/src/agent/__browser_shims/host.js'),
-  [R(F+'/src/toolsets.js')]: R(F+'/src/agent/__browser_shims/toolsets.js'),
-  [R(F+'/src/agent/llm_resolver.js')]: R(F+'/src/agent/__browser_shims/llm_resolver.js'),
-  [R(F+'/src/observability/log.js')]: R(F+'/src/agent/__browser_shims/log.js'),
-  [R(F+'/src/config.js')]: R(F+'/src/agent/__browser_shims/config.js'),
-  [R(F+'/src/home.js')]: R(F+'/src/agent/__browser_shims/home.js'),
-};
-export default {
-  name: 'freddie-browser-alias',
-  setup(build){
-    build.onResolve({filter: /.*/}, async args=>{
-      if(args.path.startsWith('node:') || (!args.path.startsWith('.') && !path.isAbsolute(args.path))) return null;
-      const resolved = path.resolve(args.resolveDir||'', args.path);
-      const candidates=[resolved, resolved+'.js', resolved+'/index.js'];
-      for(const c of candidates) if(ALIAS[c]) return { path: ALIAS[c] };
-      return null;
-    });
-  }
-};

package/src/agent/__browser_shims/build.mjs

@@ -1,18 +0,0 @@
-
-import * as esbuild from 'esbuild';
-import alias from './alias-plugin.mjs';
-await esbuild.build({
-  entryPoints: ['C:/dev/freddie/src/agent/__browser_shims/entry.js'],
-  bundle: true,
-  format: 'esm',
-  platform: 'browser',
-  conditions: ['browser','module','import'],
-  outfile: 'C:/dev/thebird/docs/freddie-runtime.js',
-  plugins: [alias],
-  legalComments: 'none',
-  minify: false,
-  sourcemap: false,
-  logLevel: 'info',
-  external: [],
-});
-console.log('bundle ok');