newmark-agent 0.5.7 → 0.5.8

package/dist/conversation-utility-host.bundle.cjs

@@ -328709,6 +328709,30 @@ function parseProviderSse(raw) {
   }
   return events;
 }
+function assembleCompatibleToolArguments(parts) {
+  const nonEmpty = (parts || []).map(String).filter((part) => part && part !== "null");
+  if (!nonEmpty.length) return "{}";
+  const isJsonObject = (value) => {
+    try {
+      const parsed = JSON.parse(value);
+      return !!parsed && typeof parsed === "object" && !Array.isArray(parsed);
+    } catch {
+      return false;
+    }
+  };
+  const incremental = nonEmpty.join("");
+  if (isJsonObject(incremental)) return incremental;
+  let compatible = "";
+  for (const incoming of nonEmpty) {
+    if (!compatible) compatible = incoming;
+    else if (incoming === compatible) continue;
+    else if (incoming.startsWith(compatible)) compatible = incoming;
+    else if (compatible.startsWith(incoming)) continue;
+    else compatible += incoming;
+  }
+  if (isJsonObject(compatible)) return compatible;
+  return [...nonEmpty].reverse().find(isJsonObject) || compatible;
+}
 function isContentPolicyBlocked(json) {
   const choices = Array.isArray(json.choices) ? json.choices : [];
   const choice = choices[0] || {};
@@ -328937,6 +328961,8 @@ var ChatCompletionsAdapter = class {
     let contentPolicyBlocked = false;
     let emittedContent = false;
     let emittedTool = false;
+    let emittedReasoning = false;
+    let explicitCompletion = false;
     try {
       while (true) {
         const { done, value } = await readProviderStreamChunk(reader, signal);
@@ -328948,7 +328974,10 @@ var ChatCompletionsAdapter = class {
           const trimmed = line.trim();
           if (!trimmed.startsWith("data: ")) continue;
           const data = trimmed.slice(6);
-          if (data === "[DONE]") continue;
+          if (data === "[DONE]") {
+            explicitCompletion = true;
+            continue;
+          }
           let json;
           try {
             json = JSON.parse(data);
@@ -328961,11 +328990,16 @@ var ChatCompletionsAdapter = class {
           }
           if (isContentPolicyBlocked(json)) contentPolicyBlocked = true;
           const choices = Array.isArray(json.choices) ? json.choices : [];
-          const delta = choices[0]?.delta;
+          const choice = choices[0];
+          if (choice?.finish_reason !== void 0 && choice.finish_reason !== null) explicitCompletion = true;
+          const delta = choice?.delta;
           if (!delta) continue;
           if (delta.reasoning_content) {
             const reasoning = this.extractText(delta.reasoning_content);
-            if (reasoning) yield { type: "reasoning.summary.delta", delta: reasoning };
+            if (reasoning) {
+              emittedReasoning = true;
+              yield { type: "reasoning.summary.delta", delta: reasoning };
+            }
           }
           const textDelta = this.extractText(delta.content);
           if (textDelta) {
@@ -329010,13 +329044,17 @@ var ChatCompletionsAdapter = class {
             type: "tool_call.completed",
             id: currentToolCall.id,
             name: currentToolCall.name,
-            arguments: currentToolCall.argumentParts.join("")
+            arguments: assembleCompatibleToolArguments(currentToolCall.argumentParts)
           };
         }
       } else if (!emittedContent && !emittedTool && contentPolicyBlocked) {
         yield { type: "response.failed", error: "[Error] Content policy refusal (content_filter)." };
         return;
       }
+      if (!explicitCompletion && !emittedContent && !emittedTool && !emittedReasoning) {
+        yield { type: "response.failed", error: "[LLM Error] Chat stream ended before an explicit completion." };
+        return;
+      }
       yield { type: "response.completed" };
     } finally {
       reader.releaseLock();
@@ -329213,6 +329251,7 @@ var ResponsesAdapter = class {
               const key3 = `${String(payload.item_id || "")}:${String(payload.summary_index || 0)}`;
               const delta = this.extractText(payload.delta);
               if (delta) {
+                emittedContent = true;
                 reasoningSummaries.set(key3, (reasoningSummaries.get(key3) || "") + delta);
                 yield { type: "reasoning.summary.delta", delta };
               }
@@ -329243,7 +329282,7 @@ var ResponsesAdapter = class {
                 calls.set(key3, {
                   id: String(item.call_id || item.id || key3),
                   name: String(item.name || ""),
-                  arguments: String(item.arguments || ""),
+                  argumentParts: item.arguments ? [String(item.arguments)] : [],
                   emitted: false
                 });
               }
@@ -329251,9 +329290,9 @@ var ResponsesAdapter = class {
             }
             if (eventType === "response.function_call_arguments.delta") {
               const key3 = String(payload.item_id || payload.call_id || payload.output_index || "");
-              const call = calls.get(key3) || { id: String(payload.call_id || key3), name: String(payload.name || ""), arguments: "", emitted: false };
+              const call = calls.get(key3) || { id: String(payload.call_id || key3), name: String(payload.name || ""), argumentParts: [], emitted: false };
               const delta = String(payload.delta || "");
-              call.arguments += delta;
+              if (delta) call.argumentParts.push(delta);
               calls.set(key3, call);
               yield { type: "tool_call.arguments.delta", id: call.id, delta };
               continue;
@@ -329265,19 +329304,20 @@ var ResponsesAdapter = class {
                 const call = calls.get(key3) || {
                   id: String(item.call_id || item.id || key3),
                   name: String(item.name || ""),
-                  arguments: String(item.arguments || ""),
+                  argumentParts: item.arguments ? [String(item.arguments)] : [],
                   emitted: false
                 };
                 call.id = String(item.call_id || call.id);
                 call.name = String(item.name || call.name);
-                call.arguments = typeof item.arguments === "string" ? item.arguments : call.arguments;
+                if (typeof item.arguments === "string" && item.arguments) call.argumentParts.push(item.arguments);
                 if (!call.emitted) {
                   call.emitted = true;
+                  const argumentsJson = assembleCompatibleToolArguments(call.argumentParts);
                   yield { type: "tool_call.started", id: call.id, name: call.name };
-                  if (call.arguments && call.arguments !== "{}") {
-                    yield { type: "tool_call.arguments.delta", id: call.id, delta: call.arguments };
+                  if (argumentsJson !== "{}") {
+                    yield { type: "tool_call.arguments.delta", id: call.id, delta: argumentsJson };
                   }
-                  yield { type: "tool_call.completed", id: call.id, name: call.name, arguments: call.arguments };
+                  yield { type: "tool_call.completed", id: call.id, name: call.name, arguments: argumentsJson };
                 }
                 calls.set(key3, call);
               }
@@ -329302,8 +329342,14 @@ var ResponsesAdapter = class {
       } else if (!completed) {
         yield { type: "response.failed", error: "[LLM Error] Responses stream ended before response.completed." };
       } else if (!emittedContent && calls.size === 0) {
-        yield { type: "response.failed", error: "[Error] Empty Responses stream." };
+        yield { type: "response.failed", error: "[Error] Provider returned an empty response." };
       } else {
+        for (const call of calls.values()) {
+          if (call.emitted) continue;
+          const argumentsJson = assembleCompatibleToolArguments(call.argumentParts);
+          yield { type: "tool_call.started", id: call.id, name: call.name };
+          yield { type: "tool_call.completed", id: call.id, name: call.name, arguments: argumentsJson };
+        }
         yield { type: "response.completed" };
       }
     } finally {
@@ -330182,7 +330228,7 @@ ${responsePath}
    * `provider_adapters_v2` context flag. Request serialization and SSE
    * normalization are delegated to the shared provider adapters while the
    * transport orchestration (loopback node-http, fetch -> node-http fallback,
-   * 120s/30s timeouts) and the 4xx Chat -> Responses downgrade stay here.
+   * cancellation-only streaming and the 4xx Chat -> Responses downgrade) stay here.
    * The emitted request body and StreamToken stream are byte-equivalent to
    * the legacy inlined path.
    */
@@ -330319,9 +330365,9 @@ ${responsePath}
   }
   /**
    * Loopback-aware transport injected into adapter `execute`. Streaming
-   * requests retain the fetch-to-node fallback for transport failures, while
-   * a local deadline is returned directly so one request cannot become a
-   * second Windows fallback request.
+   * requests retain the fetch-to-node fallback for transport failures. They
+   * have no response deadline; only caller cancellation or a concrete
+   * transport/provider failure may end the request.
    */
   buildProviderAdapterTransport() {
     return async (request, signal) => {
@@ -330331,7 +330377,7 @@ ${responsePath}
         const forwardAbort = () => abort.abort(signal?.reason);
         if (signal?.aborted) forwardAbort();
         else signal?.addEventListener("abort", forwardAbort, { once: true });
-        const effectiveTimeout = this.effectiveRequestTimeout(12e4);
+        const effectiveTimeout = 0;
         const timer = effectiveTimeout > 0 ? setTimeout(() => abort.abort(providerTimeoutError(effectiveTimeout)), effectiveTimeout) : void 0;
         try {
           try {
@@ -330476,7 +330522,7 @@ ${responsePath}
     const forwardAbort = () => abort.abort(signal?.reason);
     if (signal?.aborted) forwardAbort();
     else signal?.addEventListener("abort", forwardAbort, { once: true });
-    const effectiveTimeout = this.effectiveRequestTimeout(12e4);
+    const effectiveTimeout = 0;
     const timeout = effectiveTimeout > 0 ? setTimeout(() => abort.abort(providerTimeoutError(effectiveTimeout)), effectiveTimeout) : void 0;
     let reader = null;
     try {
@@ -330508,10 +330554,14 @@ ${responsePath}
       }
       const decoder = new TextDecoder();
       let buffer = "";
-      let currentToolCall = null;
+      const toolCalls = /* @__PURE__ */ new Map();
+      const toolCallOrder = [];
+      let syntheticToolIndex = 0;
+      let lastToolIndex = 0;
       let currentReasoningContent = "";
       let contentPolicyBlocked = false;
       let emittedContent = false;
+      let explicitCompletion = false;
       const streamSignal = signal || new AbortController().signal;
       while (true) {
         const { done, value } = await readProviderStreamChunk(reader, streamSignal);
@@ -330523,7 +330573,10 @@ ${responsePath}
           const trimmed = line.trim();
           if (!trimmed.startsWith("data: ")) continue;
           const data = trimmed.slice(6);
-          if (data === "[DONE]") continue;
+          if (data === "[DONE]") {
+            explicitCompletion = true;
+            continue;
+          }
           try {
             const json = JSON.parse(data);
             if (json.usage) yield { type: "usage", text: "", usage: extractProviderUsage(json) };
@@ -330541,24 +330594,44 @@ ${responsePath}
             }
             if (delta.tool_calls) {
               for (const tc of delta.tool_calls) {
-                if (tc.id) {
-                  if (currentToolCall) {
-                    yield { type: "tool_call", text: "", toolCall: currentToolCall, reasoningContent: currentReasoningContent || void 0 };
-                  }
-                  currentToolCall = { id: tc.id, name: tc.function?.name || "", arguments: tc.function?.arguments || "" };
-                } else if (tc.function?.arguments && currentToolCall) {
-                  currentToolCall.arguments += tc.function.arguments;
+                const rawIndex = Number(tc.index);
+                const index = Number.isInteger(rawIndex) && rawIndex >= 0 ? rawIndex : tc.id ? syntheticToolIndex++ : lastToolIndex;
+                lastToolIndex = index;
+                let call = toolCalls.get(index);
+                if (!call && (tc.id || tc.function?.name)) {
+                  call = { id: tc.id || "", name: tc.function?.name || "", argumentParts: [] };
+                  toolCalls.set(index, call);
+                  toolCallOrder.push(index);
                 }
+                if (!call) continue;
+                if (tc.id && !call.id) call.id = tc.id;
+                if (tc.function?.name && !call.name) call.name = tc.function.name;
+                if (tc.function?.arguments) call.argumentParts.push(tc.function.arguments);
               }
             }
           } catch {
           }
         }
       }
-      if (currentToolCall && currentToolCall.arguments) {
-        yield { type: "tool_call", text: "", toolCall: currentToolCall, reasoningContent: currentReasoningContent || void 0 };
+      if (toolCallOrder.length) {
+        for (const index of toolCallOrder) {
+          const call = toolCalls.get(index);
+          if (!call) continue;
+          yield {
+            type: "tool_call",
+            text: "",
+            toolCall: {
+              id: call.id,
+              name: call.name,
+              arguments: assembleCompatibleToolArguments(call.argumentParts)
+            },
+            reasoningContent: currentReasoningContent || void 0
+          };
+        }
       } else if (!emittedContent && contentPolicyBlocked) {
         yield { type: "text", text: "[Error] Content policy refusal (content_filter)." };
+      } else if (!explicitCompletion && !emittedContent && !currentReasoningContent) {
+        yield { type: "text", text: "[LLM Error] GitHub Models stream ended before an explicit completion." };
       }
     } finally {
       reader?.releaseLock();
@@ -340511,6 +340584,22 @@ function createToolchainCore() {
   return { registry: new ToolRegistry(), catalog: new CapabilityCatalog() };
 }
 
+// src/core/emptyResponseRetry.ts
+var EMPTY_RESPONSE_RETRY_DELAYS_MS = [200, 800, 2e3, 1e4, 6e4];
+var MAX_EMPTY_RESPONSE_RETRIES = EMPTY_RESPONSE_RETRY_DELAYS_MS.length;
+var MAX_CONSECUTIVE_EMPTY_RESPONSES = MAX_EMPTY_RESPONSE_RETRIES + 1;
+function emptyResponseRetryDelayMs(consecutiveEmptyResponses) {
+  return EMPTY_RESPONSE_RETRY_DELAYS_MS[Math.max(0, consecutiveEmptyResponses - 1)] ?? 0;
+}
+function observeEmptyResponseOutcome(consecutiveEmptyResponses, emptyResponse) {
+  const nextCount = emptyResponse ? consecutiveEmptyResponses + 1 : 0;
+  return {
+    consecutiveEmptyResponses: nextCount,
+    retry: emptyResponse && nextCount <= MAX_EMPTY_RESPONSE_RETRIES,
+    terminate: emptyResponse && nextCount > MAX_EMPTY_RESPONSE_RETRIES
+  };
+}
+
 // src/core/agentKernelRunner.ts
 var publicStreamFilters = /* @__PURE__ */ new WeakMap();
 var brokerOnlyAssistantBuffers = /* @__PURE__ */ new WeakMap();
@@ -340662,7 +340751,7 @@ function kernelTurnFailed(agent, turn) {
   return turn.stopReason === "error" || agent.isLlmErrorText(turn.text);
 }
 function providerTurnIsEmpty(turn) {
-  return /provider returned an empty response/i.test(`${turn.errorMessage}
+  return !turn.activity && /provider returned an empty response/i.test(`${turn.errorMessage}
 ${turn.text}`);
 }
 function removeTrailingFailedAssistant(agent, messages) {
@@ -340671,6 +340760,12 @@ function removeTrailingFailedAssistant(agent, messages) {
   const text = KernelMessageText(last);
   if (last.stopReason === "error" || agent.isLlmErrorText(text)) messages.pop();
 }
+function removeTrailingThoughtOnlyAssistant(messages) {
+  const last = messages[messages.length - 1];
+  if (last?.role !== "assistant") return;
+  const hasToolCall = last.content.some((content) => content.type === "toolCall");
+  if (!KernelMessageText(last).trim() && !hasToolCall) messages.pop();
+}
 function normalizePublicProviderError(error, secrets = []) {
   let raw = "";
   if (error instanceof Error) {
@@ -340796,8 +340891,17 @@ async function runAgentKernel(agent) {
   const tokens = [];
   const runOnce = async (promptMessages, appendPromptToAgentHistory) => {
     let lastAssistant = null;
+    let observedActivity = false;
+    let observedThought = false;
     const unsubscribe = kernel2.subscribe(async (event) => {
       await handleKernelEvent(agent, event, tokens);
+      if (event.type === "message_update") {
+        const delta = event.assistantMessageEvent;
+        const deltaText = typeof delta.delta === "string" ? delta.delta : "";
+        const thoughtDelta = delta.type === "thinking_delta" && !!deltaText.trim();
+        observedThought = observedThought || thoughtDelta;
+        observedActivity = observedActivity || thoughtDelta || delta.type === "text_delta" && !!deltaText.trim() || delta.type === "toolcall_end";
+      }
       if (event.type === "message_end" && event.message.role === "assistant") {
         lastAssistant = event.message;
       }
@@ -340815,11 +340919,13 @@ async function runAgentKernel(agent) {
       const assistant = lastAssistant;
       const text = assistant ? KernelMessageText(assistant) : "";
       const hasToolCall = !!assistant?.content?.some((content) => content.type === "toolCall");
-      const emptyResponse = !assistant || !text.trim() && !hasToolCall && String(assistant?.stopReason || "") !== "aborted";
+      const emptyResponse = !assistant || !text.trim() && !hasToolCall && !observedActivity && String(assistant?.stopReason || "") !== "aborted";
       return {
         text: emptyResponse ? "[Error] Provider returned an empty response." : text,
         stopReason: String(assistant?.stopReason || ""),
-        errorMessage: String(assistant?.errorMessage || (emptyResponse ? "Provider returned an empty response." : ""))
+        errorMessage: String(assistant?.errorMessage || (emptyResponse ? "Provider returned an empty response." : "")),
+        activity: observedActivity || !!text.trim() || hasToolCall,
+        thoughtOnly: observedThought && !text.trim() && !hasToolCall && !["error", "aborted"].includes(String(assistant?.stopReason || ""))
       };
     } finally {
       unsubscribe();
@@ -340865,14 +340971,22 @@ async function runAgentKernel(agent) {
         fallback: { from: modelBeforeKernelRun, to: agent.model, providerId: agent.activeDeployment()?.providerId }
       });
     }
-    let emptyResponseRetries = 0;
-    while (providerTurnIsEmpty(lastTurn) && emptyResponseRetries < 2) {
+    let consecutiveEmptyResponses = 0;
+    for (; ; ) {
+      const emptyResponseState = observeEmptyResponseOutcome(consecutiveEmptyResponses, providerTurnIsEmpty(lastTurn));
+      consecutiveEmptyResponses = emptyResponseState.consecutiveEmptyResponses;
+      if (lastTurn.thoughtOnly) {
+        removeTrailingThoughtOnlyAssistant(kernel2.state.messages);
+        lastTurn = await runWithCompressionResume([], false);
+        continue;
+      }
+      if (!emptyResponseState.retry) break;
       removeTrailingFailedAssistant(agent, kernel2.state.messages);
-      emptyResponseRetries += 1;
-      const notice = `[Model retry] Provider returned an empty response; retrying the same deployment (${emptyResponseRetries}/2).`;
+      const retryNumber = consecutiveEmptyResponses;
+      const notice = `[Model retry] Provider returned an empty response; retrying the same deployment (${retryNumber}/${MAX_EMPTY_RESPONSE_RETRIES}) after ${emptyResponseRetryDelayMs(consecutiveEmptyResponses)}ms.`;
       tokens.push({ type: "text", text: notice });
       agent.recordWorkStatus(notice);
-      await agent.waitForPlannedRouteRetry();
+      await agent.waitForPlannedRouteRetry(emptyResponseRetryDelayMs(consecutiveEmptyResponses));
       lastTurn = await runWithCompressionResume([], false);
     }
     let routeRetries = 0;
@@ -341068,7 +341182,7 @@ async function runAgentKernel(agent) {
             return;
           }
           if (textStarted) finalContent.push({ type: "text", text });
-          if (!finalContent.length) {
+          if (!finalContent.length && !thinking.trim()) {
             text = "[Error] Provider returned an empty response.";
             finalContent.push({ type: "text", text });
           }
@@ -345652,7 +345766,12 @@ var Agent4 = class _Agent {
   beginRouteAttempt() {
     this.routeAttemptStartedAt = Date.now();
   }
-  async waitForPlannedRouteRetry() {
+  async waitForPlannedRouteRetry(explicitDelayMs) {
+    if (explicitDelayMs !== void 0) {
+      if (explicitDelayMs <= 0) return;
+      await new Promise((resolve16) => setTimeout(resolve16, explicitDelayMs));
+      return;
+    }
     const waitBudgetMs = Math.max(0, Math.min(15e3, this.lastRouteDecision?.retryBudgetMs ?? 5e3));
     const delay = Math.max(0, Math.min(waitBudgetMs, this.lastRouteRetryDelayMs));
     this.lastRouteRetryDelayMs = 0;

package/dist/core/agent.d.ts

@@ -464,7 +464,7 @@ export declare class Agent {
     markRouteToolExecuted(name: string, rawArgs?: string): void;
     routeTransitionKind(): PlannedRouteAttempt['kind'] | '';
     beginRouteAttempt(): void;
-    waitForPlannedRouteRetry(): Promise<void>;
+    waitForPlannedRouteRetry(explicitDelayMs?: number): Promise<void>;
     recordRouteSuccess(latencyMs?: number, throughput?: number): void;
     recordRouteToolOutcome(valid: boolean): void;
     updateProviders(value: unknown): void;

package/dist/core/agent.js

@@ -1016,7 +1016,13 @@ class Agent {
     beginRouteAttempt() {
         this.routeAttemptStartedAt = Date.now();
     }
-    async waitForPlannedRouteRetry() {
+    async waitForPlannedRouteRetry(explicitDelayMs) {
+        if (explicitDelayMs !== undefined) {
+            if (explicitDelayMs <= 0)
+                return;
+            await new Promise(resolve => setTimeout(resolve, explicitDelayMs));
+            return;
+        }
         const waitBudgetMs = Math.max(0, Math.min(15_000, this.lastRouteDecision?.retryBudgetMs ?? 5_000));
         const delay = Math.max(0, Math.min(waitBudgetMs, this.lastRouteRetryDelayMs));
         this.lastRouteRetryDelayMs = 0;

package/dist/core/agentKernelRunner.js

@@ -46,6 +46,7 @@ const toolPolicy_1 = require("./toolPolicy");
 const performanceDiagnostics_1 = require("./performanceDiagnostics");
 const agentKernelDiagnostics_1 = require("./agentKernelDiagnostics");
 const toolchain_1 = require("../toolchain");
+const emptyResponseRetry_1 = require("./emptyResponseRetry");
 const publicStreamFilters = new WeakMap();
 const brokerOnlyAssistantBuffers = new WeakMap();
 const BROKER_PREFACE_BUFFER_CHARS = 96;
@@ -206,7 +207,7 @@ function kernelTurnFailed(agent, turn) {
     return turn.stopReason === 'error' || agent.isLlmErrorText(turn.text);
 }
 function providerTurnIsEmpty(turn) {
-    return /provider returned an empty response/i.test(`${turn.errorMessage}\n${turn.text}`);
+    return !turn.activity && /provider returned an empty response/i.test(`${turn.errorMessage}\n${turn.text}`);
 }
 function removeTrailingFailedAssistant(agent, messages) {
     const last = messages[messages.length - 1];
@@ -216,6 +217,14 @@ function removeTrailingFailedAssistant(agent, messages) {
     if (last.stopReason === 'error' || agent.isLlmErrorText(text))
         messages.pop();
 }
+function removeTrailingThoughtOnlyAssistant(messages) {
+    const last = messages[messages.length - 1];
+    if (last?.role !== 'assistant')
+        return;
+    const hasToolCall = last.content.some(content => content.type === 'toolCall');
+    if (!KernelMessageText(last).trim() && !hasToolCall)
+        messages.pop();
+}
 function normalizePublicProviderError(error, secrets = []) {
     let raw = '';
     if (error instanceof Error) {
@@ -369,8 +378,22 @@ async function runAgentKernel(agent) {
     const tokens = [];
     const runOnce = async (promptMessages, appendPromptToAgentHistory) => {
         let lastAssistant = null;
+        let observedActivity = false;
+        let observedThought = false;
         const unsubscribe = kernel.subscribe(async (event) => {
             await handleKernelEvent(agent, event, tokens);
+            if (event.type === 'message_update') {
+                const delta = event.assistantMessageEvent;
+                const deltaText = typeof delta.delta === 'string'
+                    ? delta.delta
+                    : '';
+                const thoughtDelta = delta.type === 'thinking_delta' && !!deltaText.trim();
+                observedThought = observedThought || thoughtDelta;
+                observedActivity = observedActivity ||
+                    thoughtDelta ||
+                    (delta.type === 'text_delta' && !!deltaText.trim()) ||
+                    (delta.type === 'toolcall_end');
+            }
             if (event.type === 'message_end' && event.message.role === 'assistant') {
                 lastAssistant = event.message;
             }
@@ -390,11 +413,14 @@ async function runAgentKernel(agent) {
             const text = assistant ? KernelMessageText(assistant) : '';
             const hasToolCall = !!assistant?.content?.some(content => content.type === 'toolCall');
             const emptyResponse = !assistant
-                || (!text.trim() && !hasToolCall && String(assistant?.stopReason || '') !== 'aborted');
+                || (!text.trim() && !hasToolCall && !observedActivity && String(assistant?.stopReason || '') !== 'aborted');
             return {
                 text: emptyResponse ? '[Error] Provider returned an empty response.' : text,
                 stopReason: String(assistant?.stopReason || ''),
                 errorMessage: String(assistant?.errorMessage || (emptyResponse ? 'Provider returned an empty response.' : '')),
+                activity: observedActivity || !!text.trim() || hasToolCall,
+                thoughtOnly: observedThought && !text.trim() && !hasToolCall
+                    && !['error', 'aborted'].includes(String(assistant?.stopReason || '')),
             };
         }
         finally {
@@ -448,14 +474,23 @@ async function runAgentKernel(agent) {
                 fallback: { from: modelBeforeKernelRun, to: agent.model, providerId: agent.activeDeployment()?.providerId },
             });
         }
-        let emptyResponseRetries = 0;
-        while (providerTurnIsEmpty(lastTurn) && emptyResponseRetries < 2) {
+        let consecutiveEmptyResponses = 0;
+        for (;;) {
+            const emptyResponseState = (0, emptyResponseRetry_1.observeEmptyResponseOutcome)(consecutiveEmptyResponses, providerTurnIsEmpty(lastTurn));
+            consecutiveEmptyResponses = emptyResponseState.consecutiveEmptyResponses;
+            if (lastTurn.thoughtOnly) {
+                removeTrailingThoughtOnlyAssistant(kernel.state.messages);
+                lastTurn = await runWithCompressionResume([], false);
+                continue;
+            }
+            if (!emptyResponseState.retry)
+                break;
             removeTrailingFailedAssistant(agent, kernel.state.messages);
-            emptyResponseRetries += 1;
-            const notice = `[Model retry] Provider returned an empty response; retrying the same deployment (${emptyResponseRetries}/2).`;
+            const retryNumber = consecutiveEmptyResponses;
+            const notice = `[Model retry] Provider returned an empty response; retrying the same deployment (${retryNumber}/${emptyResponseRetry_1.MAX_EMPTY_RESPONSE_RETRIES}) after ${(0, emptyResponseRetry_1.emptyResponseRetryDelayMs)(consecutiveEmptyResponses)}ms.`;
             tokens.push({ type: 'text', text: notice });
             agent.recordWorkStatus(notice);
-            await agent.waitForPlannedRouteRetry();
+            await agent.waitForPlannedRouteRetry((0, emptyResponseRetry_1.emptyResponseRetryDelayMs)(consecutiveEmptyResponses));
             lastTurn = await runWithCompressionResume([], false);
         }
         let routeRetries = 0;
@@ -667,7 +702,7 @@ async function runAgentKernel(agent) {
                     }
                     if (textStarted)
                         finalContent.push({ type: 'text', text });
-                    if (!finalContent.length) {
+                    if (!finalContent.length && !thinking.trim()) {
                         text = '[Error] Provider returned an empty response.';
                         finalContent.push({ type: 'text', text });
                     }

package/dist/core/emptyResponseRetry.d.ts

@@ -0,0 +1,16 @@
+export declare const EMPTY_RESPONSE_RETRY_DELAYS_MS: readonly [200, 800, 2000, 10000, 60000];
+/**
+ * A retry is scheduled only after an explicit provider empty-response
+ * failure. The initial failed request is not called a retry, so five retries
+ * means six consecutive explicit failures before termination.
+ */
+export declare const MAX_EMPTY_RESPONSE_RETRIES: 5;
+export declare const MAX_CONSECUTIVE_EMPTY_RESPONSES: number;
+export declare function emptyResponseRetryDelayMs(consecutiveEmptyResponses: number): number;
+export interface EmptyResponseRetryState {
+    consecutiveEmptyResponses: number;
+    retry: boolean;
+    terminate: boolean;
+}
+export declare function observeEmptyResponseOutcome(consecutiveEmptyResponses: number, emptyResponse: boolean): EmptyResponseRetryState;
+//# sourceMappingURL=emptyResponseRetry.d.ts.map

package/dist/core/emptyResponseRetry.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_CONSECUTIVE_EMPTY_RESPONSES = exports.MAX_EMPTY_RESPONSE_RETRIES = exports.EMPTY_RESPONSE_RETRY_DELAYS_MS = void 0;
+exports.emptyResponseRetryDelayMs = emptyResponseRetryDelayMs;
+exports.observeEmptyResponseOutcome = observeEmptyResponseOutcome;
+exports.EMPTY_RESPONSE_RETRY_DELAYS_MS = [200, 800, 2_000, 10_000, 60_000];
+/**
+ * A retry is scheduled only after an explicit provider empty-response
+ * failure. The initial failed request is not called a retry, so five retries
+ * means six consecutive explicit failures before termination.
+ */
+exports.MAX_EMPTY_RESPONSE_RETRIES = exports.EMPTY_RESPONSE_RETRY_DELAYS_MS.length;
+exports.MAX_CONSECUTIVE_EMPTY_RESPONSES = exports.MAX_EMPTY_RESPONSE_RETRIES + 1;
+function emptyResponseRetryDelayMs(consecutiveEmptyResponses) {
+    return exports.EMPTY_RESPONSE_RETRY_DELAYS_MS[Math.max(0, consecutiveEmptyResponses - 1)] ?? 0;
+}
+function observeEmptyResponseOutcome(consecutiveEmptyResponses, emptyResponse) {
+    const nextCount = emptyResponse ? consecutiveEmptyResponses + 1 : 0;
+    return {
+        consecutiveEmptyResponses: nextCount,
+        retry: emptyResponse && nextCount <= exports.MAX_EMPTY_RESPONSE_RETRIES,
+        terminate: emptyResponse && nextCount > exports.MAX_EMPTY_RESPONSE_RETRIES,
+    };
+}
+//# sourceMappingURL=emptyResponseRetry.js.map

package/dist/core/terminalOutputBuffer.d.ts

@@ -0,0 +1,24 @@
+export declare const TERMINAL_HISTORY_LIMIT: number;
+export interface TerminalOutputBufferOptions {
+    flushIntervalMs?: number;
+    historyLimit?: number;
+}
+export declare class TerminalOutputBuffer {
+    private readonly send;
+    private readonly sessions;
+    private timer;
+    private readonly flushIntervalMs;
+    private readonly historyLimit;
+    constructor(send: (sessionId: string, text: string) => void, options?: TerminalOutputBufferOptions);
+    push(sessionId: string, text: string): void;
+    flush(sessionId: string): void;
+    flushAll(): void;
+    close(sessionId: string): string;
+    history(sessionId: string): string;
+    pendingChunkCount(): number;
+    hasScheduledFlush(): boolean;
+    private bound;
+    private schedule;
+    private clearTimerWhenIdle;
+}
+//# sourceMappingURL=terminalOutputBuffer.d.ts.map