fix: surface completed native WebFetch documents (#183)

dwgx · claude · dwgx · commit 1c47aef3df29 · 2026-06-07T22:18:59.000+09:00
The native WebFetch path actually works end-to-end: when the language server already executed read_url_content and returned a real web_document, Cascade also produced a final assistant answer. But the proxy mislabeled the completed step (a co-present requested_interaction echo was checked first) and surfaced a dead read_url_content tool-call proposal, dropping both the model answer and the fetched document. - proto-trace.js: classify completed_web_document before pending_permission - windsurf.js: flag read_url_content steps that carry a real web_document - client.js: split completed WebFetch results from proposals; do not re-approve or early-stop on an already-executed result - handlers/chat.js: completed read_url_content is not converted to OpenAI tool_calls; preserve final model text (finish_reason=stop), fall back to the document body when the model produced no text. Stream path guards against duplicate output. Bash/Read/Grep and document-less pending WebFetch keep existing proposal semantics. Verified on a memory-safe lab instance: native WebFetch fetches https://example.com and the document content is confirmed present. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
diff --git a/docs/releases/RELEASE_NOTES_2.0.144.md b/docs/releases/RELEASE_NOTES_2.0.144.md
@@ -0,0 +1,16 @@
+## v2.0.144 - WebFetch completed document handling
+
+This release fixes the lab-gated native WebFetch path when the language server
+has already executed `read_url_content` and returned a real `web_document`.
+
+- Completed `read_url_content.web_document` steps are no longer surfaced to
+  OpenAI clients as dead tool-call proposals. The proxy now preserves Cascade's
+  final assistant text with `finish_reason="stop"`.
+- If Cascade returns a completed WebFetch document but no final text, the proxy
+  falls back to the fetched document body as assistant content.
+- Pending WebFetch permission steps without a document keep the existing
+  proposal/wait behavior, and Bash/Read/Grep native proposal semantics are
+  unchanged.
+- Proto trace classification now checks `completed_web_document` before
+  `pending_permission`, so steps that contain both `web_document` and a
+  requested-interaction echo are classified as completed.
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "windsurf-api",
-  "version": "2.0.143",
+  "version": "2.0.144",
   "description": "Windsurf to OpenAI + Anthropic compatible API proxy. Turns Windsurf's 107 AI models (Claude, GPT, Gemini, DeepSeek, Grok, Qwen, Kimi, GLM, SWE) into dual-protocol API endpoints. Zero npm deps.",
   "type": "module",
   "main": "src/index.js",
diff --git a/src/client.js b/src/client.js
@@ -288,6 +288,14 @@ export function shouldColdStall({ elapsed, coldStallMs, sawActive, sawText, tota
   return elapsed > coldStallMs && sawActive && !sawText && (totalThinking || 0) === 0 && (toolCallCount || 0) === 0;
 }
 
+function isCompletedReadUrlNativeResult(tc) {
+  return !!(tc?.cascade_native
+    && tc.name === 'read_url_content'
+    && tc.hasWebDocument
+    && typeof tc.result === 'string'
+    && tc.result.length > 0);
+}
+
 // v2.0.74 (#122). Three-tier ceiling picker for warm-stall detection.
 // Exported so the regression test can assert that:
 //   - tool-active beats thinking beats text-only
@@ -918,12 +926,13 @@ export class WindsurfClient {
         const steps = parseTrajectorySteps(stepsResp);
         const hasNativeProposalInBatch = nativeMode && !nativeBridgePollAfterTool
           && steps.some(step => Array.isArray(step?.toolCalls)
-            && step.toolCalls.some(tc => tc?.cascade_native));
+            && step.toolCalls.some(tc => tc?.cascade_native && !isCompletedReadUrlNativeResult(tc)));
 
         if (nativeMode && (nativeAllowlist || []).includes('read_url_content')) {
           for (let i = 0; i < steps.length; i++) {
             const pending = steps[i]?.requestedInteraction;
             if (pending?.kind !== 'read_url_content') continue;
+            if (steps[i]?.toolCalls?.some(isCompletedReadUrlNativeResult)) continue;
             const url = pending.url || '';
             const origin = pending.origin || '';
             if (!isReadUrlAutoApproveAllowed(url, origin)) continue;
@@ -1058,7 +1067,9 @@ export class WindsurfClient {
               // ChatToolCall variants are dropped in chat.js anyway —
               // see "Built-in Cascade tool calls ... DROPPED" comment).
               if (tc.cascade_native) {
-                const chunk = { text: '', thinking: '', isError: false, nativeToolCall: tc };
+                const chunk = isCompletedReadUrlNativeResult(tc)
+                  ? { text: '', thinking: '', isError: false, nativeToolResult: tc }
+                  : { text: '', thinking: '', isError: false, nativeToolCall: tc };
                 chunks.push(chunk);
                 onChunk?.(chunk);
               }
@@ -1067,7 +1078,8 @@ export class WindsurfClient {
             // Cascade-native IDE step has been surfaced as a tool_call, stop
             // polling immediately so the LS does not keep executing the
             // built-in tool in the remote workspace while the client waits.
-            if (nativeMode && step.toolCalls.some(tc => tc.cascade_native)) {
+            const hasNativeProposal = step.toolCalls.some(tc => tc.cascade_native && !isCompletedReadUrlNativeResult(tc));
+            if (nativeMode && hasNativeProposal) {
               if (!nativeBridgePollAfterTool) {
                 endReason = 'native_tool_call';
                 break;
diff --git a/src/handlers/chat.js b/src/handlers/chat.js
@@ -87,6 +87,14 @@ function appendAssistantTurn(messages, allText, toolCalls) {
   return [...(messages || []), m];
 }
 
+function isCompletedReadUrlNativeResult(raw) {
+  return !!(raw?.cascade_native
+    && raw.name === 'read_url_content'
+    && raw.hasWebDocument
+    && typeof raw.result === 'string'
+    && raw.result.length > 0);
+}
+
 // Cap exponential backoff before falling over to the next account when
 // upstream Cascade returns "internal error occurred". Without this a
 // 9-account pool hammers the upstream within ~10s and every attempt
@@ -2516,6 +2524,7 @@ async function nonStreamResponse(client, id, created, model, modelKey, messages,
     let allThinking = '';
     let cascadeMeta = null;
     let toolCalls = [];
+    let hasCompletedNativeReadUrlResult = false;
     const bridgeDiag = {
       bridgeEnabled: nativeBridgeOn,
       requestedTools: Array.isArray(tools) && tools.length > 0,
@@ -2566,11 +2575,18 @@ async function nonStreamResponse(client, id, created, model, modelKey, messages,
         // can't be safely surfaced (caller wouldn't know how to execute).
         const lookup = nativeOpts?.callerLookup || new Map();
         const nativeCalls = [];
+        const nativeResults = [];
+        let usedNativeReadUrlFallback = false;
         for (const raw of (chunks.toolCalls || [])) {
           if (!raw?.cascade_native) continue;
           bridgeDiag.cascadeToolCalls++;
           bridgeDiag.cascadeKinds.push(raw.name);
           recordNativeBridgeCascadeToolCall(raw.name);
+          if (isCompletedReadUrlNativeResult(raw)) {
+            nativeResults.push(raw);
+            hasCompletedNativeReadUrlResult = true;
+            continue;
+          }
           const candidates = lookup.get(raw.name) || [];
           const callerName = candidates[0];
           if (!callerName) {
@@ -2595,7 +2611,11 @@ async function nonStreamResponse(client, id, created, model, modelKey, messages,
         }
         toolCalls = filterToolCallsByAllowlist(nativeCalls, tools);
         for (const tc of toolCalls) recordNativeBridgeEmittedToolCall(tc.name, { source: 'cascade' });
-        if (toolCalls.length === 0 && allText) {
+        if (!allText && toolCalls.length === 0 && nativeResults.length) {
+          allText = nativeResults.map(raw => raw.result).filter(Boolean).join('\n');
+          usedNativeReadUrlFallback = !!allText;
+        }
+        if (toolCalls.length === 0 && allText && !usedNativeReadUrlFallback) {
           const fallback = parseNativeFunctionCallsFromText(allText, lookup);
           const filteredFallback = filterToolCallsByAllowlist(fallback.toolCalls, tools);
           allText = fallback.text || '';
@@ -2612,10 +2632,10 @@ async function nonStreamResponse(client, id, created, model, modelKey, messages,
         // emitting the cascade step, and the caller doesn't want that
         // noise.
         allText = stripToolMarkupFromText(allText);
-        if (toolCalls.length === 0 && (chunks.toolCalls || []).length > 0) {
+        if (toolCalls.length === 0 && nativeResults.length === 0 && (chunks.toolCalls || []).length > 0) {
           log.info(`Chat[non-stream]: nativeBridge=true received ${chunks.toolCalls.length} cascade tool calls but none mapped to caller tools (kinds=${chunks.toolCalls.map(tc => tc.name).join(',')})`);
         }
-        if (toolCalls.length === 0) recordNativeBridgeNoToolCallResponse();
+        if (toolCalls.length === 0 && nativeResults.length === 0) recordNativeBridgeNoToolCallResponse();
       } else if (emulateTools) {
         // Capture pre-parse text once for diagnostic logging — useful when
         // non-Claude models emit a tool call in a format the parser missed.
@@ -2844,7 +2864,7 @@ async function nonStreamResponse(client, id, created, model, modelKey, messages,
       allThinking = '';
     }
     bridgeDiag.totalToolCalls = toolCalls.length;
-    bridgeDiag.noToolCalls = bridgeDiag.requestedTools && toolCalls.length === 0;
+    bridgeDiag.noToolCalls = bridgeDiag.requestedTools && toolCalls.length === 0 && !hasCompletedNativeReadUrlResult;
     logBridgeResultDiagnostics(reqId, bridgeDiag);
 
     // Check the cascade back into the pool under the *post-turn* fingerprint
@@ -3226,6 +3246,7 @@ function streamResponse(id, created, model, modelKey, provider, messages, cascad
         route: deps?.route || 'chat',
       }) : null;
       const collectedToolCalls = [];
+      const completedNativeReadUrlResults = [];
       const bridgeDiagCascadeSeen = new Set();
       const bridgeDiag = {
         bridgeEnabled: nativeBridgeOn,
@@ -3325,6 +3346,18 @@ function streamResponse(id, created, model, modelKey, provider, messages, cascad
         // back into the caller's OpenAI tool name via callerLookup, then
         // emit as a tool_call delta. Old behaviour batched these at
         // turn end (release notes for v2.0.65 documented the gap).
+        if (nativeBridgeOn && chunk.nativeToolResult) {
+          const raw = chunk.nativeToolResult;
+          if (markBridgeDiagCascadeRaw({ ...raw, cascade_native: true })) {
+            recordNativeBridgeCascadeToolCall(raw.name);
+          }
+          if (isCompletedReadUrlNativeResult(raw)
+              && !completedNativeReadUrlResults.some(existing => (existing.id || '') === (raw.id || ''))) {
+            completedNativeReadUrlResults.push(raw);
+          }
+          return;
+        }
+
         if (nativeBridgeOn && chunk.nativeToolCall) {
           const raw = chunk.nativeToolCall;
           markBridgeDiagCascadeRaw({ ...raw, cascade_native: true });
@@ -3695,8 +3728,15 @@ function streamResponse(id, created, model, modelKey, provider, messages, cascad
               const nativeRaw = [];
               for (const raw of cascadeResult.toolCalls) {
                 if (!raw?.cascade_native) continue;
-                markBridgeDiagCascadeRaw(raw);
-                recordNativeBridgeCascadeToolCall(raw.name);
+                if (markBridgeDiagCascadeRaw(raw)) {
+                  recordNativeBridgeCascadeToolCall(raw.name);
+                }
+                if (isCompletedReadUrlNativeResult(raw)) {
+                  if (!completedNativeReadUrlResults.some(existing => (existing.id || '') === (raw.id || ''))) {
+                    completedNativeReadUrlResults.push(raw);
+                  }
+                  continue;
+                }
                 const candidates = lookup.get(raw.name) || [];
                 const callerName = candidates[0];
                 if (!callerName) {
@@ -3727,13 +3767,18 @@ function streamResponse(id, created, model, modelKey, provider, messages, cascad
                 recordNativeBridgeEmittedToolCall(tc.name, { source: 'cascade' });
                 emitToolCallDelta(tc, idx);
               }
-              if (filteredNative.length === 0 && cascadeResult.toolCalls.some(tc => tc.cascade_native)) {
+              if (filteredNative.length === 0 && completedNativeReadUrlResults.length === 0 && cascadeResult.toolCalls.some(tc => tc.cascade_native)) {
                 log.info(`Chat[stream]: nativeBridge=true received cascade tool calls but none mapped to caller tools (kinds=${cascadeResult.toolCalls.filter(tc => tc.cascade_native).map(tc => tc.name).join(',')})`);
               }
             }
-            if (nativeBridgeOn && collectedToolCalls.length === 0) recordNativeBridgeNoToolCallResponse();
+            if (accText.length === 0 && collectedToolCalls.length === 0 && completedNativeReadUrlResults.length) {
+              const fallbackText = completedNativeReadUrlResults.map(raw => raw.result).filter(Boolean).join('\n');
+              if (fallbackText) emitContent(pathStreamText.feed(fallbackText));
+              emitContent(pathStreamText.flush());
+            }
+            if (nativeBridgeOn && collectedToolCalls.length === 0 && completedNativeReadUrlResults.length === 0) recordNativeBridgeNoToolCallResponse();
             bridgeDiag.totalToolCalls = collectedToolCalls.length;
-            bridgeDiag.noToolCalls = bridgeDiag.requestedTools && collectedToolCalls.length === 0;
+            bridgeDiag.noToolCalls = bridgeDiag.requestedTools && collectedToolCalls.length === 0 && completedNativeReadUrlResults.length === 0;
             logBridgeResultDiagnostics(reqId, bridgeDiag);
             // Pool check-in on success (cascade only)
             if (reuseEnabled && cascadeResult?.cascadeId && (accText || collectedToolCalls.length)) {
diff --git a/src/proto-trace.js b/src/proto-trace.js
@@ -700,8 +700,8 @@ function summarizeWebFetchTrajectoryBranch({ type, status, nativeOneofs, request
   const hasLegacySummary = legacySummaryBytes > 0;
   const autoRunDecision = readUrlOneof?.body?.autoRunDecision ?? null;
   let state = null;
-  if (pendingReadUrl) state = 'pending_permission';
-  else if (readUrlOneof && hasWebDocument) state = 'completed_web_document';
+  if (readUrlOneof && hasWebDocument) state = 'completed_web_document';
+  else if (pendingReadUrl) state = 'pending_permission';
   else if (readUrlOneof && autoRunDecision != null && !hasWebDocument && !hasLegacySummary) state = 'auto_run_decision_only';
   else if (readUrlOneof && hasLegacySummary && !hasWebDocument) state = 'legacy_summary_only';
   else if (readUrlOneof) state = 'native_oneof_no_document';
diff --git a/src/windsurf.js b/src/windsurf.js
@@ -1264,11 +1264,12 @@ export function parseTrajectorySteps(buf) {
           };
           argumentsJson = JSON.stringify(args);
           const webDocument = getField(body, 2, 2);
-          result = webDocument ? decodeKnowledgeBaseItemText(webDocument.value) : '';
+          const hasWebDocument = !!webDocument;
+          result = hasWebDocument ? decodeKnowledgeBaseItemText(webDocument.value) : '';
           if (!result && readUrlLegacySummaryFallbackEnabled()) {
             result = getField(body, 5, 2)?.value?.toString('utf8') || '';
           }
-          if (!result && readUrlRequestedInteraction) continue;
+          if (!hasWebDocument && !result && readUrlRequestedInteraction) continue;
         } else if (kind === 'search_web') {
           const args = {
             query: getField(body, 1, 2)?.value?.toString('utf8') || '',
@@ -1289,6 +1290,7 @@ export function parseTrajectorySteps(buf) {
         name: kind,
         argumentsJson,
         result,
+        ...(kind === 'read_url_content' && getField(body, 2, 2) ? { hasWebDocument: true } : {}),
         cascade_native: true,
       });
     }
diff --git a/test/client-panel-retry.test.js b/test/client-panel-retry.test.js
@@ -148,6 +148,32 @@ function readUrlContentDoneStepResponse() {
   return writeMessageField(1, step);
 }
 
+function readUrlContentDoneWithEchoStepResponse() {
+  const spec = Buffer.concat([
+    writeStringField(1, 'https://example.com/'),
+    writeStringField(2, 'https://example.com'),
+  ]);
+  const doc = Buffer.concat([
+    writeStringField(2, 'Example Domain fetched body'),
+    writeStringField(3, 'https://example.com/'),
+    writeStringField(7, 'Example Domain summary'),
+  ]);
+  const body = Buffer.concat([
+    writeStringField(1, 'https://example.com/'),
+    writeMessageField(2, doc),
+    writeStringField(3, 'https://example.com/'),
+    writeVarintField(4, 123),
+    writeVarintField(7, 8),
+  ]);
+  const step = Buffer.concat([
+    writeVarintField(1, 31),
+    writeVarintField(4, 3),
+    writeMessageField(56, writeMessageField(14, spec)),
+    writeMessageField(40, body),
+  ]);
+  return writeMessageField(1, step);
+}
+
 function setEnvForTest(values) {
   const previous = new Map(Object.keys(values).map(key => [key, process.env[key]]));
   for (const [key, value] of Object.entries(values)) {
@@ -713,4 +739,83 @@ describe('WindsurfClient cascade panel retry', () => {
       restoreEnv();
     }
   });
+
+  it('does not treat completed WebFetch with requested interaction echo as a proposal', async () => {
+    const restoreEnv = setEnvForTest({
+      WINDSURFAPI_NATIVE_TOOL_BRIDGE_WEBFETCH_AUTO_APPROVE: '1',
+      WINDSURFAPI_NATIVE_TOOL_BRIDGE_WEBFETCH_AUTO_APPROVE_ORIGINS: 'https://example.com',
+      WINDSURFAPI_NATIVE_TOOL_BRIDGE_POLL_AFTER_TOOL: '1',
+      CASCADE_POLL_INTERVAL_MS: '10',
+      CASCADE_IDLE_GRACE_MS: '1',
+      CASCADE_MAX_WAIT_MS: '500',
+      CASCADE_COLD_STALL_BASE_MS: '500',
+      GRPC_PROTOCOL: 'connect',
+    });
+
+    let approvals = 0;
+    const streamed = [];
+    try {
+      await withFakeLanguageServer((stream, headers) => {
+        const chunks = [];
+        stream.on('data', chunk => chunks.push(chunk));
+        stream.on('end', () => {
+          const method = String(headers[':path'] || '').split('/').pop();
+          if (method === 'StartCascade') {
+            stream.respond({ ':status': 200, 'content-type': headers['content-type'] || 'application/grpc' });
+            stream.end(responseBody(startCascadeResponse('webfetch-completed-cascade'), headers));
+            return;
+          }
+          if (method === 'SendUserCascadeMessage') {
+            stream.respond({ ':status': 200, 'content-type': headers['content-type'] || 'application/grpc' });
+            stream.end(responseBody(Buffer.alloc(0), headers));
+            return;
+          }
+          if (method === 'GetCascadeTrajectorySteps') {
+            stream.respond({ ':status': 200, 'content-type': headers['content-type'] || 'application/grpc' });
+            stream.end(responseBody(Buffer.concat([
+              readUrlContentDoneWithEchoStepResponse(),
+              trajectoryStepsResponse('Natural answer using Example Domain.'),
+            ]), headers));
+            return;
+          }
+          if (method === 'HandleCascadeUserInteraction') {
+            approvals++;
+            stream.respond({ ':status': 200, 'content-type': headers['content-type'] || 'application/grpc' });
+            stream.end(responseBody(Buffer.alloc(0), headers));
+            return;
+          }
+          if (method === 'GetCascadeTrajectory') {
+            stream.respond({ ':status': 200, 'content-type': headers['content-type'] || 'application/grpc' });
+            stream.end(responseBody(trajectoryInfoResponse(1, 'trajectory-webfetch', 'webfetch-completed-cascade'), headers));
+            return;
+          }
+          if (method === 'GetCascadeTrajectoryGeneratorMetadata') {
+            stream.respond({ ':status': 200, 'content-type': headers['content-type'] || 'application/grpc' });
+            stream.end(responseBody(Buffer.alloc(0), headers));
+            return;
+          }
+          stream.respond({ ':status': 404 });
+          stream.end();
+        });
+      }, async (port) => {
+        const { WindsurfClient } = await import('../src/client.js');
+        const client = new WindsurfClient('test-api-key', port, 'csrf-token');
+        const chunks = await client.cascadeChat([{ role: 'user', content: 'fetch it' }], 0, 'claude-4.5-haiku', {
+          nativeMode: true,
+          nativeAllowlist: ['read_url_content'],
+          onChunk: c => streamed.push(c),
+        });
+        assert.equal(approvals, 0);
+        assert.equal(chunks.toolCalls.length, 1);
+        assert.equal(chunks.toolCalls[0].name, 'read_url_content');
+        assert.equal(chunks.toolCalls[0].result, 'Example Domain fetched body');
+        assert.equal(chunks.toolCalls[0].hasWebDocument, true);
+        assert.equal(streamed.filter(c => c.nativeToolCall).length, 0);
+        assert.equal(streamed.filter(c => c.nativeToolResult).length, 1);
+        assert.match(chunks.map(c => c.text || '').join(''), /Natural answer using Example Domain/);
+      });
+    } finally {
+      restoreEnv();
+    }
+  });
 });
diff --git a/test/native-tool-routing.test.js b/test/native-tool-routing.test.js
diff --git a/test/proto-trace.test.js b/test/proto-trace.test.js

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "windsurf-api",`
`3`		`- "version": "2.0.143",`
	`3`	`+ "version": "2.0.144",`
`4`	`4`	`"description": "Windsurf to OpenAI + Anthropic compatible API proxy. Turns Windsurf's 107 AI models (Claude, GPT, Gemini, DeepSeek, Grok, Qwen, Kimi, GLM, SWE) into dual-protocol API endpoints. Zero npm deps.",`
`5`	`5`	`"type": "module",`
`6`	`6`	`"main": "src/index.js",`