@code-yeongyu/senpi 2026.8.21-3 → 2026.8.22

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

@@ -31,6 +31,7 @@ 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";
@@ -38,7 +39,7 @@ 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;
-/** Maximum heartbeat/checkpoint-only silence before a Cursor turn is failed. */
+/** @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;
@@ -264,10 +265,14 @@ 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;
@@ -278,6 +283,7 @@ export const stream = (model, context, options) => {
                 resolveH2 = resolve;
                 rejectH2 = reject;
             });
+            let attemptSawCheckpoint = false;
             try {
                 const apiKey = options?.apiKey;
                 if (!apiKey) {
@@ -288,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;
@@ -313,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 });
                 }
@@ -350,12 +380,11 @@ 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;
-                const heartbeatOnlyThresholdMs = options?.streamHealthHeartbeatOnlyThresholdMs ?? CURSOR_STREAM_HEALTH_HEARTBEAT_ONLY_THRESHOLD_MS;
                 let lastInboundFrameAt = Date.now();
-                let lastMeaningfulFrameAt = lastInboundFrameAt;
                 let turnEndCompletionStarted = false;
                 const armStreamHealthTimer = () => {
                     if (streamHealthTimer)
@@ -363,18 +392,17 @@ export const stream = (model, context, options) => {
                     if (sawTurnEnded || h2Settled)
                         return;
                     const now = Date.now();
-                    const deadline = Math.min(lastInboundFrameAt + healthFailThresholdMs, lastMeaningfulFrameAt + heartbeatOnlyThresholdMs);
+                    const deadline = lastInboundFrameAt + healthFailThresholdMs;
                     streamHealthTimer = setTimeout(() => {
                         streamHealthTimer = null;
                         if (sawTurnEnded || h2Settled)
                             return;
                         const stalledFor = Date.now() - lastInboundFrameAt;
-                        const meaningfulStalledFor = Date.now() - lastMeaningfulFrameAt;
-                        if (stalledFor < healthFailThresholdMs && meaningfulStalledFor < heartbeatOnlyThresholdMs) {
+                        if (stalledFor < healthFailThresholdMs) {
                             armStreamHealthTimer();
                             return;
                         }
-                        settleH2(new Error("Cursor stream ended before turnEnded: inbound stream stalled"));
+                        settleH2(new CursorRetryableStreamError("Cursor stream ended before turnEnded: inbound stream stalled", "stall"));
                         h2Request?.close();
                     }, Math.max(0, deadline - now));
                 };
@@ -426,11 +454,7 @@ export const stream = (model, context, options) => {
                                 ? serverMessage.message.value.message?.case
                                 : undefined;
                             const isTurnEnded = interactionUpdateCase === "turnEnded";
-                            const isLivenessOnly = interactionUpdateCase === "heartbeat" ||
-                                serverMessage.message.case === "conversationCheckpointUpdate";
                             lastInboundFrameAt = Date.now();
-                            if (!isLivenessOnly)
-                                lastMeaningfulFrameAt = lastInboundFrameAt;
                             armStreamHealthTimer();
                             // Dispatch is fire-and-forget so the socket keeps draining
                             // while a handler runs, but the promise is tracked: `done`
@@ -474,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", () => {
@@ -512,6 +543,39 @@ export const stream = (model, context, options) => {
                 // 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
@@ -560,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 });
@@ -584,7 +648,7 @@ export const stream = (model, context, options) => {
                 h2Request = null;
                 h2Client = null;
             }
-        } while (retryPoisonedConversation);
+        } while (retryAttempt);
     })();
     return stream;
 };
@@ -3270,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, {
@@ -3319,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,
@@ -3347,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");