takt 0.45.0 → 0.47.0

package/dist/infra/opencode/client.js

@@ -7,10 +7,12 @@
 import { createOpencode } from '@opencode-ai/sdk/v2';
 import { createServer } from 'node:net';
 import { AskUserQuestionDeniedError } from '../../core/workflow/ask-user-question-error.js';
-import { createLogger, getErrorMessage, createStreamDiagnostics, parseStructuredOutput } from '../../shared/utils/index.js';
+import { createLogger, getErrorMessage, createStreamDiagnostics } from '../../shared/utils/index.js';
+import { getNestedObservabilityEnvFingerprint, runWithNestedObservabilityProcessEnv, } from '../../shared/telemetry/index.js';
 import { parseProviderModel } from '../../shared/utils/providerModel.js';
-import { buildOpenCodePermissionRuleset, mapToOpenCodePermissionReply, mapToOpenCodeTools, } from './types.js';
-import { createStreamTrackingState, emitInit, emitText, emitResult, handlePartUpdated, } from './OpenCodeStreamHandler.js';
+import { buildOpenCodePermissionRuleset, resolveOpenCodePermissionReply, } from './types.js';
+import { createStreamTrackingState, emitInit, emitText, emitPermissionAsked, emitPermissionSummary, emitResult, handlePartUpdated, } from './OpenCodeStreamHandler.js';
+import { UnavailableToolLoopDetector } from './unavailable-tool-loop.js';
 import { buildRateLimitedResponseFields, containsRateLimitError } from '../rate-limit/detection.js';
 const log = createLogger('opencode-sdk');
 const OPENCODE_STREAM_IDLE_TIMEOUT_MS = 10 * 60 * 1000;
@@ -31,60 +33,132 @@ const OPENCODE_RETRYABLE_ERROR_PATTERNS = [
     'failed to start server on port',
     'timeout waiting for server',
 ];
-let sharedServer = null;
-let initPromise = null;
-async function acquireClient(model, apiKey) {
-    if (initPromise) {
-        await initPromise;
+const sharedServers = new Map();
+async function acquireClient(model, apiKey, childProcessEnv, abortSignal) {
+    throwIfAborted(abortSignal);
+    const key = buildSharedServerKey(model, apiKey, childProcessEnv);
+    const entry = getSharedServerEntry(key);
+    if (entry.initPromise) {
+        const server = await entry.initPromise;
+        throwIfAborted(abortSignal);
+        return acquireSharedServer(server, abortSignal);
     }
-    if (sharedServer?.model === model && sharedServer.apiKey === apiKey) {
-        if (sharedServer.queue.length === 0) {
-            return { client: sharedServer.client, release: () => releaseClient() };
+    if (entry.server) {
+        return acquireSharedServer(entry.server, abortSignal);
+    }
+    entry.initPromise = createSharedServer(model, apiKey, childProcessEnv)
+        .then((server) => {
+        entry.server = server;
+        return server;
+    })
+        .finally(() => {
+        entry.initPromise = undefined;
+    });
+    const server = await entry.initPromise;
+    throwIfAborted(abortSignal);
+    return acquireSharedServer(server, abortSignal);
+}
+function buildSharedServerKey(model, apiKey, childProcessEnv) {
+    return JSON.stringify([model, apiKey, getNestedObservabilityEnvFingerprint(childProcessEnv)]);
+}
+function getSharedServerEntry(key) {
+    const existing = sharedServers.get(key);
+    if (existing) {
+        return existing;
+    }
+    const entry = {};
+    sharedServers.set(key, entry);
+    return entry;
+}
+async function createSharedServer(model, apiKey, childProcessEnv) {
+    const port = await getFreePort();
+    const { client, server } = await runWithNestedObservabilityProcessEnv(childProcessEnv, () => createOpencode({
+        port,
+        config: {
+            model,
+            small_model: model,
+            ...(apiKey ? { provider: { opencode: { options: { apiKey } } } } : {}),
+        },
+        timeout: OPENCODE_SERVER_START_TIMEOUT_MS,
+    }));
+    const closeServer = () => {
+        try {
+            server.close();
         }
-        return new Promise((resolve) => {
-            sharedServer.queue.push((client) => resolve({ client, release: () => releaseClient() }));
-        });
+        catch (error) {
+            log.debug(`Failed to close OpenCode server: ${getErrorMessage(error)}`, { model });
+        }
+    };
+    log.debug('OpenCode server started', { model, port });
+    return { client, close: closeServer, model, apiKey, busy: false, queue: [] };
+}
+function acquireSharedServer(server, abortSignal) {
+    throwIfAborted(abortSignal);
+    if (!server.busy) {
+        server.busy = true;
+        return { client: server.client, release: createReleaseHandle(server) };
     }
-    sharedServer?.close();
-    let resolveInit;
-    initPromise = new Promise((resolve) => { resolveInit = resolve; });
+    return new Promise((resolve, reject) => {
+        const entry = { resolve, reject, signal: abortSignal };
+        if (abortSignal) {
+            entry.onAbort = () => {
+                removeQueuedClient(server, entry);
+                reject(new Error(OPENCODE_STREAM_ABORTED_MESSAGE));
+            };
+            abortSignal.addEventListener('abort', entry.onAbort, { once: true });
+        }
+        server.queue.push(entry);
+    });
+}
+export async function getOpenCodeSessionSnapshot(model, sessionID, directory, apiKey) {
+    const { client, release } = await acquireClient(model, apiKey, undefined);
     try {
-        const port = await getFreePort();
-        const { client, server } = await createOpencode({
-            port,
-            config: {
-                model,
-                small_model: model,
-                ...(apiKey ? { provider: { opencode: { options: { apiKey } } } } : {}),
-            },
-            timeout: OPENCODE_SERVER_START_TIMEOUT_MS,
-        });
-        const closeServer = () => {
-            try {
-                server.close();
-            }
-            catch {
-                // Ignore close errors
-            }
-        };
-        sharedServer = { client, close: closeServer, model, apiKey, queue: [] };
-        log.debug('OpenCode server started', { model, port });
-        return { client, release: () => releaseClient() };
+        const result = await client.session.get({ sessionID, directory });
+        if (!result.data) {
+            throw new Error(`OpenCode session not found: ${sessionID}`);
+        }
+        return result.data;
     }
     finally {
-        initPromise = null;
-        resolveInit();
+        release();
     }
 }
-function releaseClient() {
-    if (!sharedServer)
+function releaseClient(server) {
+    const next = server.queue.shift();
+    if (next) {
+        if (next.signal && next.onAbort) {
+            next.signal.removeEventListener('abort', next.onAbort);
+        }
+        next.resolve({ client: server.client, release: createReleaseHandle(server) });
         return;
-    const next = sharedServer.queue.shift();
-    next?.(sharedServer.client);
+    }
+    server.busy = false;
+}
+function removeQueuedClient(server, entry) {
+    server.queue = server.queue.filter((queued) => queued !== entry);
+    if (entry.signal && entry.onAbort) {
+        entry.signal.removeEventListener('abort', entry.onAbort);
+    }
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw new Error(OPENCODE_STREAM_ABORTED_MESSAGE);
+    }
+}
+function createReleaseHandle(server) {
+    let released = false;
+    return () => {
+        if (released)
+            return;
+        released = true;
+        releaseClient(server);
+    };
 }
 export function resetSharedServer() {
-    sharedServer?.close();
-    sharedServer = null;
+    for (const entry of sharedServers.values()) {
+        entry.server?.close();
+    }
+    sharedServers.clear();
 }
 async function withTimeout(operation, timeoutMs, timeoutErrorMessage) {
     const controller = new AbortController();
@@ -123,25 +197,33 @@ function extractOpenCodeErrorMessage(error) {
     }
     return undefined;
 }
-function getCommonPrefixLength(a, b) {
-    const max = Math.min(a.length, b.length);
-    let i = 0;
-    while (i < max && a[i] === b[i]) {
-        i += 1;
-    }
-    return i;
-}
 function stripPromptEcho(chunk, echoState) {
     if (!chunk)
         return '';
-    if (!echoState.remainingPrompt)
+    if (echoState.remainingPrompts.length === 0)
         return chunk;
-    const consumeLength = getCommonPrefixLength(chunk, echoState.remainingPrompt);
-    if (consumeLength > 0) {
-        echoState.remainingPrompt = echoState.remainingPrompt.slice(consumeLength);
-        return chunk.slice(consumeLength);
+    const matchingPrompts = echoState.remainingPrompts.filter((remainingPrompt) => (remainingPrompt.startsWith(chunk) || chunk.startsWith(remainingPrompt)));
+    if (matchingPrompts.length === 0) {
+        echoState.remainingPrompts = [];
+        return chunk;
+    }
+    const consumedPrompt = matchingPrompts
+        .filter((remainingPrompt) => chunk.startsWith(remainingPrompt))
+        .sort((a, b) => b.length - a.length)[0];
+    if (consumedPrompt !== undefined) {
+        const visible = chunk.slice(consumedPrompt.length);
+        echoState.remainingPrompts = [];
+        return visible;
     }
-    return chunk;
+    echoState.remainingPrompts = matchingPrompts.map((remainingPrompt) => (remainingPrompt.slice(chunk.length)));
+    return '';
+}
+function buildPromptEchoCandidates(prompt, systemPrompt) {
+    const prompts = [prompt];
+    if (systemPrompt !== undefined && systemPrompt.length > 0) {
+        prompts.unshift(`${systemPrompt}\n\n${prompt}`);
+    }
+    return Array.from(new Set(prompts)).filter((candidate) => candidate.length > 0);
 }
 function toQuestionInput(props) {
     return {
@@ -165,6 +247,12 @@ function toQuestionAnswers(props, answers) {
         return [value];
     });
 }
+function buildPermissionRejectedMessage(permission) {
+    if (permission && permission.length > 0) {
+        return `OpenCode permission rejected: ${permission}`;
+    }
+    return 'OpenCode permission rejected';
+}
 async function getFreePort() {
     return new Promise((resolve, reject) => {
         const server = createServer();
@@ -198,6 +286,10 @@ export class OpenCodeClient {
         if (abortCause === 'timeout') {
             return true;
         }
+        if (abortCause === 'prompt') {
+            const lower = message.toLowerCase();
+            return OPENCODE_RETRYABLE_ERROR_PATTERNS.some((pattern) => lower.includes(pattern));
+        }
         if (aborted || abortCause) {
             return false;
         }
@@ -229,17 +321,6 @@ export class OpenCodeClient {
             }
         });
     }
-    /** Build a prompt suffix that instructs the agent to return JSON matching the schema */
-    buildStructuredOutputSuffix(schema) {
-        return [
-            '',
-            '---',
-            'IMPORTANT: You MUST respond with ONLY a valid JSON object matching this schema. No other text, no markdown code blocks, no explanation.',
-            '```',
-            JSON.stringify(schema, null, 2),
-            '```',
-        ].join('\n');
-    }
     buildRateLimitedResponse(agentType, sessionId, message) {
         return {
             persona: agentType,
@@ -250,14 +331,6 @@ export class OpenCodeClient {
     }
     /** Call OpenCode with an agent prompt */
     async call(agentType, prompt, options) {
-        const basePrompt = options.systemPrompt
-            ? `${options.systemPrompt}\n\n${prompt}`
-            : prompt;
-        // OpenCode SDK does not natively support structured output via outputFormat.
-        // Inject JSON output instructions into the prompt to make the agent return JSON.
-        const fullPrompt = options.outputSchema
-            ? `${basePrompt}${this.buildStructuredOutputSuffix(options.outputSchema)}`
-            : basePrompt;
         for (let attempt = 1; attempt <= OPENCODE_RETRY_MAX_ATTEMPTS; attempt++) {
             let idleTimeoutId;
             const streamAbortController = new AbortController();
@@ -267,7 +340,38 @@ export class OpenCodeClient {
             let release;
             let opencodeApiClient;
             let sessionId = options.sessionId;
+            let promptCompletion;
+            let promptCompletionWait;
+            let promptError;
             const interactionTimeoutMs = options.interactionTimeoutMs ?? OPENCODE_INTERACTION_TIMEOUT_MS;
+            const promptCompletionTimeoutMessage = 'OpenCode prompt completion timed out';
+            const awaitPromptCompletion = () => {
+                if (!promptCompletion) {
+                    return Promise.resolve();
+                }
+                promptCompletionWait ??= (async () => {
+                    let timeoutId;
+                    try {
+                        await Promise.race([
+                            promptCompletion,
+                            new Promise((_, reject) => {
+                                timeoutId = setTimeout(() => {
+                                    reject(new Error(promptCompletionTimeoutMessage));
+                                }, interactionTimeoutMs);
+                            }),
+                        ]);
+                    }
+                    catch (error) {
+                        promptError ??= getErrorMessage(error);
+                    }
+                    finally {
+                        if (timeoutId !== undefined) {
+                            clearTimeout(timeoutId);
+                        }
+                    }
+                })();
+                return promptCompletionWait;
+            };
             const resetIdleTimeout = () => {
                 if (idleTimeoutId !== undefined) {
                     clearTimeout(idleTimeoutId);
@@ -284,6 +388,7 @@ export class OpenCodeClient {
             };
             if (options.abortSignal) {
                 if (options.abortSignal.aborted) {
+                    abortCause = 'external';
                     streamAbortController.abort();
                 }
                 else {
@@ -301,48 +406,79 @@ export class OpenCodeClient {
                 diagRef = diag;
                 const parsedModel = parseProviderModel(options.model, 'OpenCode model');
                 const fullModel = `${parsedModel.providerID}/${parsedModel.modelID}`;
-                const acquired = await acquireClient(fullModel, options.opencodeApiKey);
+                const acquired = await acquireClient(fullModel, options.opencodeApiKey, options.childProcessEnv, options.abortSignal);
                 opencodeApiClient = acquired.client;
                 release = acquired.release;
-                const sessionResult = sessionId
-                    ? { data: { id: sessionId } }
-                    : await opencodeApiClient.session.create({
+                if (streamAbortController.signal.aborted) {
+                    release();
+                    release = undefined;
+                    throw new Error(OPENCODE_STREAM_ABORTED_MESSAGE);
+                }
+                const permissionRuleset = buildOpenCodePermissionRuleset(options.permissionMode, options.networkAccess, options.allowedTools);
+                const shouldCreateSession = sessionId === undefined || options.allowedTools !== undefined;
+                const appliedPermissionRuleset = shouldCreateSession;
+                if (sessionId === undefined) {
+                    const sessionResult = await opencodeApiClient.session.create({
                         directory: options.cwd,
-                        permission: buildOpenCodePermissionRuleset(options.permissionMode, options.networkAccess),
+                        permission: permissionRuleset,
                     });
-                sessionId = sessionResult.data?.id;
-                if (!sessionId) {
-                    release();
-                    throw new Error('Failed to create OpenCode session');
+                    sessionId = sessionResult.data?.id;
+                    if (!sessionId) {
+                        throw new Error('Failed to create OpenCode session');
+                    }
+                }
+                else if (options.allowedTools !== undefined) {
+                    const sessionResult = await opencodeApiClient.session.create({
+                        directory: options.cwd,
+                        parentID: sessionId,
+                        permission: permissionRuleset,
+                    });
+                    sessionId = sessionResult.data?.id;
+                    if (!sessionId) {
+                        throw new Error('Failed to create OpenCode session');
+                    }
+                }
+                const activeSessionId = sessionId;
+                if (activeSessionId === undefined) {
+                    throw new Error('OpenCode session ID is required');
                 }
                 const { stream } = await opencodeApiClient.event.subscribe({ directory: options.cwd }, { signal: streamAbortController.signal });
                 resetIdleTimeout();
                 diag.onConnected();
-                const tools = mapToOpenCodeTools(options.allowedTools);
+                if (appliedPermissionRuleset) {
+                    emitPermissionSummary(options.onStream, {
+                        sessionId: activeSessionId,
+                        ...(options.permissionMode !== undefined ? { permissionMode: options.permissionMode } : {}),
+                        ...(options.allowedTools !== undefined ? { allowedTools: options.allowedTools } : {}),
+                        ...(options.networkAccess !== undefined ? { networkAccess: options.networkAccess } : {}),
+                        resolvedPermissions: permissionRuleset,
+                    });
+                }
                 const promptPayload = {
-                    sessionID: sessionId,
+                    sessionID: activeSessionId,
                     directory: options.cwd,
                     model: parsedModel,
                     ...(options.variant !== undefined ? { variant: options.variant } : {}),
-                    ...(tools ? { tools } : {}),
-                    parts: [{ type: 'text', text: fullPrompt }],
+                    ...(options.systemPrompt !== undefined ? { system: options.systemPrompt } : {}),
+                    parts: [{ type: 'text', text: prompt }],
                 };
-                if (options.outputSchema) {
-                    promptPayload.outputFormat = {
-                        type: 'json_schema',
-                        schema: options.outputSchema,
-                    };
-                }
                 const promptPayloadForSdk = promptPayload;
-                await opencodeApiClient.session.promptAsync(promptPayloadForSdk, {
+                promptCompletion = opencodeApiClient.session.promptAsync(promptPayloadForSdk, {
                     signal: streamAbortController.signal,
+                }).catch((error) => {
+                    promptError = getErrorMessage(error);
+                    if (!streamAbortController.signal.aborted) {
+                        abortCause = 'prompt';
+                        streamAbortController.abort();
+                    }
                 });
-                emitInit(options.onStream, options.model, sessionId);
+                emitInit(options.onStream, options.model, activeSessionId);
                 let content = '';
                 let success = true;
                 let failureMessage = '';
                 const state = createStreamTrackingState();
-                const echoState = { remainingPrompt: fullPrompt };
+                const unavailableToolLoopDetector = new UnavailableToolLoopDetector();
+                const echoState = { remainingPrompts: buildPromptEchoCandidates(prompt, options.systemPrompt) };
                 const textOffsets = new Map();
                 const textContentParts = new Map();
                 // Consume a raw text delta for a part: strip the prompt echo, stream the
@@ -374,6 +510,7 @@ export class OpenCodeClient {
                         const part = props.part;
                         const delta = props.delta;
                         if (part.type === 'text') {
+                            unavailableToolLoopDetector.reset();
                             const textPart = part;
                             const prev = textOffsets.get(textPart.id) ?? 0;
                             const rawDelta = delta
@@ -381,28 +518,57 @@ export class OpenCodeClient {
                             consumeTextDelta(textPart.id, rawDelta);
                             continue;
                         }
+                        if (part.type === 'tool') {
+                            const toolPart = part;
+                            const loopError = toolPart.state.status === 'error'
+                                ? unavailableToolLoopDetector.observe(toolPart.callID || toolPart.id, toolPart.tool, toolPart.state.error)
+                                : undefined;
+                            if (toolPart.state.status !== 'error') {
+                                unavailableToolLoopDetector.reset();
+                            }
+                            handlePartUpdated(part, delta, options.onStream, state);
+                            if (loopError !== undefined) {
+                                success = false;
+                                failureMessage = loopError;
+                                diag.onStreamError('message.part.updated', loopError);
+                                break;
+                            }
+                            continue;
+                        }
                         handlePartUpdated(part, delta, options.onStream, state);
                         continue;
                     }
                     if (sseEvent.type === 'message.part.delta') {
                         const deltaProps = sseEvent.properties;
                         if (deltaProps.field === 'text' && deltaProps.delta) {
+                            unavailableToolLoopDetector.reset();
                             consumeTextDelta(deltaProps.partID, deltaProps.delta);
                         }
                         continue;
                     }
                     if (sseEvent.type === 'permission.asked') {
                         const permProps = sseEvent.properties;
-                        if (permProps.sessionID === sessionId) {
+                        if (permProps.sessionID === activeSessionId) {
                             try {
-                                const reply = options.permissionMode
-                                    ? mapToOpenCodePermissionReply(options.permissionMode)
-                                    : 'once';
+                                const reply = resolveOpenCodePermissionReply(options.permissionMode, permProps.permission, options.allowedTools !== undefined ? permissionRuleset : undefined);
+                                emitPermissionAsked(options.onStream, {
+                                    requestId: permProps.id,
+                                    sessionId: permProps.sessionID,
+                                    permission: permProps.permission ?? '',
+                                    patterns: Array.isArray(permProps.patterns) ? permProps.patterns : [],
+                                    always: Array.isArray(permProps.always) ? permProps.always : [],
+                                    reply,
+                                });
                                 await withTimeout((signal) => opencodeApiClient.permission.reply({
                                     requestID: permProps.id,
                                     directory: options.cwd,
                                     reply,
                                 }, { signal }), interactionTimeoutMs, 'OpenCode permission reply timed out');
+                                if (reply === 'reject') {
+                                    success = false;
+                                    failureMessage = buildPermissionRejectedMessage(permProps.permission);
+                                    break;
+                                }
                             }
                             catch (e) {
                                 success = false;
@@ -414,7 +580,7 @@ export class OpenCodeClient {
                     }
                     if (sseEvent.type === 'question.asked') {
                         const questionProps = sseEvent.properties;
-                        if (questionProps.sessionID === sessionId) {
+                        if (questionProps.sessionID === activeSessionId) {
                             const rejectQuestion = () => withTimeout((signal) => opencodeApiClient.question.reject({
                                 requestID: questionProps.id,
                                 directory: options.cwd,
@@ -461,7 +627,7 @@ export class OpenCodeClient {
                     if (sseEvent.type === 'message.updated') {
                         const messageProps = sseEvent.properties;
                         const info = messageProps.info;
-                        const isCurrentAssistantMessage = info?.sessionID === sessionId && info.role === 'assistant';
+                        const isCurrentAssistantMessage = info?.sessionID === activeSessionId && info?.role === 'assistant';
                         if (isCurrentAssistantMessage) {
                             const streamError = extractOpenCodeErrorMessage(info?.error);
                             if (streamError) {
@@ -476,7 +642,7 @@ export class OpenCodeClient {
                     if (sseEvent.type === 'message.completed') {
                         const completedProps = sseEvent.properties;
                         const info = completedProps.info;
-                        const isCurrentAssistantMessage = info?.sessionID === sessionId && info.role === 'assistant';
+                        const isCurrentAssistantMessage = info?.sessionID === activeSessionId && info?.role === 'assistant';
                         if (isCurrentAssistantMessage) {
                             const streamError = extractOpenCodeErrorMessage(info?.error);
                             if (streamError) {
@@ -491,7 +657,7 @@ export class OpenCodeClient {
                     if (sseEvent.type === 'message.failed') {
                         const failedProps = sseEvent.properties;
                         const info = failedProps.info;
-                        const isCurrentAssistantMessage = info?.sessionID === sessionId && info.role === 'assistant';
+                        const isCurrentAssistantMessage = info?.sessionID === activeSessionId && info?.role === 'assistant';
                         if (isCurrentAssistantMessage) {
                             success = false;
                             failureMessage = extractOpenCodeErrorMessage(info?.error) ?? 'OpenCode message failed';
@@ -502,23 +668,23 @@ export class OpenCodeClient {
                     }
                     if (sseEvent.type === 'session.status') {
                         const statusProps = sseEvent.properties;
-                        if (statusProps.sessionID === sessionId && statusProps.status?.type === 'idle') {
+                        if (statusProps.sessionID === activeSessionId && statusProps.status?.type === 'idle') {
                             break;
                         }
                         continue;
                     }
                     if (sseEvent.type === 'session.idle') {
                         const idleProps = sseEvent.properties;
-                        if (idleProps.sessionID === sessionId) {
+                        if (idleProps.sessionID === activeSessionId) {
                             break;
                         }
                         continue;
                     }
                     if (sseEvent.type === 'session.error') {
                         const errorProps = sseEvent.properties;
-                        if (!errorProps.sessionID || errorProps.sessionID === sessionId) {
+                        if (!errorProps.sessionID || errorProps.sessionID === activeSessionId) {
                             success = false;
-                            failureMessage = errorProps.error?.data?.message ?? 'OpenCode session error';
+                            failureMessage = extractOpenCodeErrorMessage(errorProps.error) ?? 'OpenCode session error';
                             diag.onStreamError('session.error', failureMessage);
                             break;
                         }
@@ -526,12 +692,25 @@ export class OpenCodeClient {
                     }
                 }
                 content = [...textContentParts.values()].join('\n');
+                if (!success && !streamAbortController.signal.aborted) {
+                    streamAbortController.abort();
+                }
+                await awaitPromptCompletion();
+                if (promptError !== undefined) {
+                    if (success) {
+                        success = false;
+                        failureMessage = promptError;
+                    }
+                    else if (!failureMessage) {
+                        failureMessage = promptError;
+                    }
+                }
                 diag.onCompleted(success ? 'normal' : 'error', success ? undefined : failureMessage);
                 if (!success) {
                     const message = failureMessage || 'OpenCode execution failed';
                     if (containsRateLimitError(message)) {
-                        const rateLimitedResponse = this.buildRateLimitedResponse(agentType, sessionId, message);
-                        emitResult(options.onStream, false, rateLimitedResponse.error ?? rateLimitedResponse.content, sessionId);
+                        const rateLimitedResponse = this.buildRateLimitedResponse(agentType, activeSessionId, message);
+                        emitResult(options.onStream, false, rateLimitedResponse.error ?? rateLimitedResponse.content, activeSessionId);
                         return rateLimitedResponse;
                     }
                     const retriable = this.isRetriableError(message, streamAbortController.signal.aborted, abortCause);
@@ -540,25 +719,23 @@ export class OpenCodeClient {
                         await this.waitForRetryDelay(attempt, options.abortSignal);
                         continue;
                     }
-                    emitResult(options.onStream, false, message, sessionId);
+                    emitResult(options.onStream, false, message, activeSessionId);
                     return {
                         persona: agentType,
                         status: 'error',
                         content: message,
                         timestamp: new Date(),
-                        sessionId,
+                        sessionId: activeSessionId,
                     };
                 }
                 const trimmed = content.trim();
-                const structuredOutput = parseStructuredOutput(trimmed, !!options.outputSchema);
-                emitResult(options.onStream, true, trimmed, sessionId);
+                emitResult(options.onStream, true, trimmed, activeSessionId);
                 return {
                     persona: agentType,
                     status: 'done',
                     content: trimmed,
                     timestamp: new Date(),
-                    sessionId,
-                    structuredOutput,
+                    sessionId: activeSessionId,
                 };
             }
             catch (error) {
@@ -566,7 +743,9 @@ export class OpenCodeClient {
                 const errorMessage = streamAbortController.signal.aborted
                     ? abortCause === 'timeout'
                         ? timeoutMessage
-                        : OPENCODE_STREAM_ABORTED_MESSAGE
+                        : abortCause === 'prompt' && promptError !== undefined
+                            ? promptError
+                            : OPENCODE_STREAM_ABORTED_MESSAGE
                     : message;
                 if (containsRateLimitError(errorMessage)) {
                     const rateLimitedResponse = this.buildRateLimitedResponse(agentType, sessionId, errorMessage);
@@ -575,7 +754,7 @@ export class OpenCodeClient {
                     }
                     return rateLimitedResponse;
                 }
-                diagRef?.onCompleted(abortCause === 'timeout' ? 'timeout' : streamAbortController.signal.aborted ? 'abort' : 'error', errorMessage);
+                diagRef?.onCompleted(abortCause === 'timeout' ? 'timeout' : streamAbortController.signal.aborted && abortCause !== 'prompt' ? 'abort' : 'error', errorMessage);
                 const retriable = this.isRetriableError(errorMessage, streamAbortController.signal.aborted, abortCause);
                 if (retriable && attempt < OPENCODE_RETRY_MAX_ATTEMPTS) {
                     log.info('Retrying OpenCode call after transient exception', { agentType, attempt, errorMessage });
@@ -600,10 +779,11 @@ export class OpenCodeClient {
                 if (options.abortSignal) {
                     options.abortSignal.removeEventListener('abort', onExternalAbort);
                 }
-                release?.();
                 if (!streamAbortController.signal.aborted) {
                     streamAbortController.abort();
                 }
+                await awaitPromptCompletion();
+                release?.();
             }
         }
         throw new Error('Unreachable: OpenCode retry loop exhausted without returning');