fix(runtime): count only visible thinking toward the empty-step cap

OpenAI Responses emits an empty thinking carrier at reasoning-end whenever provider metadata is present. That is not user-visible progress, so it must not reset the identical textless tool-step counter (#4083).

Generated-by: Cursor
Co-authored-by: Cursor <cursoragent@cursor.com>

Author: Rangsh

packages/runtime/src/__tests__/ai-sdk-backend.test.ts

@@ -6092,6 +6092,65 @@ describe('AiSdkBackend model history', () => {
     );
   });
 
+  test('stops an unbounded loop when Responses reasoning-end is only an empty carrier', async () => {
+    // OpenAI Responses emits `{ kind: 'thinking', text: '' }` at reasoning-end
+    // whenever provider metadata is present. That carrier must not count as
+    // visible thinking, or identical textless tool steps never reach the cap.
+    const reasoningMetadata = {
+      openai: {
+        itemId: 'rs_empty',
+        reasoningEncryptedContent: 'encrypted-carrier',
+      },
+    };
+    let calls = 0;
+    const model = new MockLanguageModelV4({
+      doStream: async () => {
+        calls += 1;
+        return {
+          stream: simulateReadableStream({
+            chunks: [
+              { type: 'stream-start', warnings: [] },
+              { type: 'reasoning-start', id: 'r1', providerMetadata: reasoningMetadata },
+              { type: 'reasoning-end', id: 'r1', providerMetadata: reasoningMetadata },
+              {
+                type: 'tool-call',
+                toolCallId: `tool-${calls}`,
+                toolName: 'Read',
+                input: JSON.stringify({ path: 'notes.md' }),
+              },
+              {
+                type: 'finish',
+                finishReason: { unified: 'tool-calls', raw: 'tool_calls' },
+                usage: emptyUsage(),
+              },
+            ],
+            initialDelayInMs: null,
+            chunkDelayInMs: null,
+          }),
+        };
+      },
+    });
+    const durable = durableTurnHarness('turn-empty-responses-loop', 'keep going');
+    const backend = createTestAiSdkBackend({
+      sessionId: 'session-1',
+      header: header(),
+      appendMessage: async () => {},
+      connection: connection(),
+      apiKey: 'sk-test',
+      modelId: 'mock-model-id',
+      modelFactory: () => model,
+      tools: [testTool('Read', z.object({ path: z.string() }))],
+      loadTurnRuntimeEvents: durable.loadTurnRuntimeEvents,
+      newId: idGenerator(),
+      now: monotonicClock(),
+    });
+
+    const events = await drainDurably(backend.send(durable.input()), durable);
+    assert.equal(calls, 3);
+    assert.equal(events.find((event) => event.type === 'complete')?.stopReason, 'step_limit');
+    assert.equal(events.filter((event) => event.type === 'tool_start').length, 3);
+  });
+
   test('aborting during post-stream persistence wins over step-limit completion', async () => {
     const loop = countingToolLoopModel();
     const gate = makeGate();

packages/runtime/src/ai-sdk-backend.ts

@@ -2396,7 +2396,12 @@ export class AiSdkBackend implements AgentBackend {
                   stepTextPartStartOffset,
                 );
               } else if (event.kind === 'thinking') {
-                stepSawThinking = true;
+                // OpenAI Responses emits an empty thinking carrier at
+                // `reasoning-end` whenever provider metadata is present. That
+                // is not user-visible progress, so it must not reset the
+                // empty-step loop cap (#4083). Persistence still uses
+                // `sawStepThinking` so the encrypted carrier round-trips.
+                if (event.text.length > 0) stepSawThinking = true;
                 sawStepThinking = true;
                 stepThinking += event.text;
                 if (event.text.length > 0) attemptSawThinking = true;