@agentconnect/host 0.2.0 → 0.2.1

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/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.1",
   "license": "MIT",
   "type": "module",
   "homepage": "https://github.com/rayzhudev/agent-connect",