condukt 0.6.19 → 0.6.20

package/dist/runtimes/copilot/sdk-backend.js

@@ -50,6 +50,18 @@ const cp = __importStar(require("child_process"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const lifecycle_events_1 = require("./lifecycle-events");
+const NAMED_SDK_EVENTS = new Set([
+    'assistant.message', 'assistant.message_delta',
+    'assistant.reasoning', 'assistant.reasoning_delta',
+    'assistant.intent', 'assistant.usage',
+    'tool.execution_start', 'tool.execution_complete',
+    'tool.execution_partial_result',
+    'session.idle', 'session.task_complete', 'session.error',
+    'model.call_failure', 'abort',
+    'session.compaction_start', 'session.compaction_complete',
+    'subagent.started', 'subagent.completed', 'subagent.failed',
+    'permission.requested',
+]);
 // ---------------------------------------------------------------------------
 // PATH hardening: shared logic with SubprocessBackend
 // ---------------------------------------------------------------------------
@@ -197,8 +209,13 @@ class SdkSession {
     timeoutTimer = null;
     heartbeatTimer = null;
     compactionTimer = null;
+    abortGraceTimer = null;
     compactionInProgress = false;
+    turnSettled = false;
+    compactionRecoveryInProgress = false;
     aborted = false;
+    _turnText = new Map();
+    intentionalAborts = new WeakSet();
     /**
      * Maps toolCallId -> toolName for attributing tool_complete events.
      * Populated from assistant.message toolRequests and tool.execution_start.
@@ -231,10 +248,21 @@ class SdkSession {
      * Matches SubprocessBackend.send() contract: fire-and-forget, events stream via on().
      */
     send(prompt) {
+        if (this.aborted) {
+            this.emitError(new Error('Session is aborted'));
+            return;
+        }
+        // Detach the preceding SDK handle synchronously before resetting shared turn
+        // state. Any late events from it then fail the per-handler isActive() guard.
+        this.clearTimers();
+        void this._cleanup();
+        this._turnText.clear();
+        this._toolCallNames.clear();
+        this._callIdToParent.clear();
+        this._pendingPartials.clear();
+        this.turnSettled = false;
         this._run(prompt).catch((err) => {
-            if (!this.aborted) {
-                this.emitError(err instanceof Error ? err : new Error(String(err)));
-            }
+            this.fail(err instanceof Error ? err : new Error(String(err)), 'session.run');
         });
     }
     /**
@@ -286,7 +314,15 @@ class SdkSession {
             onPermissionRequest: approveAll,
             workingDirectory: this.config.cwd,
             reasoningEffort: this.config.thinkingBudget,
+            // Registered before createSession issues its RPC, closing the early-event
+            // gap for session.start and *_loaded events. Named payload handlers are
+            // wired after the handle exists; this hook handles class-wide liveness and
+            // future failure-shaped events without duplicating named event output.
+            onEvent: (e) => this.handleEarlyEvent(e),
         };
+        if (this.config.contextTier) {
+            sessionConfig.contextTier = this.config.contextTier;
+        }
         // CLI 1.0.11+ discovers MCP servers, skills, and custom instructions from
         // configDir. Without this, the CLI searches workingDirectory (which is often
         // a temp execution dir) and fails to find the project's .copilot/ config.
@@ -317,6 +353,13 @@ class SdkSession {
             bufferExhaustionThreshold: 0.90,
         };
         const sdkSession = await client.createSession(sessionConfig);
+        if (this.aborted) {
+            try {
+                await sdkSession.disconnect();
+            }
+            catch { /* Ignore inert early-abort handle */ }
+            return;
+        }
         this._sdkSession = sdkSession;
         // Set autopilot mode explicitly (matches SubprocessBackend's --autopilot flag)
         try {
@@ -326,19 +369,21 @@ class SdkSession {
             // SDK may not support mode.set — continue without it
         }
         // ---------------------------------------------------------------
-        // Set up hard timeout
+        // Wire SDK events -> CopilotSession events
+        // ---------------------------------------------------------------
+        this._wireEvents(sdkSession);
         // ---------------------------------------------------------------
+        // Set up turn timers only while this handle is still active
+        // ---------------------------------------------------------------
+        if (this.aborted || this._sdkSession !== sdkSession)
+            return;
         this.timeoutTimer = setTimeout(() => {
-            this.emitError(new Error(`Session timed out after ${this.config.timeout}s`));
-            this.abort();
+            if (this.aborted || this._sdkSession !== sdkSession)
+                return;
+            this.fail(new Error(`Session timed out after ${this.config.timeout}s`), 'timeout');
         }, this.config.timeout * 1000);
-        // Set up heartbeat timeout
         this.resetHeartbeat();
         // ---------------------------------------------------------------
-        // Wire SDK events -> CopilotSession events
-        // ---------------------------------------------------------------
-        this._wireEvents(sdkSession);
-        // ---------------------------------------------------------------
         // Send the prompt (fire-and-forget; events stream via handlers)
         // ---------------------------------------------------------------
         await sdkSession.send({ prompt });
@@ -347,16 +392,25 @@ class SdkSession {
      * Wire all SDK session events to CopilotSession event emissions.
      */
     _wireEvents(sdkSession) {
+        const isActive = () => this._sdkSession === sdkSession && !this.aborted;
         // --- Assistant text response ---
         sdkSession.on('assistant.message', (e) => {
-            if (this.aborted)
+            if (!isActive())
                 return;
             this.resetHeartbeat();
             const data = e.data;
             const content = typeof data?.content === 'string' ? data.content : '';
             const parentToolCallId = typeof data?.parentToolCallId === 'string' ? data.parentToolCallId : undefined;
-            if (content)
-                this.emit('text', content, parentToolCallId);
+            const streamKey = parentToolCallId ?? '__root__';
+            if (content) {
+                const streamed = this._turnText.get(streamKey) ?? '';
+                const remainder = content === streamed
+                    ? ''
+                    : content.startsWith(streamed) ? content.slice(streamed.length) : content;
+                if (remainder)
+                    this.emit('text', remainder, parentToolCallId);
+            }
+            this._turnText.delete(streamKey);
             // Pre-seed _toolCallNames from tool requests so tool.execution_complete
             // can resolve names even if tool.execution_start lacks a toolCallId.
             const toolRequests = Array.isArray(data?.toolRequests) ? data.toolRequests : [];
@@ -369,18 +423,21 @@ class SdkSession {
         });
         // --- Assistant text delta (streaming) ---
         sdkSession.on('assistant.message_delta', (e) => {
-            if (this.aborted)
+            if (!isActive())
                 return;
             this.resetHeartbeat();
             const data = e.data;
             const delta = typeof data?.deltaContent === 'string' ? data.deltaContent : '';
             const parentToolCallId = typeof data?.parentToolCallId === 'string' ? data.parentToolCallId : undefined;
-            if (delta)
+            if (delta) {
+                const streamKey = parentToolCallId ?? '__root__';
+                this._turnText.set(streamKey, (this._turnText.get(streamKey) ?? '') + delta);
                 this.emit('text', delta, parentToolCallId);
+            }
         });
         // --- Reasoning ---
         sdkSession.on('assistant.reasoning', (e) => {
-            if (this.aborted)
+            if (!isActive())
                 return;
             this.resetHeartbeat();
             const content = typeof e.data?.content === 'string' ? e.data.content : '';
@@ -388,7 +445,7 @@ class SdkSession {
                 this.emit('reasoning', content);
         });
         sdkSession.on('assistant.reasoning_delta', (e) => {
-            if (this.aborted)
+            if (!isActive())
                 return;
             this.resetHeartbeat();
             const delta = typeof e.data?.deltaContent === 'string' ? e.data.deltaContent : '';
@@ -397,7 +454,7 @@ class SdkSession {
         });
         // --- Tool execution start ---
         sdkSession.on('tool.execution_start', (e) => {
-            if (this.aborted)
+            if (!isActive())
                 return;
             this.resetHeartbeat();
             const data = e.data;
@@ -426,7 +483,7 @@ class SdkSession {
         });
         // --- Tool execution complete ---
         sdkSession.on('tool.execution_complete', (e) => {
-            if (this.aborted)
+            if (!isActive())
                 return;
             this.resetHeartbeat();
             const data = e.data;
@@ -457,7 +514,7 @@ class SdkSession {
         // the SDK. We look it up from the _callIdToParent map populated by
         // tool.execution_start.
         sdkSession.on('tool.execution_partial_result', (e) => {
-            if (this.aborted)
+            if (!isActive())
                 return;
             this.resetHeartbeat();
             const data = e.data;
@@ -481,37 +538,68 @@ class SdkSession {
         });
         // --- Session idle (agent finished all work) ---
         sdkSession.on('session.idle', () => {
-            if (this.aborted)
+            if (!isActive() || this.compactionRecoveryInProgress)
                 return;
-            this.clearTimers();
-            this.emit('idle');
-            this._cleanup();
+            this.settleIdle();
         });
         // --- task_complete → idle (some models fire this instead of session.idle) ---
         sdkSession.on('session.task_complete', () => {
-            if (this.aborted)
+            if (!isActive() || this.compactionRecoveryInProgress)
                 return;
-            this.clearTimers();
-            this.emit('idle');
-            this._cleanup();
+            this.settleIdle();
         });
-        // --- Session error ---
+        // The CLI normally follows an abort event with session.idle. If that
+        // terminal event is lost, fail quickly rather than waiting for heartbeat.
+        sdkSession.on('abort', (e) => {
+            if (!isActive() || this.compactionRecoveryInProgress)
+                return;
+            if (this.intentionalAborts.delete(sdkSession))
+                return;
+            if (this.abortGraceTimer)
+                clearTimeout(this.abortGraceTimer);
+            this.abortGraceTimer = setTimeout(() => {
+                this.abortGraceTimer = null;
+                if (!isActive())
+                    return;
+                const reason = typeof e.data?.reason === 'string' ? `: ${e.data.reason}` : '';
+                this.fail(new Error(`SDK turn aborted${reason}`), 'abort', e.data);
+            }, 1000);
+        });
+        // --- Session/model errors ---
         sdkSession.on('session.error', (e) => {
-            if (this.aborted)
+            if (!isActive())
+                return;
+            // A rate-limit error eligible for automatic model switching is followed by
+            // auto_mode_switch.requested. Let the headless policy resolve that request
+            // instead of tearing down the session before it can recover.
+            if (e.data?.eligibleForAutoSwitch === true) {
+                this.resetHeartbeat();
                 return;
-            this.clearTimers();
-            const msg = typeof e.data?.message === 'string' ? e.data.message : 'Unknown session error';
-            try {
-                process.stderr.write(`[SdkBackend] session.error: ${msg}\n`);
             }
-            catch { /* */ }
-            this.emitError(new Error(msg));
+            const msg = typeof e.data?.message === 'string' ? e.data.message : 'Unknown session error';
+            this.fail(new Error(msg), 'session.error', e.data);
+        });
+        // model.call_failure is telemetry for a failed LLM request, but the SDK has
+        // no API to resume/retry that in-flight turn. A second send() would append a
+        // duplicate user message rather than replaying the failed call, so fail the
+        // condukt session immediately instead of waiting for its heartbeat timeout.
+        sdkSession.on('model.call_failure', (e) => {
+            if (!isActive())
+                return;
+            const data = e.data;
+            const detail = typeof data?.errorMessage === 'string'
+                ? data.errorMessage
+                : typeof data?.errorCode === 'string'
+                    ? data.errorCode
+                    : 'Unknown model call failure';
+            const status = typeof data?.statusCode === 'number' ? ` (HTTP ${data.statusCode})` : '';
+            this.fail(new Error(`Model call failed${status}: ${detail}`), 'model.call_failure', data);
         });
         // --- Context compaction (infinite sessions) ---
         // During compaction the model goes silent. SUSPEND the heartbeat entirely
         // (not reset) to prevent killing the session. Hard timeout remains as safety net.
         sdkSession.on('session.compaction_start', () => {
-            if (this.aborted)
+            if (!isActive())
                 return;
             this.compactionInProgress = true;
             // SUSPEND heartbeat — compaction silence is expected
@@ -528,8 +616,10 @@ class SdkSession {
             // Recovery: if compaction doesn't complete within 3 min, escalate.
             // Capture session to local to avoid TOCTOU null dereference after await.
             const session = this._sdkSession;
+            if (!session || !isActive())
+                return;
             this.compactionTimer = setTimeout(async () => {
-                if (!this.compactionInProgress || this.aborted || !session)
+                if (!this.compactionInProgress || !isActive() || !session)
                     return;
                 try {
                     try {
@@ -538,13 +628,13 @@ class SdkSession {
                     catch { /* */ }
                     await session.rpc.compaction.compact();
                     // Re-check guards after await — session may have been torn down
-                    if (!this.compactionInProgress || this.aborted)
+                    if (!this.compactionInProgress || !isActive())
                         return;
                     // If force-compact works, compaction_complete will fire naturally
                 }
                 catch {
                     // Re-check guards after await
-                    if (this.aborted)
+                    if (!isActive())
                         return;
                     try {
                         process.stderr.write('[SdkBackend] Force compact failed — aborting + re-sending\n');
@@ -555,17 +645,30 @@ class SdkSession {
                     // SDK docs: "The session remains valid and can continue to be used for new messages."
                     // Wait for idle after abort before sending, to avoid racing with in-flight processing.
                     this.compactionInProgress = false;
+                    this.compactionRecoveryInProgress = true;
+                    this._turnText.clear();
                     try {
+                        this.intentionalAborts.add(session);
                         await session.abort();
+                        // Some SDK versions emit abort synchronously, others just after the
+                        // request resolves. Keep the marker through the settling window.
+                        if (this.abortGraceTimer) {
+                            clearTimeout(this.abortGraceTimer);
+                            this.abortGraceTimer = null;
+                        }
+                        // WeakSet entries are removed when the delayed intentional abort event
+                        // arrives. The handle itself becomes collectible after session cleanup.
                         // Wait briefly for the abort to settle before re-sending.
                         // The SDK resolves abort() on acknowledgement, not on idle.
                         await new Promise(resolve => setTimeout(resolve, 2000));
-                        if (this.aborted)
+                        if (!isActive())
                             return;
                         await session.send({ prompt: 'Continue from where you left off.' });
+                        this.compactionRecoveryInProgress = false;
                         this.resetHeartbeat();
                     }
                     catch {
+                        this.compactionRecoveryInProgress = false;
                         try {
                             process.stderr.write('[SdkBackend] Recovery failed — restarting heartbeat as safety net\n');
                         }
@@ -576,7 +679,7 @@ class SdkSession {
             }, 3 * 60 * 1000);
         });
         sdkSession.on('session.compaction_complete', (e) => {
-            if (this.aborted)
+            if (!isActive())
                 return;
             this.compactionInProgress = false;
             if (this.compactionTimer) {
@@ -607,7 +710,7 @@ class SdkSession {
         // The synthetic tool_start/tool_complete dual-emit is removed — sub-agent
         // grouping is handled by SubagentSectionPart in the UI layer.
         sdkSession.on('subagent.started', (e) => {
-            if (this.aborted)
+            if (!isActive())
                 return;
             this.resetHeartbeat();
             const data = e.data;
@@ -616,7 +719,7 @@ class SdkSession {
             this.emit('subagent_start', name, { ...data, toolCallId });
         });
         sdkSession.on('subagent.completed', (e) => {
-            if (this.aborted)
+            if (!isActive())
                 return;
             this.resetHeartbeat();
             const data = e.data;
@@ -625,7 +728,7 @@ class SdkSession {
             this.emit('subagent_end', name, { ...data, toolCallId });
         });
         sdkSession.on('subagent.failed', (e) => {
-            if (this.aborted)
+            if (!isActive())
                 return;
             this.resetHeartbeat();
             const data = e.data;
@@ -636,7 +739,7 @@ class SdkSession {
         });
         // --- Rich events (optional; consumers can subscribe or ignore) ---
         sdkSession.on('assistant.intent', (e) => {
-            if (this.aborted)
+            if (!isActive())
                 return;
             this.resetHeartbeat();
             const intent = typeof e.data?.intent === 'string' ? e.data.intent : '';
@@ -644,37 +747,24 @@ class SdkSession {
                 this.emit('intent', intent);
         });
         sdkSession.on('assistant.usage', (e) => {
-            if (this.aborted)
+            if (!isActive())
                 return;
             this.resetHeartbeat();
             this.emit('usage', e.data ?? {});
         });
         sdkSession.on('permission.requested', (e) => {
-            if (this.aborted)
+            if (!isActive())
                 return;
             this.resetHeartbeat();
             this.emit('permission', e.data ?? {});
         });
-        // Named event types handled by typed handlers above
-        const HANDLED_EVENT_TYPES = new Set([
-            'assistant.message', 'assistant.message_delta',
-            'assistant.reasoning', 'assistant.reasoning_delta',
-            'assistant.intent', 'assistant.usage',
-            'tool.execution_start', 'tool.execution_complete',
-            'tool.execution_partial_result',
-            'session.idle', 'session.task_complete', 'session.error',
-            'session.compaction_start', 'session.compaction_complete',
-            'subagent.started', 'subagent.completed', 'subagent.failed',
-            'permission.requested',
-        ]);
+        // Class-level handling for the full SDK event surface. Named handlers above
+        // retain payload-specific mapping; this dispatcher supplies liveness,
+        // terminal fallbacks, pending-request policies, and future-event safety.
         sdkSession.on((e) => {
-            if (this.aborted)
+            if (!isActive())
                 return;
-            if (e && typeof e.type === 'string'
-                && !HANDLED_EVENT_TYPES.has(e.type)
-                && !lifecycle_events_1.LIFECYCLE_EVENT_TYPES.has(e.type)) {
-                process.stderr.write(`[SdkBackend] Unhandled event: ${e.type}\n`);
-            }
+            this.dispatchClassEvent(sdkSession, e);
         });
     }
     on(event, handler) {
@@ -741,13 +831,158 @@ class SdkSession {
         catch { /* closed stream */ }
         this.emit('error', err);
     }
+    settleIdle() {
+        if (this.aborted || this.turnSettled)
+            return;
+        this.turnSettled = true;
+        this._turnText.clear();
+        this.clearTimers();
+        this.emit('idle');
+        void this._cleanup();
+    }
+    fail(err, eventType, data) {
+        if (this.aborted || this.turnSettled)
+            return;
+        this.turnSettled = true;
+        this.clearTimers();
+        try {
+            process.stderr.write(`[SdkBackend] ${eventType}: ${this.serializeEventDataCompact(eventType, data)}\n`);
+        }
+        catch { /* closed stream */ }
+        this.emitError(err);
+        this.aborted = true;
+        void this._cleanup();
+    }
+    handleEarlyEvent(e) {
+        if (this.aborted || !e || typeof e.type !== 'string')
+            return;
+        // Once the active handle exists, the session catch-all is authoritative.
+        // Only the pre-handle creation window is handled here.
+        if (this._sdkSession)
+            return;
+        const eventClass = (0, lifecycle_events_1.classifySdkEvent)(e.type);
+        if (eventClass === 'informational')
+            return;
+        if (this.isFailureShapedEvent(e)) {
+            const payload = this.serializeEventDataCompact(e.type, e.data);
+            try {
+                process.stderr.write(`[SdkBackend] Early failure event: ${e.type} data=${payload}\n`);
+            }
+            catch { /* */ }
+            this.fail(new Error(`Early SDK failure event: ${e.type}`), e.type, e.data);
+        }
+    }
+    dispatchClassEvent(sdkSession, e) {
+        if (!e || typeof e.type !== 'string' || NAMED_SDK_EVENTS.has(e.type))
+            return;
+        const eventClass = (0, lifecycle_events_1.classifySdkEvent)(e.type);
+        if (e.type === 'session.shutdown' && e.data?.shutdownType === 'error') {
+            const reason = typeof e.data.errorReason === 'string'
+                ? e.data.errorReason
+                : 'SDK session shut down abnormally';
+            this.fail(new Error(reason), 'session.shutdown', e.data);
+            return;
+        }
+        if (eventClass === 'terminal-success') {
+            this.settleIdle();
+            return;
+        }
+        if (eventClass === 'terminal-failure') {
+            this.fail(new Error(`SDK terminal failure: ${e.type}`), e.type, e.data);
+            return;
+        }
+        if (eventClass === 'streaming-liveness') {
+            this.resetHeartbeat();
+            return;
+        }
+        if (eventClass === 'pending-request') {
+            this.resetHeartbeat();
+            void this.resolvePendingRequest(sdkSession, e);
+            return;
+        }
+        if (eventClass === 'informational')
+            return;
+        const payload = this.serializeEventDataCompact(e.type, e.data);
+        try {
+            process.stderr.write(`[SdkBackend] Unknown event: ${e.type} data=${payload}\n`);
+        }
+        catch { /* */ }
+        if (this.isFailureShapedEvent(e)) {
+            this.fail(new Error(`Unknown SDK failure event: ${e.type}`), e.type, e.data);
+        }
+    }
+    serializeEventData(data) {
+        try {
+            return JSON.stringify(data ?? {});
+        }
+        catch {
+            return '(unstringifiable payload)';
+        }
+    }
+    serializeEventDataCompact(type, data) {
+        if (type === 'session.binary_asset')
+            return '(binary payload omitted)';
+        const serialized = this.serializeEventData(data);
+        return serialized.length > 2000 ? `${serialized.slice(0, 2000)}…` : serialized;
+    }
+    isFailureShapedEvent(e) {
+        const type = e.type ?? '';
+        if (/(?:^|[._-])(error|failure|fatal)(?:$|[._-])/i.test(type))
+            return true;
+        const data = e.data;
+        if (!data)
+            return false;
+        return data.failed === true
+            || typeof data.error === 'string'
+            || (data.error != null && typeof data.error === 'object');
+    }
+    async resolvePendingRequest(sdkSession, e) {
+        if (this.aborted || this._sdkSession !== sdkSession)
+            return;
+        const requestId = typeof e.data?.requestId === 'string' ? e.data.requestId : '';
+        if (!requestId) {
+            this.fail(new Error(`Pending SDK request missing requestId: ${e.type}`), e.type ?? 'pending-request', e.data);
+            return;
+        }
+        try {
+            switch (e.type) {
+                case 'sampling.requested':
+                    await sdkSession.rpc.mcp.cancelSamplingExecution({ requestId });
+                    break;
+                case 'auto_mode_switch.requested':
+                    // Approve this turn only. Do not persist a user preference from a
+                    // headless execution engine.
+                    await sdkSession.rpc.ui.handlePendingAutoModeSwitch({ requestId, response: 'yes' });
+                    break;
+                case 'session_limits_exhausted.requested':
+                    await sdkSession.rpc.ui.handlePendingSessionLimitsExhausted({
+                        requestId,
+                        response: { action: 'cancel' },
+                    });
+                    break;
+                case 'mcp.headers_refresh_required':
+                    // The runtime has its own timeout fallback; registering no response
+                    // avoids inventing credentials in a headless process.
+                    break;
+            }
+        }
+        catch (err) {
+            if (this.aborted || this._sdkSession !== sdkSession)
+                return;
+            this.fail(err instanceof Error ? err : new Error(String(err)), `${e.type}.policy`, e.data);
+        }
+    }
     resetHeartbeat() {
+        if (this.aborted || this.turnSettled || !this._sdkSession)
+            return;
+        const sdkSession = this._sdkSession;
         if (this.heartbeatTimer) {
             clearTimeout(this.heartbeatTimer);
         }
         this.heartbeatTimer = setTimeout(() => {
-            this.emitError(new Error(`No output for ${this.config.heartbeatTimeout}s (heartbeat timeout)`));
-            this.abort();
+            if (this.aborted || this.turnSettled || this._sdkSession !== sdkSession)
+                return;
+            this.fail(new Error(`No output for ${this.config.heartbeatTimeout}s (heartbeat timeout)`), 'heartbeat');
         }, this.config.heartbeatTimeout * 1000);
     }
     clearTimers() {
@@ -763,7 +998,12 @@ class SdkSession {
             clearTimeout(this.compactionTimer);
             this.compactionTimer = null;
         }
+        if (this.abortGraceTimer) {
+            clearTimeout(this.abortGraceTimer);
+            this.abortGraceTimer = null;
+        }
         this.compactionInProgress = false;
+        this.compactionRecoveryInProgress = false;
     }
 }
 //# sourceMappingURL=sdk-backend.js.map