linkshell-cli 0.5.33 → 0.5.34

package/dist/cli/src/runtime/acp/agent-workspace.d.ts

@@ -4,6 +4,7 @@ export declare function makeAgentV2RemoteConversationId(provider: AgentProvider,
 export declare class AgentWorkspaceProxy {
     private readonly input;
     private clients;
+    private clientStartPromises;
     private agentProtocols;
     private providerCapabilities;
     private providerErrors;
@@ -58,6 +59,15 @@ export declare class AgentWorkspaceProxy {
     private defaultModelForProvider;
     private initialize;
     private ensureProviderClient;
+    private startProviderClient;
+    /** Kick off runtime capability discovery WITHOUT blocking the caller.
+     *  refreshProviderCapabilities spawns a warm provider subprocess (measured
+     *  858ms warm, multi-second cold for Claude), and nothing on the open/prompt
+     *  path needs it — sendCapabilities and prompt-time model resolution both
+     *  degrade gracefully to static fallbacks until providerCapabilities is
+     *  populated. When discovery lands we push a fresh agent.v2.capabilities so
+     *  clients pick up the real model/command list. */
+    private refreshProviderCapabilitiesInBackground;
     private refreshProviderCapabilities;
     private syncProviderSessions;
     private hydrateConversationFromProvider;

package/dist/cli/src/runtime/acp/agent-workspace.js

@@ -1664,6 +1664,9 @@ function previewFromTimelineItem(item) {
 export class AgentWorkspaceProxy {
     input;
     clients = new Map();
+    // In-flight client starts, so concurrent ensureProviderClient calls (eager
+    // initialize() racing conversation.open) share one subprocess spawn.
+    clientStartPromises = new Map();
     agentProtocols = new Map();
     providerCapabilities = new Map();
     providerErrors = new Map();
@@ -1983,6 +1986,24 @@ export class AgentWorkspaceProxy {
         const existing = this.clients.get(provider);
         if (existing)
             return existing;
+        // Dedupe concurrent starts: eager initialize() and conversation.open can
+        // race here before this.clients is populated (it's only set AFTER the
+        // client finishes initializing), which would spawn the provider subprocess
+        // twice. Memoize the in-flight promise so both callers share one spawn;
+        // drop it once settled so a failed start can be retried.
+        const inflight = this.clientStartPromises.get(provider);
+        if (inflight)
+            return inflight;
+        const start = this.startProviderClient(provider);
+        this.clientStartPromises.set(provider, start);
+        try {
+            return await start;
+        }
+        finally {
+            this.clientStartPromises.delete(provider);
+        }
+    }
+    async startProviderClient(provider) {
         const resolved = resolveAgentCommand({
             provider,
             command: this.input.command,
@@ -2033,7 +2054,7 @@ export class AgentWorkspaceProxy {
             const client = await tryCreateClient(resolved);
             this.clients.set(provider, client);
             this.providerErrors.delete(provider);
-            await this.refreshProviderCapabilities(provider, client, resolved.protocol);
+            this.refreshProviderCapabilitiesInBackground(provider, client, resolved.protocol);
             this.status = "idle";
             this.error = undefined;
             this.sendCapabilities();
@@ -2054,7 +2075,7 @@ export class AgentWorkspaceProxy {
                     const client = await tryCreateClient(fallback);
                     this.clients.set(provider, client);
                     this.providerErrors.delete(provider);
-                    await this.refreshProviderCapabilities(provider, client, fallback.protocol);
+                    this.refreshProviderCapabilitiesInBackground(provider, client, fallback.protocol);
                     this.status = "idle";
                     this.error = undefined;
                     this.sendCapabilities();
@@ -2074,6 +2095,22 @@ export class AgentWorkspaceProxy {
             return undefined;
         }
     }
+    /** Kick off runtime capability discovery WITHOUT blocking the caller.
+     *  refreshProviderCapabilities spawns a warm provider subprocess (measured
+     *  858ms warm, multi-second cold for Claude), and nothing on the open/prompt
+     *  path needs it — sendCapabilities and prompt-time model resolution both
+     *  degrade gracefully to static fallbacks until providerCapabilities is
+     *  populated. When discovery lands we push a fresh agent.v2.capabilities so
+     *  clients pick up the real model/command list. */
+    refreshProviderCapabilitiesInBackground(provider, client, protocol) {
+        void this.refreshProviderCapabilities(provider, client, protocol)
+            .then(() => this.sendCapabilities())
+            .catch((error) => {
+            if (this.input.verbose) {
+                process.stderr.write(`[agent:v2] capability refresh failed for ${provider}: ${error instanceof Error ? error.message : String(error)}\n`);
+            }
+        });
+    }
     async refreshProviderCapabilities(provider, client, protocol) {
         if (client instanceof AcpClient && protocol !== "codex-app-server")
             return;