@agentconnect/host 0.2.0 → 0.2.2

package/dist/host.js

@@ -132,14 +132,21 @@ function createHostRuntime(options) {
             return;
         recordCapability(`model.${providerId}`);
     }
+    function recordProviderCapability(providerId) {
+        recordCapability(`model.${providerId}`);
+    }
     async function getCachedStatus(provider, options = {}) {
+        if (options.force) {
+            statusCache.delete(provider.id);
+            statusInFlight.delete(provider.id);
+        }
         const cached = statusCache.get(provider.id);
         const now = Date.now();
-        if (cached && now - cached.at < statusCacheTtlMs) {
+        if (!options.force && cached && now - cached.at < statusCacheTtlMs) {
             return cached.status;
         }
         const existing = statusInFlight.get(provider.id);
-        if (existing)
+        if (!options.force && existing)
             return existing;
         if (options.allowFast && provider.fastStatus) {
             try {
@@ -184,12 +191,50 @@ function createHostRuntime(options) {
         statusInFlight.set(provider.id, promise);
         return promise;
     }
+    async function isModelForProvider(model, providerId) {
+        try {
+            const models = await listModels();
+            if (!models.length)
+                return true;
+            const match = models.find((entry) => entry.id === model);
+            if (match)
+                return match.provider === providerId;
+        }
+        catch {
+            return true;
+        }
+        return resolveProviderForModel(model) === providerId;
+    }
+    async function pickDefaultModel(providerId) {
+        try {
+            const recent = await listRecentModels(providerId);
+            if (recent.length > 0)
+                return recent[0].id;
+        }
+        catch {
+            // ignore recent model lookup failures
+        }
+        try {
+            const models = await listModels();
+            const match = models.find((entry) => entry.provider === providerId);
+            if (match)
+                return match.id;
+        }
+        catch {
+            // ignore model lookup failures
+        }
+        if (providerId === 'claude')
+            return 'default';
+        if (providerId === 'local')
+            return 'local';
+        return null;
+    }
     function invalidateStatus(providerId) {
         if (!providerId)
             return;
         statusCache.delete(providerId);
     }
-    function emitSessionEvent(responder, sessionId, type, data) {
+    function emitSessionEvent(emit, sessionId, type, data) {
         if (process.env.AGENTCONNECT_DEBUG?.trim()) {
             try {
                 console.log(`[AgentConnect][Session ${sessionId}] ${type} ${JSON.stringify(data)}`);
@@ -198,7 +243,7 @@ function createHostRuntime(options) {
                 console.log(`[AgentConnect][Session ${sessionId}] ${type}`);
             }
         }
-        responder.emit({
+        emit({
             jsonrpc: '2.0',
             method: 'acp.session.event',
             params: { sessionId, type, data },
@@ -252,7 +297,10 @@ function createHostRuntime(options) {
                 responder.error(id, 'AC_ERR_UNSUPPORTED', 'Unknown provider');
                 return;
             }
-            const status = await getCachedStatus(provider, { allowFast: true });
+            const statusOptions = params.options ?? {};
+            const allowFast = statusOptions.fast !== false;
+            const force = Boolean(statusOptions.force);
+            const status = await getCachedStatus(provider, { allowFast, force });
             responder.reply(id, {
                 provider: {
                     id: provider.id,
@@ -395,13 +443,39 @@ function createHostRuntime(options) {
         }
         if (method === 'acp.sessions.create') {
             const sessionId = `sess_${Math.random().toString(36).slice(2, 10)}`;
-            const model = params.model || 'claude-opus';
+            const rawProvider = params.provider;
+            if (rawProvider && !providers[rawProvider]) {
+                responder.error(id, 'AC_ERR_UNSUPPORTED', 'Unknown provider');
+                return;
+            }
+            const rawModel = typeof params.model === 'string' ? params.model.trim() : '';
+            const modelInput = rawModel ? rawModel : undefined;
+            if (!rawProvider && !modelInput) {
+                responder.error(id, 'AC_ERR_INVALID_ARGS', 'Model or provider is required');
+                return;
+            }
+            const providerId = rawProvider ?? resolveProviderForModel(modelInput);
+            let model = modelInput ?? null;
+            if (rawProvider && modelInput) {
+                const matches = await isModelForProvider(modelInput, rawProvider);
+                if (!matches) {
+                    responder.error(id, 'AC_ERR_INVALID_ARGS', 'Model does not belong to provider');
+                    return;
+                }
+            }
+            if (rawProvider && !modelInput) {
+                model = await pickDefaultModel(rawProvider);
+            }
             const reasoningEffort = params.reasoningEffort || null;
             const cwd = params.cwd ? resolveAppPathInternal(params.cwd) : undefined;
             const repoRoot = params.repoRoot ? resolveAppPathInternal(params.repoRoot) : undefined;
             const providerDetailLevel = params.providerDetailLevel || undefined;
-            const providerId = resolveProviderForModel(model);
-            recordModelCapability(model);
+            if (model) {
+                recordModelCapability(model);
+            }
+            else {
+                recordProviderCapability(providerId);
+            }
             sessions.set(sessionId, {
                 id: sessionId,
                 providerId,
@@ -421,43 +495,39 @@ function createHostRuntime(options) {
             const sessionId = params.sessionId;
             const existing = sessions.get(sessionId);
             if (!existing) {
-                const model = params.model || 'claude-opus';
-                const reasoningEffort = params.reasoningEffort || null;
-                const cwd = params.cwd ? resolveAppPathInternal(params.cwd) : undefined;
-                const repoRoot = params.repoRoot ? resolveAppPathInternal(params.repoRoot) : undefined;
-                const providerDetailLevel = params.providerDetailLevel || undefined;
-                recordModelCapability(model);
-                sessions.set(sessionId, {
-                    id: sessionId,
-                    providerId: resolveProviderForModel(model),
-                    model,
-                    providerSessionId: params.providerSessionId || null,
-                    reasoningEffort,
-                    cwd,
-                    repoRoot,
-                    providerDetailLevel: providerDetailLevel === 'raw' || providerDetailLevel === 'minimal'
-                        ? providerDetailLevel
-                        : undefined,
-                });
+                responder.error(id, 'AC_ERR_INVALID_ARGS', 'Unknown session');
+                return;
             }
-            else {
-                if (params.providerSessionId) {
-                    existing.providerSessionId = String(params.providerSessionId);
-                }
-                if (params.cwd) {
-                    existing.cwd = resolveAppPathInternal(params.cwd);
-                }
-                if (params.repoRoot) {
-                    existing.repoRoot = resolveAppPathInternal(params.repoRoot);
+            if (params.providerSessionId) {
+                existing.providerSessionId = String(params.providerSessionId);
+            }
+            if (params.cwd) {
+                existing.cwd = resolveAppPathInternal(params.cwd);
+            }
+            if (params.repoRoot) {
+                existing.repoRoot = resolveAppPathInternal(params.repoRoot);
+            }
+            if (params.providerDetailLevel) {
+                const level = String(params.providerDetailLevel);
+                if (level === 'raw' || level === 'minimal') {
+                    existing.providerDetailLevel = level;
                 }
-                if (params.providerDetailLevel) {
-                    const level = String(params.providerDetailLevel);
-                    if (level === 'raw' || level === 'minimal') {
-                        existing.providerDetailLevel = level;
-                    }
+            }
+            if (!existing.model && typeof params.model === 'string' && params.model.trim()) {
+                const candidate = params.model.trim();
+                const matches = await isModelForProvider(candidate, existing.providerId);
+                if (!matches) {
+                    responder.error(id, 'AC_ERR_INVALID_ARGS', 'Model does not belong to provider');
+                    return;
                 }
+                existing.model = candidate;
+            }
+            if (existing.model) {
                 recordModelCapability(existing.model);
             }
+            else {
+                recordProviderCapability(existing.providerId);
+            }
             responder.reply(id, { sessionId });
             return;
         }
@@ -469,7 +539,18 @@ function createHostRuntime(options) {
                 responder.error(id, 'AC_ERR_INVALID_ARGS', 'Unknown session');
                 return;
             }
-            recordModelCapability(session.model);
+            let model = session.model;
+            if (!model) {
+                model = await pickDefaultModel(session.providerId);
+                if (model)
+                    session.model = model;
+            }
+            if (model) {
+                recordModelCapability(model);
+            }
+            else {
+                recordProviderCapability(session.providerId);
+            }
             const provider = providers[session.providerId];
             if (!provider) {
                 responder.error(id, 'AC_ERR_UNSUPPORTED', 'Unknown provider');
@@ -495,52 +576,66 @@ function createHostRuntime(options) {
             const providerDetailLevel = params.providerDetailLevel === 'raw' || params.providerDetailLevel === 'minimal'
                 ? params.providerDetailLevel
                 : session.providerDetailLevel || 'minimal';
-            activeRuns.set(sessionId, controller);
+            const runToken = `run_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+            activeRuns.set(sessionId, { controller, emit: responder.emit, token: runToken });
             let sawError = false;
             provider
                 .runPrompt({
                 prompt: message,
                 resumeSessionId: session.providerSessionId,
-                model: session.model,
+                model: model ?? undefined,
                 reasoningEffort: session.reasoningEffort,
                 repoRoot,
                 cwd,
                 providerDetailLevel,
                 signal: controller.signal,
                 onEvent: (event) => {
+                    const current = activeRuns.get(sessionId);
+                    if (!current || current.token !== runToken)
+                        return;
                     if (event.type === 'error') {
                         sawError = true;
                     }
                     if (sawError && event.type === 'final') {
                         return;
                     }
-                    emitSessionEvent(responder, sessionId, event.type, { ...event });
+                    emitSessionEvent(current.emit, sessionId, event.type, { ...event });
                 },
             })
                 .then((result) => {
+                const current = activeRuns.get(sessionId);
+                if (!current || current.token !== runToken)
+                    return;
                 if (result?.sessionId) {
                     session.providerSessionId = result.sessionId;
                 }
             })
                 .catch((err) => {
+                const current = activeRuns.get(sessionId);
+                if (!current || current.token !== runToken)
+                    return;
                 if (!sawError) {
-                    emitSessionEvent(responder, sessionId, 'error', {
+                    emitSessionEvent(current.emit, sessionId, 'error', {
                         message: err?.message || 'Provider error',
                     });
                 }
             })
                 .finally(() => {
-                activeRuns.delete(sessionId);
+                const current = activeRuns.get(sessionId);
+                if (current && current.token === runToken) {
+                    activeRuns.delete(sessionId);
+                }
             });
             responder.reply(id, { accepted: true });
             return;
         }
         if (method === 'acp.sessions.cancel') {
             const sessionId = params.sessionId;
-            const controller = activeRuns.get(sessionId);
-            if (controller) {
-                controller.abort();
+            const run = activeRuns.get(sessionId);
+            if (run) {
                 activeRuns.delete(sessionId);
+                run.controller.abort();
+                emitSessionEvent(run.emit, sessionId, 'final', { cancelled: true });
             }
             responder.reply(id, { cancelled: true });
             return;

package/dist/providers/codex.js

@@ -227,7 +227,7 @@ async function hasCodexAuth() {
     return false;
 }
 function buildCodexExecArgs(options) {
-    const { prompt, cdTarget, resumeSessionId, model, reasoningEffort, mode } = options;
+    const { prompt, cdTarget, resumeSessionId, model, reasoningEffort, providerDetailLevel, mode } = options;
     const args = ['exec', '--skip-git-repo-check'];
     if (mode === 'legacy') {
         args.push('--json', '-C', cdTarget);
@@ -236,6 +236,27 @@ function buildCodexExecArgs(options) {
         args.push('--experimental-json', '--cd', cdTarget);
     }
     args.push('--yolo');
+    const summarySetting = process.env.AGENTCONNECT_CODEX_REASONING_SUMMARY;
+    const summary = summarySetting && summarySetting.trim()
+        ? summarySetting.trim()
+        : 'detailed';
+    const summaryDisabled = ['0', 'false', 'off', 'none'].includes(summary.toLowerCase());
+    if (!summaryDisabled) {
+        args.push('--config', `model_reasoning_summary=${summary}`);
+        const supportsSetting = process.env.AGENTCONNECT_CODEX_SUPPORTS_REASONING_SUMMARIES;
+        const supportsValue = supportsSetting && supportsSetting.trim() ? supportsSetting.trim() : 'true';
+        args.push('--config', `model_supports_reasoning_summaries=${supportsValue}`);
+    }
+    const verbositySetting = process.env.AGENTCONNECT_CODEX_MODEL_VERBOSITY;
+    if (verbositySetting && verbositySetting.trim()) {
+        args.push('--config', `model_verbosity=${verbositySetting.trim()}`);
+    }
+    const rawSetting = process.env.AGENTCONNECT_CODEX_SHOW_RAW_REASONING;
+    const rawEnabled = providerDetailLevel === 'raw' ||
+        (rawSetting ? ['1', 'true', 'yes', 'on'].includes(rawSetting.trim().toLowerCase()) : false);
+    if (rawEnabled) {
+        args.push('--config', 'show_raw_agent_reasoning=true');
+    }
     if (model) {
         args.push('--model', String(model));
     }
@@ -637,6 +658,7 @@ export function runCodexPrompt({ prompt, resumeSessionId, model, reasoningEffort
                 resumeSessionId,
                 model,
                 reasoningEffort,
+                providerDetailLevel,
                 mode,
             });
             const argsPreview = [...args];
@@ -646,7 +668,25 @@ export function runCodexPrompt({ prompt, resumeSessionId, model, reasoningEffort
             debugLog('Codex', 'spawn', { command, args: argsPreview, cwd: runDir, mode });
             const child = spawn(command, args, {
                 cwd: runDir,
-                env: { ...process.env },
+                env: (() => {
+                    const env = { ...process.env };
+                    if (!env.RUST_LOG) {
+                        const override = process.env.AGENTCONNECT_CODEX_RUST_LOG;
+                        if (override && override.trim()) {
+                            env.RUST_LOG = override.trim();
+                        }
+                        else {
+                            const debugFlag = process.env.AGENTCONNECT_CODEX_DEBUG_LOGS;
+                            const enabled = debugFlag
+                                ? ['1', 'true', 'yes', 'on'].includes(debugFlag.trim().toLowerCase())
+                                : false;
+                            if (enabled) {
+                                env.RUST_LOG = 'codex_exec=debug,codex_core=debug';
+                            }
+                        }
+                    }
+                    return env;
+                })(),
                 stdio: ['ignore', 'pipe', 'pipe'],
             });
             if (signal) {

package/dist/types.d.ts

@@ -144,6 +144,7 @@ export interface SessionEvent {
     input?: unknown;
     output?: unknown;
     timestampMs?: number;
+    cancelled?: boolean;
 }
 export interface RunPromptOptions {
     prompt: string;
@@ -182,7 +183,7 @@ export interface Provider {
 export interface SessionState {
     id: string;
     providerId: ProviderId;
-    model: string;
+    model: string | null;
     providerSessionId: string | null;
     reasoningEffort: string | null;
     cwd?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentconnect/host",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "license": "MIT",
   "type": "module",
   "homepage": "https://github.com/rayzhudev/agent-connect",