fix(runtime): keep signature-only thinking out of the empty-step cap

A standalone Anthropic/Responses thinking signature is omitted or redacted reasoning, not user-visible progress. Persist it for replay, but do not let it prevent emptyStepSignature from bounding identical textless tool steps (#4083).

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

Author: Rangsh

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

@@ -6151,6 +6151,74 @@ describe('AiSdkBackend model history', () => {
     assert.equal(events.filter((event) => event.type === 'tool_start').length, 3);
   });
 
+  test('stops an unbounded loop when only a thinking signature accompanies identical tool calls', async () => {
+    // Anthropic can emit omitted/redacted reasoning as a standalone signature
+    // with no text. The signature must persist for replay, but must not count
+    // as visible thinking or the empty-step cap never fires (#4083).
+    let calls = 0;
+    const model = new MockLanguageModelV4({
+      doStream: async () => {
+        calls += 1;
+        return {
+          stream: simulateReadableStream({
+            chunks: [
+              { type: 'stream-start', warnings: [] },
+              { type: 'reasoning-start', id: 'r1' },
+              {
+                type: 'reasoning-delta',
+                id: 'r1',
+                delta: '',
+                providerMetadata: { anthropic: { signature: `sig-${calls}` } },
+              },
+              { type: 'reasoning-end', id: 'r1' },
+              {
+                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-signature-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);
+    assert.ok(
+      events.some(
+        (event) =>
+          event.type === 'thinking_complete' &&
+          event.signature !== undefined &&
+          event.text === '',
+      ),
+      'signature-only reasoning must still persist',
+    );
+  });
+
   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

@@ -2447,7 +2447,9 @@ export class AiSdkBackend implements AgentBackend {
                   text: event.text,
                 } satisfies ThinkingDeltaEvent);
               } else if (event.kind === 'thinking-signature') {
-                stepSawThinking = true;
+                // A standalone signature is omitted/redacted reasoning, not
+                // user-visible progress. Persist it for replay, but do not
+                // reset the empty-step loop cap (#4083).
                 attemptSawContinuationMetadata = true;
                 stepSignature = event.signature;
               } else if (event.kind === 'provider-tool-input') {