@code-yeongyu/senpi 2026.8.21 → 2026.8.22

package/node_modules/@earendil-works/pi-ai/dist/api/cursor-agent.js

@@ -31,11 +31,18 @@ import { buildMcpStateResult, buildNeutralHookResult, buildPiBashError, buildPiB
 import { AgentClientMessageSchema, AgentConversationTurnStructureSchema, AgentRunRequestSchema, AgentServerMessageSchema, AgentStoreConflictErrorSchema, AgentStoreConflictResultSchema, AssistantMessageSchema, BackgroundShellSpawnResultSchema, CanvasDiagnosticsErrorSchema, CanvasDiagnosticsResultSchema, ClientHeartbeatSchema, ComputerUseErrorSchema, ComputerUseResultSchema, ConversationActionSchema, ConversationSearchErrorSchema, ConversationSearchResultSchema, ConversationStateStructureSchema, ConversationStepSchema, ConversationTurnStructureSchema, DeleteErrorSchema, DeleteRejectedSchema, DeleteResultSchema, DeleteSuccessSchema, DiagnosticsErrorSchema, DiagnosticsRejectedSchema, DiagnosticsResultSchema, DiagnosticsSuccessSchema, ExecClientControlMessageSchema, ExecClientHeartbeatSchema, ExecClientMessageSchema, ExecClientStreamCloseSchema, ExecClientThrowSchema, FetchErrorSchema, FetchResultSchema, ForceBackgroundShellResultSchema, ForceBackgroundShellStatus, ForceBackgroundSubagentResultSchema, ForceBackgroundSubagentStatus, GetBlobResultSchema, GetUsableModelsRequestSchema, GetUsableModelsResponseSchema, GrepContentMatchSchema, GrepContentResultSchema, GrepCountResultSchema, GrepErrorSchema, GrepFileCountSchema, GrepFileMatchSchema, GrepFilesResultSchema, GrepResultSchema, GrepSuccessSchema, GrepUnionResultSchema, KvClientMessageSchema, ListMcpResourcesExecResultSchema, ListMcpResourcesSuccessSchema, LsDirectoryTreeNode_FileSchema, LsDirectoryTreeNodeSchema, LsErrorSchema, LsRejectedSchema, LsResultSchema, LsSuccessSchema, McpAllowlistPrecheckResultSchema, McpApprovedSchema, McpArgsSchema, McpErrorSchema, McpImageContentSchema, McpRejectedSchema, McpResultSchema, McpSuccessSchema, McpTextContentSchema, McpToolCallSchema, McpToolDefinitionSchema, McpToolErrorSchema, McpToolNotFoundSchema, McpToolResultContentItemSchema, McpToolResultSchema, ModelDetailsSchema, ReadErrorSchema, ReadMcpResourceExecResultSchema, ReadMcpResourceNotFoundSchema, ReadRejectedSchema, ReadResultSchema, ReadSuccessSchema, RecordScreenFailureSchema, RecordScreenResultSchema, RequestContextResultSchema, RequestContextSchema, RequestContextSuccessSchema, ResumeActionSchema, SelectedContextSchema, SelectedImageSchema, SetBlobResultSchema, ShellAllowlistPrecheckResultSchema, ShellFailureSchema, ShellRejectedSchema, ShellResultSchema, ShellStreamExitSchema, ShellStreamSchema, ShellStreamStartSchema, ShellStreamStderrSchema, ShellStreamStdoutSchema, ShellSuccessSchema, SmartModeClassifierErrorSchema, SmartModeClassifierResultSchema, SubagentAwaitNotFoundSchema, SubagentAwaitResultSchema, SubagentErrorSchema, SubagentResultSchema, ToolCallSchema, UserMessageActionSchema, UserMessageSchema, WebFetchAllowlistPrecheckResultSchema, WriteErrorSchema, WriteRejectedSchema, WriteResultSchema, WriteShellStdinErrorSchema, WriteShellStdinResultSchema, WriteSuccessSchema, } from "./cursor-agent/gen/agent_pb.js";
 import { composeShellCommand, omitUndefinedArgs, piLimit, piLsPath, piReadArgs, piTimeout, } from "./cursor-agent/pi-args.js";
 import { buildRequestedModel } from "./cursor-agent/reasoning-params.js";
+import { CursorRetryableStreamError, cursorStreamRetryDelayMs, shouldRetryCursorStream, waitForCursorStreamRetry, } from "./cursor-agent/stream-retry.js";
 import { CURSOR_CONVERSATION_POISONED_MESSAGE, createConversationRotationStore, isZeroTokenResourceExhausted, resolveConversationRotationPersistPath, } from "./cursor-conversation-rotation.js";
 import { keepUsableCursorTaskArgs } from "./cursor-task-args.js";
 export const CURSOR_API_URL = "https://api2.cursor.sh";
 export const CURSOR_CLIENT_VERSION = "cli-2026.07.23-e383d2b";
 const EXEC_HEARTBEAT_INTERVAL_MS = 3000;
+/** Maximum inbound silence before a Cursor turn without turnEnded is failed. */
+export const CURSOR_STREAM_HEALTH_FAIL_THRESHOLD_MS = 30_000;
+/** @deprecated Heartbeats and checkpoints count as inbound liveness without a separate deadline. */
+export const CURSOR_STREAM_HEALTH_HEARTBEAT_ONLY_THRESHOLD_MS = CURSOR_STREAM_HEALTH_FAIL_THRESHOLD_MS * 3;
+/** Maximum time allowed to drain exec handlers after turnEnded. */
+export const CURSOR_TURN_END_DRAIN_TIMEOUT_MS = 5000;
 /**
  * HTTP/1 connection-specific headers that HTTP/2 forbids. Node's
  * `http2.request()` throws on these rather than dropping them.
@@ -221,8 +228,10 @@ export const stream = (model, context, options) => {
         let h2Client = null;
         let h2Request = null;
         let heartbeatTimer = null;
+        let streamHealthTimer = null;
         let h2Settled = false;
         let sawTurnEnded = false;
+        let turnEndDrainTimedOut = false;
         let endStreamError = null;
         // Reachable from the catch: a stream that dies mid-turn must still close
         // and pair the blocks it left open.
@@ -233,6 +242,10 @@ export const stream = (model, context, options) => {
             if (h2Settled)
                 return;
             h2Settled = true;
+            if (streamHealthTimer) {
+                clearTimeout(streamHealthTimer);
+                streamHealthTimer = null;
+            }
             if (error !== undefined) {
                 rejectH2(error);
                 return;
@@ -252,19 +265,25 @@ export const stream = (model, context, options) => {
         let baseConversationId;
         let conversationId;
         let usageState;
-        let retryPoisonedConversation = false;
+        let retryAttempt = false;
         let attempt = 0;
+        let streamRetries = 0;
+        let forceResumeAction = false;
+        let pinnedRequestedModel;
+        let pinnedModelDetails;
         do {
-            retryPoisonedConversation = false;
+            retryAttempt = false;
             attempt += 1;
             h2Settled = false;
             sawTurnEnded = false;
+            turnEndDrainTimedOut = false;
             endStreamError = null;
             openBlockState = undefined;
             const h2Completion = new Promise((resolve, reject) => {
                 resolveH2 = resolve;
                 rejectH2 = reject;
             });
+            let attemptSawCheckpoint = false;
             try {
                 const apiKey = options?.apiKey;
                 if (!apiKey) {
@@ -275,11 +294,16 @@ export const stream = (model, context, options) => {
                 const blobStore = conversationBlobStores.get(conversationId) ?? new Map();
                 conversationBlobStores.set(conversationId, blobStore);
                 const cachedState = conversationStateCache.get(conversationId);
-                const { requestBytes, conversationState } = await buildGrpcRequest(model, context, options, {
+                const { requestBytes, conversationState, requestedModel, modelDetails } = await buildGrpcRequest(model, context, options, {
                     conversationId,
                     blobStore,
                     conversationState: cachedState,
+                    forceResumeAction,
+                    pinnedRequestedModel,
+                    pinnedModelDetails,
                 });
+                pinnedRequestedModel ??= requestedModel;
+                pinnedModelDetails ??= modelDetails;
                 conversationStateCache.set(conversationId, conversationState);
                 const requestContextTools = buildMcpToolDefinitions(context.tools);
                 const baseUrl = model.baseUrl || CURSOR_API_URL;
@@ -300,9 +324,28 @@ export const stream = (model, context, options) => {
                     "x-cursor-client-type": "cli",
                     "x-request-id": randomUUID(),
                 };
-                h2Client = http2.connect(baseUrl);
-                h2Client.on("error", (error) => settleH2(mapH2TransportError(error, baseUrl)));
-                h2Request = h2Client.request(requestHeaders);
+                const attemptH2Client = http2.connect(baseUrl);
+                h2Client = attemptH2Client;
+                attemptH2Client.on("error", (error) => {
+                    if (h2Client !== attemptH2Client)
+                        return;
+                    const mapped = mapH2TransportError(error, baseUrl);
+                    settleH2(sawTurnEnded
+                        ? mapped
+                        : new CursorRetryableStreamError(mapped instanceof Error ? mapped.message : String(mapped), "transport", { cause: mapped }));
+                });
+                attemptH2Client.on("goaway", () => {
+                    if (h2Client === attemptH2Client && !h2Settled && !sawTurnEnded) {
+                        settleH2(new CursorRetryableStreamError("Cursor HTTP/2 session received GOAWAY", "transport"));
+                        h2Request?.close();
+                    }
+                });
+                attemptH2Client.on("close", () => {
+                    if (h2Client === attemptH2Client && !h2Settled && !sawTurnEnded && !endStreamError) {
+                        settleH2(new CursorRetryableStreamError("Cursor HTTP/2 session closed", "transport"));
+                    }
+                });
+                h2Request = attemptH2Client.request(requestHeaders);
                 if (attempt === 1) {
                     stream.push({ type: "start", partial: output });
                 }
@@ -337,8 +380,55 @@ export const stream = (model, context, options) => {
                 };
                 openBlockState = state;
                 const onConversationCheckpoint = (checkpoint) => {
+                    attemptSawCheckpoint = true;
                     conversationStateCache.set(conversationId, checkpoint);
                 };
+                const healthFailThresholdMs = options?.streamHealthFailThresholdMs ?? CURSOR_STREAM_HEALTH_FAIL_THRESHOLD_MS;
+                let lastInboundFrameAt = Date.now();
+                let turnEndCompletionStarted = false;
+                const armStreamHealthTimer = () => {
+                    if (streamHealthTimer)
+                        clearTimeout(streamHealthTimer);
+                    if (sawTurnEnded || h2Settled)
+                        return;
+                    const now = Date.now();
+                    const deadline = lastInboundFrameAt + healthFailThresholdMs;
+                    streamHealthTimer = setTimeout(() => {
+                        streamHealthTimer = null;
+                        if (sawTurnEnded || h2Settled)
+                            return;
+                        const stalledFor = Date.now() - lastInboundFrameAt;
+                        if (stalledFor < healthFailThresholdMs) {
+                            armStreamHealthTimer();
+                            return;
+                        }
+                        settleH2(new CursorRetryableStreamError("Cursor stream ended before turnEnded: inbound stream stalled", "stall"));
+                        h2Request?.close();
+                    }, Math.max(0, deadline - now));
+                };
+                const completeAfterTurnEnded = async () => {
+                    const drainTimeoutMs = options?.turnEndDrainTimeoutMs ?? CURSOR_TURN_END_DRAIN_TIMEOUT_MS;
+                    let timeout;
+                    const drained = await Promise.race([
+                        drainInFlightDispatches().then(() => true),
+                        new Promise((resolve) => {
+                            timeout = setTimeout(() => resolve(false), drainTimeoutMs);
+                        }),
+                    ]);
+                    if (timeout)
+                        clearTimeout(timeout);
+                    if (h2Settled)
+                        return;
+                    if (!drained) {
+                        turnEndDrainTimedOut = true;
+                        settleH2(new Error(`Cursor exec dispatches did not settle within ${drainTimeoutMs}ms after turnEnded`));
+                        h2Request?.close();
+                        return;
+                    }
+                    h2Request?.close();
+                    settleH2();
+                };
+                armStreamHealthTimer();
                 h2Request.on("data", (chunk) => {
                     // Steady state drains fully per chunk; alias the fresh h2 chunk
                     // instead of copying it through Buffer.concat.
@@ -360,8 +450,12 @@ export const stream = (model, context, options) => {
                         }
                         try {
                             const serverMessage = fromBinary(AgentServerMessageSchema, messageBytes);
-                            const isTurnEnded = serverMessage.message.case === "interactionUpdate" &&
-                                serverMessage.message.value.message?.case === "turnEnded";
+                            const interactionUpdateCase = serverMessage.message.case === "interactionUpdate"
+                                ? serverMessage.message.value.message?.case
+                                : undefined;
+                            const isTurnEnded = interactionUpdateCase === "turnEnded";
+                            lastInboundFrameAt = Date.now();
+                            armStreamHealthTimer();
                             // Dispatch is fire-and-forget so the socket keeps draining
                             // while a handler runs, but the promise is tracked: `done`
                             // must not be pushed while an exec handler is still resolving,
@@ -372,10 +466,13 @@ export const stream = (model, context, options) => {
                             });
                             inFlightDispatches.add(dispatch);
                             void dispatch.finally(() => inFlightDispatches.delete(dispatch));
-                            // Application completion is not protocol success; wait for a
-                            // clean HTTP/2 end.
-                            if (isTurnEnded) {
+                            // turnEnded is the definitive application completion signal. Drain
+                            // every dispatch it follows, then close our side of the stream so a
+                            // server that keeps HTTP/2 open cannot hold the turn hostage.
+                            if (isTurnEnded && !turnEndCompletionStarted) {
                                 sawTurnEnded = true;
+                                turnEndCompletionStarted = true;
+                                void completeAfterTurnEnded().catch((error) => settleH2(error));
                             }
                         }
                         catch (e) {
@@ -401,10 +498,17 @@ export const stream = (model, context, options) => {
                     }
                 });
                 h2Request.on("end", () => {
+                    if (!sawTurnEnded && !endStreamError) {
+                        settleH2(new CursorRetryableStreamError("Cursor stream ended before turnEnded", "clean-end"));
+                        return;
+                    }
                     settleH2();
                 });
                 h2Request.on("error", (error) => {
-                    settleH2(mapH2TransportError(error, baseUrl));
+                    const mapped = mapH2TransportError(error, baseUrl);
+                    settleH2(sawTurnEnded
+                        ? mapped
+                        : new CursorRetryableStreamError(mapped instanceof Error ? mapped.message : String(mapped), "transport", { cause: mapped }));
                 });
                 if (options?.signal) {
                     options.signal.addEventListener("abort", () => {
@@ -435,8 +539,43 @@ export const stream = (model, context, options) => {
                 // Same reason as the success path: a handler still running would land
                 // its real result after the turn finalized and be discarded — even
                 // though the tool may already have run side effects. On abort the
-                // drain returns immediately.
-                await drainInFlightDispatches();
+                // drain returns immediately. A post-turn drain timeout is already the
+                // bound: do not wait forever a second time in the error path.
+                if (!turnEndDrainTimedOut)
+                    await drainInFlightDispatches();
+                const shouldRetryStream = shouldRetryCursorStream({
+                    error,
+                    retries: streamRetries,
+                    maxRetries: options?.streamStallMaxRetries ?? 10,
+                    sawTurnEnded,
+                    aborted: options?.signal?.aborted === true,
+                });
+                if (shouldRetryStream) {
+                    if (openBlockState) {
+                        // Resume responses continue from the server checkpoint. Close any
+                        // locally open cards before resetting per-attempt bookkeeping; no
+                        // speculative replay deduplication is attempted.
+                        endCurrentTextBlock(output, stream, openBlockState);
+                        endCurrentThinkingBlock(output, stream, openBlockState);
+                        flushOpenToolCalls(output, stream, openBlockState);
+                    }
+                    forceResumeAction ||= attemptSawCheckpoint;
+                    const retryDelayMs = cursorStreamRetryDelayMs({
+                        attempt: streamRetries,
+                        fixedDelayMs: options?.streamStallRetryDelayMs,
+                    });
+                    streamRetries += 1;
+                    retryAttempt = true;
+                    await waitForCursorStreamRetry(retryDelayMs, options?.signal);
+                    if (options?.signal?.aborted) {
+                        retryAttempt = false;
+                        output.stopReason = "aborted";
+                        output.errorMessage = "Request was aborted";
+                        stream.push({ type: "error", reason: output.stopReason, error: output });
+                        stream.end();
+                    }
+                    continue;
+                }
                 // A stream that dies mid-turn leaves blocks open. Closing them here
                 // settles their live cards and pairs the server-owned calls that
                 // nothing else answers — an unpaired call is stripped from every
@@ -485,14 +624,14 @@ export const stream = (model, context, options) => {
                             const blobs = conversationBlobStores.get(conversationId);
                             if (blobs)
                                 conversationBlobStores.set(decision.wireId, blobs);
-                            retryPoisonedConversation = true;
+                            retryAttempt = true;
                         }
                         else {
                             message = CURSOR_CONVERSATION_POISONED_MESSAGE;
                         }
                     }
                 }
-                if (!retryPoisonedConversation) {
+                if (!retryAttempt) {
                     output.stopReason = options?.signal?.aborted ? "aborted" : "error";
                     output.errorMessage = message;
                     stream.push({ type: "error", reason: output.stopReason, error: output });
@@ -509,7 +648,7 @@ export const stream = (model, context, options) => {
                 h2Request = null;
                 h2Client = null;
             }
-        } while (retryPoisonedConversation);
+        } while (retryAttempt);
     })();
     return stream;
 };
@@ -3195,7 +3334,7 @@ async function buildGrpcRequest(model, context, options, state) {
         }
     }
     const action = create(ConversationActionSchema, {
-        action: userContent && (userText.trim().length > 0 || hasUserImages)
+        action: !state.forceResumeAction && userContent && (userText.trim().length > 0 || hasUserImages)
             ? {
                 case: "userMessageAction",
                 value: create(UserMessageActionSchema, {
@@ -3244,15 +3383,16 @@ async function buildGrpcRequest(model, context, options, state) {
         rootPromptMessagesJson,
         turns,
     });
-    const requestedModel = buildRequestedModel(model, options?.thinkingSelection);
+    const requestedModel = state.pinnedRequestedModel ?? buildRequestedModel(model, options?.thinkingSelection);
     const wireModelId = requestedModel.modelId;
     const cursorMaxMode = model.compat?.cursorMaxMode === true;
-    const modelDetails = create(ModelDetailsSchema, {
-        modelId: wireModelId,
-        displayModelId: model.id,
-        displayName: model.name,
-        ...(cursorMaxMode ? { maxMode: true } : undefined),
-    });
+    const modelDetails = state.pinnedModelDetails ??
+        create(ModelDetailsSchema, {
+            modelId: wireModelId,
+            displayModelId: model.id,
+            displayName: model.name,
+            ...(cursorMaxMode ? { maxMode: true } : undefined),
+        });
     const runRequest = create(AgentRunRequestSchema, {
         conversationState,
         action,
@@ -3272,7 +3412,7 @@ async function buildGrpcRequest(model, context, options, state) {
         bytes: requestBytes.length,
         tools: context.tools?.length ?? 0,
     });
-    return { requestBytes, blobStore, conversationState };
+    return { requestBytes, blobStore, conversationState, requestedModel, modelDetails };
 }
 function hasImages(content) {
     return content.some((item) => item.type === "image");