@playwo/opencode-cursor-oauth 0.0.0-dev.2c48be2f48c9 → 0.0.0-dev.36e1216df6cf

package/dist/proxy/bridge-non-streaming.js

@@ -5,6 +5,7 @@ import { updateStoredConversationAfterCompletion } from "./conversation-state";
 import { startBridge } from "./bridge-session";
 import { updateConversationCheckpoint, syncStoredBlobStore, } from "./state-sync";
 import { computeUsage, createConnectFrameParser, createThinkingTagFilter, parseConnectEndStream, processServerMessage, scheduleBridgeEnd, } from "./stream-dispatch";
+import { createBridgeCloseController } from "./bridge-close-controller";
 export async function handleNonStreamingResponse(payload, accessToken, modelId, convKey, metadata) {
     const completionId = `chatcmpl-${crypto.randomUUID().replace(/-/g, "").slice(0, 28)}`;
     const created = Math.floor(Date.now() / 1000);
@@ -33,6 +34,7 @@ async function collectFullResponse(payload, accessToken, modelId, convKey, metad
     let endStreamError = null;
     const pendingToolCalls = [];
     const { bridge, heartbeatTimer } = await startBridge(accessToken, payload.requestBytes);
+    const bridgeCloseController = createBridgeCloseController(bridge);
     const state = {
         toolCallIndex: 0,
         pendingExecs: [],
@@ -43,22 +45,49 @@ async function collectFullResponse(payload, accessToken, modelId, convKey, metad
     bridge.onData(createConnectFrameParser((messageBytes) => {
         try {
             const serverMessage = fromBinary(AgentServerMessageSchema, messageBytes);
-            processServerMessage(serverMessage, payload.blobStore, payload.mcpTools, (data) => bridge.write(data), state, (text, isThinking) => {
+            processServerMessage(serverMessage, payload.blobStore, payload.cloudRule, payload.mcpTools, (data) => bridge.write(data), state, (text, isThinking) => {
                 if (isThinking)
                     return;
                 const { content } = tagFilter.process(text);
                 fullText += content;
             }, (exec) => {
-                pendingToolCalls.push({
+                const toolCall = {
                     id: exec.toolCallId,
                     type: "function",
                     function: {
                         name: exec.toolName,
                         arguments: exec.decodedArgs,
                     },
+                };
+                const existingIndex = pendingToolCalls.findIndex((call) => call.id === exec.toolCallId);
+                if (existingIndex >= 0) {
+                    pendingToolCalls[existingIndex] = toolCall;
+                }
+                else {
+                    pendingToolCalls.push(toolCall);
+                }
+            }, (_info) => { }, undefined, (checkpointBytes) => {
+                updateConversationCheckpoint(convKey, checkpointBytes);
+                bridgeCloseController.noteCheckpoint();
+                if (pendingToolCalls.length > 0) {
+                    scheduleBridgeEnd(bridge);
+                }
+            }, () => {
+                bridgeCloseController.noteTurnEnded();
+                if (pendingToolCalls.length > 0) {
+                    scheduleBridgeEnd(bridge);
+                }
+            }, (info) => {
+                endStreamError = new Error(`Cursor returned unsupported ${info.category}: ${info.caseName}${info.detail ? ` (${info.detail})` : ""}`);
+                logPluginError("Closing non-streaming Cursor bridge after unsupported message", {
+                    modelId,
+                    convKey,
+                    category: info.category,
+                    caseName: info.caseName,
+                    detail: info.detail,
                 });
                 scheduleBridgeEnd(bridge);
-            }, (checkpointBytes) => updateConversationCheckpoint(convKey, checkpointBytes), (info) => {
+            }, (info) => {
                 endStreamError = new Error(`Cursor requested unsupported exec type: ${info.execCase}`);
                 logPluginError("Closing non-streaming Cursor bridge after unsupported exec", {
                     modelId,
@@ -85,6 +114,7 @@ async function collectFullResponse(payload, accessToken, modelId, convKey, metad
         scheduleBridgeEnd(bridge);
     }));
     bridge.onClose(() => {
+        bridgeCloseController.dispose();
         clearInterval(heartbeatTimer);
         syncStoredBlobStore(convKey, payload.blobStore);
         const flushed = tagFilter.flush();

package/dist/proxy/bridge-session.js

@@ -2,12 +2,10 @@ import { createCursorSession } from "../cursor/bidi-session";
 import { makeHeartbeatBytes } from "./stream-dispatch";
 const HEARTBEAT_INTERVAL_MS = 5_000;
 export async function startBridge(accessToken, requestBytes) {
-    const requestId = crypto.randomUUID();
     const bridge = await createCursorSession({
         accessToken,
-        requestId,
+        initialRequestBytes: requestBytes,
     });
-    bridge.write(requestBytes);
     const heartbeatTimer = setInterval(() => bridge.write(makeHeartbeatBytes()), HEARTBEAT_INTERVAL_MS);
     return { bridge, heartbeatTimer };
 }

package/dist/proxy/bridge-streaming.d.ts

@@ -2,4 +2,4 @@ import { type ToolResultInfo } from "../openai/messages";
 import type { ConversationRequestMetadata } from "./conversation-meta";
 import type { ActiveBridge, CursorRequestPayload } from "./types";
 export declare function handleStreamingResponse(payload: CursorRequestPayload, accessToken: string, modelId: string, bridgeKey: string, convKey: string, metadata: ConversationRequestMetadata): Promise<Response>;
-export declare function handleToolResultResume(active: ActiveBridge, toolResults: ToolResultInfo[], bridgeKey: string, convKey: string): Response;
+export declare function handleToolResultResume(active: ActiveBridge, toolResults: ToolResultInfo[], bridgeKey: string, convKey: string): Promise<Response>;