mixdog 1.4.0 → 1.4.1

package/src/runtime/agent/orchestrator/providers/openai-compat-chat-send.mjs

@@ -184,6 +184,7 @@ export async function sendCompatChat(provider, messages, useModel, tools, opts)
                 signal: attemptSignal,
                 label: provider.name,
                 providerName: provider.name,
+                sessionId: opts.sessionId,
                 onStreamDelta: opts.onStreamDelta,
                 onToolCall: opts.onToolCall,
                 onTextDelta: opts.onTextDelta,

package/src/runtime/agent/orchestrator/providers/openai-compat-chat-stream/chunk-events.mjs

@@ -5,7 +5,14 @@
  */
 import { mergeToolCallDelta } from './tool-call-acc.mjs';
 import { reportStreamItemStart } from '../lib/send-callbacks.mjs';
-import { appendText, drainLeakedCalls, relayText, reportProgress, reportTransport } from './stream-state.mjs';
+import {
+  appendText,
+  drainLeakedCalls,
+  relayText,
+  reportLifecycle,
+  reportProgress,
+  reportTransport,
+} from './stream-state.mjs';
 import { chatContentParts } from '../openai-compat-reasoning-field.mjs';
 
 function appendReasoning(state, text, source) {
@@ -50,7 +57,7 @@ export function applyCompatChunk(state, chunk) {
   const choice = chunk?.choices?.[0];
   const delta = choice?.delta;
   if (typeof delta?.role === 'string' && delta.role) {
-    reportProgress(state, 'semantic');
+    reportLifecycle(state, 'semantic');
   }
   const contentParts = chatContentParts(delta?.content);
   if (contentParts) applyContentParts(state, contentParts);

package/src/runtime/agent/orchestrator/providers/openai-compat-chat-stream/stream-state.mjs

@@ -70,6 +70,13 @@ export function reportProgress(state, kind) {
   } catch {}
 }
 
+/** Chunk metadata without output (a role-only delta): progress once the
+ *  model has produced output; before that it neither ends the first-output
+ *  phase nor starts the semantic idle (the chunk already reported transport). */
+export function reportLifecycle(state, kind) {
+  if (state.semanticIdleDeadlineAt > 0) reportProgress(state, kind);
+}
+
 /** Text the model exposed: accumulate, refresh the idle deadline, relay live. */
 export function appendText(state, text) {
   state.content += text;

package/src/runtime/agent/orchestrator/providers/openai-compat-chat-stream.mjs

@@ -10,6 +10,7 @@ import {
   PROVIDER_SSE_IDLE_WATCHDOG_ENABLED,
   PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS,
   createTimeoutSignal,
+  providerFirstOutputTimeoutMs,
 } from '../stall-policy.mjs';
 import { TIMEOUT_PHASE } from '../../../shared/provider-timeout-phase.mjs';
 import {
@@ -28,6 +29,7 @@ import {
   toolWorkStarted,
 } from './openai-compat-chat-stream/stream-state.mjs';
 import { applyCompatChunk } from './openai-compat-chat-stream/chunk-events.mjs';
+import { streamFirstOutputWindow } from './lib/first-output-window.mjs';
 import { incompleteStreamError, settleCompatStream } from './openai-compat-chat-stream/stream-result.mjs';
 
 export async function consumeCompatChatCompletionStream(
@@ -45,11 +47,20 @@ export async function consumeCompatChatCompletionStream(
     semanticIdleTimeoutMs,
     firstByteTimeoutMs,
     leakedToolCallRecovery = true,
+    sessionId = null,
   } = {}
 ) {
   const idleOverrideEnabled = Number.isFinite(Number(semanticIdleTimeoutMs)) && Number(semanticIdleTimeoutMs) > 0;
   const idleEnabled = idleOverrideEnabled || PROVIDER_SSE_IDLE_WATCHDOG_ENABLED;
   const idleMs = idleOverrideEnabled ? Number(semanticIdleTimeoutMs) : PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS;
+  // Until the first semantic output the logical request's first-output window
+  // bounds the stream; a request that already had output runs under the
+  // semantic idle from the stream's opening.
+  const firstOutput = streamFirstOutputWindow({
+    sessionId,
+    onStreamDelta,
+    timeoutMs: providerFirstOutputTimeoutMs(idleMs),
+  });
   const state = createCompatStreamState({
     providerName,
     knownToolNames,
@@ -60,6 +71,7 @@ export async function consumeCompatChatCompletionStream(
     onStreamItemStart,
     leakedToolCallRecovery,
   });
+  if (firstOutput.outputSeen) state.semanticIdleDeadlineAt = Date.now() + idleMs;
   reportTransport(state);
   const iterator = stream[Symbol.asyncIterator]();
   let iteratorDone = false;
@@ -72,9 +84,8 @@ export async function consumeCompatChatCompletionStream(
     while (true) {
       const { value: chunk, done } = await nextAsyncWithWatchdog(iterator, {
         signal: state.sawFirstEvent ? signal : firstByteTimeout.signal,
-        idleMs,
-        idleDeadlineAt: state.semanticIdleDeadlineAt,
-        idleEnabled: state.sawFirstEvent && idleEnabled && state.semanticIdleDeadlineAt > 0,
+        ...firstOutput.idleWatch(state.semanticIdleDeadlineAt, idleMs),
+        idleEnabled: state.sawFirstEvent && idleEnabled,
         idleLabel: `${label} SSE idle`,
         streamLabel: label,
         emittedToolCall: () => toolWorkStarted(state),

package/src/runtime/agent/orchestrator/providers/openai-compat-responses-events.mjs

@@ -147,7 +147,8 @@ function settleMaxOutputIncomplete(event, state, ctx, reason) {
 function onCreated(event, state, ctx) {
   if (event.response?.model) state.model = event.response.model;
   if (event.response?.id) state.responseId = event.response.id;
-  signal(ctx, 'semantic');
+  // Metadata, not output: progress only once the stream has seen output.
+  ctx.onLifecycle?.('semantic');
 }
 
 function onOutputTextDelta(event, state, ctx) {
@@ -196,7 +197,8 @@ function onOutputItemAdded(event, state, ctx) {
     state.toolInFlight = true;
   }
   reportStreamItemStart(ctx.onStreamItemStart, responsesItemStart(event.item));
-  signal(ctx, state.toolInFlight ? 'tool' : 'semantic');
+  if (state.toolInFlight) signal(ctx, 'tool');
+  else ctx.onLifecycle?.('semantic');
 }
 
 // A tool call's args (or custom-tool input) are streaming — mark tool work

package/src/runtime/agent/orchestrator/providers/openai-compat-responses.mjs

@@ -241,6 +241,7 @@ async function streamCompatResponses({ provider, params, label, signal, opts, he
           return await consumeCompatResponsesStream(stream, {
             signal: attemptSignal,
             label,
+            sessionId: opts.sessionId,
             onStreamDelta: opts.onStreamDelta,
             onToolCall: opts.onToolCall,
             onTextDelta: opts.onTextDelta,

package/src/runtime/agent/orchestrator/providers/openai-compat-stream-common.mjs

@@ -168,9 +168,11 @@ export async function nextAsyncWithWatchdog(
       }
       // The SDK JSON-decodes each frame inside next(): a SyntaxError here is a
       // malformed wire frame, typed at this boundary and nowhere else.
-      iterator.next().then(resolve, (error) =>
-        reject(error instanceof SyntaxError ? malformedCompatStreamError(streamLabel || idleLabel, error) : error)
-      );
+      iterator
+        .next()
+        .then(resolve, (error) =>
+          reject(error instanceof SyntaxError ? malformedCompatStreamError(streamLabel || idleLabel, error) : error)
+        );
     });
   } catch (err) {
     if (idleTimedOut)

package/src/runtime/agent/orchestrator/providers/openai-compat-stream.mjs

@@ -7,6 +7,7 @@ import {
   PROVIDER_SSE_IDLE_WATCHDOG_ENABLED,
   PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS,
   createTimeoutSignal,
+  providerFirstOutputTimeoutMs,
 } from '../stall-policy.mjs';
 import {
   closeCompatStream,
@@ -23,6 +24,7 @@ import {
   parseCompletedToolCallArgumentsJson,
 } from './lib/openai-tool-args.mjs';
 import { handleCompatResponsesStreamEvent } from './openai-compat-responses-events.mjs';
+import { streamFirstOutputWindow } from './lib/first-output-window.mjs';
 import {
   attachPartialState,
   createResponsesLeakRelay,
@@ -56,6 +58,7 @@ export async function consumeCompatResponsesStream(
     responseOutputText,
     knownToolNames,
     semanticIdleTimeoutMs,
+    sessionId = null,
   } = {}
 ) {
   try {
@@ -68,13 +71,23 @@ export async function consumeCompatResponsesStream(
   const idleEnabled = idleOverrideEnabled || PROVIDER_SSE_IDLE_WATCHDOG_ENABLED;
   // Per-event (last-event-relative) SEMANTIC idle — see the Chat path note.
   const idleMs = idleOverrideEnabled ? Number(semanticIdleTimeoutMs) : PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS;
+  // Until the first semantic output the logical request's first-output window
+  // bounds the stream; a request that already had output runs under the
+  // semantic idle from the stream's opening.
+  const firstOutput = streamFirstOutputWindow({
+    sessionId,
+    onStreamDelta,
+    timeoutMs: providerFirstOutputTimeoutMs(idleMs),
+  });
   const state = createResponsesStreamState();
+  if (firstOutput.outputSeen) state.semanticIdleDeadlineAt = Date.now() + idleMs;
   const reportProgress = (kind) => {
     if (kind !== 'transport') state.semanticIdleDeadlineAt = Date.now() + idleMs;
     try {
       onStreamDelta?.(kind);
     } catch {}
   };
+  const reportLifecycle = (kind) => reportProgress(state.semanticIdleDeadlineAt > 0 ? kind : 'transport');
   let sawFirstEvent = false;
   const { relayLeakText, flushLeak, leakedCalls } = createResponsesLeakRelay({
     state,
@@ -88,6 +101,7 @@ export async function consumeCompatResponsesStream(
     parseResponsesToolCalls,
     responseOutputText,
     onStreamDelta: reportProgress,
+    onLifecycle: reportLifecycle,
     onToolCall,
     onTextDelta,
     onStreamItemStart,
@@ -98,9 +112,8 @@ export async function consumeCompatResponsesStream(
     while (true) {
       const { value: event, done } = await nextAsyncWithWatchdog(iterator, {
         signal: sawFirstEvent ? signal : firstByteTimeout.signal,
-        idleMs,
-        idleDeadlineAt: state.semanticIdleDeadlineAt,
-        idleEnabled: sawFirstEvent && idleEnabled && state.semanticIdleDeadlineAt > 0,
+        ...firstOutput.idleWatch(state.semanticIdleDeadlineAt, idleMs),
+        idleEnabled: sawFirstEvent && idleEnabled,
         idleLabel: `${label} SSE idle`,
         streamLabel: label,
         // Unsafe-to-retry once any tool call (native or recovered-leaked)

package/src/runtime/agent/orchestrator/providers/openai-compat-xai-send.mjs

@@ -131,6 +131,7 @@ export async function sendXaiResponses(provider, messages, useModel, tools, opts
           return await consumeCompatResponsesStream(stream, {
             signal: attemptSignal,
             label: 'xai:responses',
+            sessionId: opts.sessionId,
             onStreamDelta: opts.onStreamDelta,
             onToolCall: opts.onToolCall,
             onTextDelta: opts.onTextDelta,

package/src/runtime/agent/orchestrator/providers/openai-http-sse-response-state/response-events/output-items.mjs

@@ -15,7 +15,7 @@ function outputItemKind(item) {
   return 'semantic';
 }
 
-export function createOutputItemEvents({ state, items, meaningful }) {
+export function createOutputItemEvents({ state, items, meaningful, lifecycle }) {
   const { toolTracker } = state;
 
   const onOutputItemAdded = (item) => {
@@ -52,7 +52,10 @@ export function createOutputItemEvents({ state, items, meaningful }) {
       toolTracker.mark(item);
       state.toolInFlight = true;
     }
-    meaningful(state.toolInFlight ? 'tool' : 'semantic');
+    // A tool call starting is model output; an empty reasoning or message
+    // item is lifecycle (the silent thinking follows it).
+    if (state.toolInFlight) meaningful('tool');
+    else lifecycle('semantic');
   };
 
   const onToolInputDelta = (itemId) => {

package/src/runtime/agent/orchestrator/providers/openai-http-sse-response-state/response-events.mjs

@@ -7,18 +7,28 @@ import { createOutputItemEvents } from './response-events/output-items.mjs';
 import { createTerminalFrameEvents } from './response-events/terminal-frames.mjs';
 import { reportStreamItemStart, responsesItemStart } from '../lib/send-callbacks.mjs';
 
-export function createResponseEvents({ state, items, text, outcome, meaningful, onServerEvent, onStreamItemStart }) {
-  const output = createOutputItemEvents({ state, items, meaningful });
+export function createResponseEvents({
+  state,
+  items,
+  text,
+  outcome,
+  meaningful,
+  lifecycle,
+  onServerEvent,
+  onStreamItemStart,
+}) {
+  const output = createOutputItemEvents({ state, items, meaningful, lifecycle });
   const terminal = createTerminalFrameEvents({ state, items, text, outcome, meaningful });
 
   const handleEvent = (event) => {
     if (!event || typeof event.type !== 'string') return;
     onServerEvent();
     switch (event.type) {
+      // The server's ack is metadata, not model output: it satisfies only the
+      // first-server-event deadline (onServerEvent above).
       case 'response.created':
         if (event.response?.model) state.model = event.response.model;
         if (event.response?.id) state.responseId = event.response.id;
-        meaningful('semantic');
         break;
       case 'response.output_text.delta':
         text.relayLeakText(event.delta || '');

package/src/runtime/agent/orchestrator/providers/openai-http-sse-response-state.mjs

@@ -24,7 +24,8 @@ import { createResponseEvents } from './openai-http-sse-response-state/response-
  * @param {(call: object) => void} [deps.onToolCall]
  * @param {(text: string) => void} [deps.onTextDelta]
  * @param {(kind: string) => void} deps.meaningful  semantic progress (re-arms the idle watchdog)
- * @param {() => void} deps.onServerEvent  first-event → semantic-idle handover
+ * @param {(kind: string) => void} [deps.lifecycle]  item lifecycle without output: progress only after semantic output
+ * @param {() => void} deps.onServerEvent  any parsed server event (satisfies the first-server-event deadline)
  * @param {(detail: object) => void} [deps.onStreamItemStart]  a tool call or phased message started
  */
 export function createHttpSseResponseState({
@@ -33,6 +34,7 @@ export function createHttpSseResponseState({
   onTextDelta,
   onStreamItemStart = null,
   meaningful,
+  lifecycle = () => {},
   onServerEvent,
   label,
 }) {
@@ -40,7 +42,16 @@ export function createHttpSseResponseState({
   const outcome = createResponseOutcome({ state });
   const items = createResponseItems({ state, onToolCall });
   const text = createTextRelay({ state, body, onTextDelta, meaningful, emitToolCall: items.emitToolCall });
-  const events = createResponseEvents({ state, items, text, outcome, meaningful, onServerEvent, onStreamItemStart });
+  const events = createResponseEvents({
+    state,
+    items,
+    text,
+    outcome,
+    meaningful,
+    lifecycle,
+    onServerEvent,
+    onStreamItemStart,
+  });
 
   return {
     handleEvent: events.handleEvent,

package/src/runtime/agent/orchestrator/providers/openai-http-sse-watchdogs.mjs

@@ -1,7 +1,15 @@
 /**
  * openai-http-sse-watchdogs.mjs — liveness gates of one HTTP/SSE fallback
  * stream: the total/external abort relay, the fixed first-server-event
- * deadline, the SEMANTIC idle watchdog, and the cancellable reader.read().
+ * deadline, the first-OUTPUT window, the SEMANTIC idle watchdog, and the
+ * cancellable reader.read().
+ *
+ * Until the model's first semantic output (reasoning, text, a tool call) only
+ * the first-server-event deadline and the first-output window run: server
+ * metadata (response.created / in_progress, an empty reasoning or message
+ * item) and keepalives neither end that phase nor start the semantic-idle
+ * clock, so a model may think silently longer than the idle window. From the
+ * first semantic output on, the semantic idle owns the stream.
  *
  * After headerTimeout.cleanup() the in-flight fetch no longer carries a live
  * signal, so a totalTimeout / external abort that fires during a pending
@@ -17,8 +25,10 @@ import {
   PROVIDER_FIRST_BYTE_TIMEOUT_MS,
   PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS,
   PROVIDER_SSE_IDLE_WATCHDOG_ENABLED,
+  providerFirstOutputTimeoutMs,
   streamStalledError,
 } from '../stall-policy.mjs';
+import { streamFirstOutputWindow } from './lib/first-output-window.mjs';
 
 function positiveOverride(value) {
   const ms = Number(value);
@@ -31,8 +41,18 @@ function positiveOverride(value) {
  * @param {ReadableStreamDefaultReader} deps.reader
  * @param {{ signal?: AbortSignal, cleanup(): void }} deps.totalTimeout
  * @param {() => object} deps.stallPartial  streamed partial state attached to a semantic-idle stall
+ * @param {string|null} [deps.sessionId]  the session whose logical request this stream serves
+ * @param {Function} [deps.onStreamDelta]  the stream's progress callback; without it the stream is a fork of the request
  */
-export function createHttpSseWatchdogs({ opts, reader, totalTimeout, stallPartial, label: LABEL }) {
+export function createHttpSseWatchdogs({
+  opts,
+  reader,
+  totalTimeout,
+  stallPartial,
+  label: LABEL,
+  sessionId = null,
+  onStreamDelta,
+}) {
   let abortReason = null;
   let pendingReadReject = null;
   const rejectPendingRead = (err) => {
@@ -58,9 +78,46 @@ export function createHttpSseWatchdogs({ opts, reader, totalTimeout, stallPartia
     else totalTimeout.signal.addEventListener('abort', onTotalAbort, { once: true });
   }
 
-  // Initial wait is governed only by the fixed first-server-event policy.
-  // Semantic idle begins after a parsed server event, so a lower
-  // semantic-idle override cannot shorten this first-event wait.
+  // SEMANTIC idle watchdog: reset ONLY on meaningful() (text/reasoning/tool
+  // deltas), never on raw bytes/keepalive frames, so a stream that emits some
+  // deltas then goes silent trips a short, named terminal failure instead of
+  // hanging until the 30-min agent watchdog. Disablable via the shared env.
+  let semanticIdleTimer = null;
+  const semanticIdleOverrideMs = positiveOverride(opts?._semanticIdleTimeoutMs);
+  const semanticIdleMs = semanticIdleOverrideMs || PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS;
+  const semanticIdleEnabled = semanticIdleOverrideMs > 0 || PROVIDER_SSE_IDLE_WATCHDOG_ENABLED;
+  // FIRST-OUTPUT window of the logical request this stream serves, retired by
+  // the first semantic output. Metadata-only streams (repeated
+  // response.in_progress, keepalive/ping frames, unknown event types) cannot
+  // refresh it, so a wedge that never produces a token still ends here.
+  const firstOutputOverrideMs = positiveOverride(opts?._firstOutputTimeoutMs);
+  const firstOutput = streamFirstOutputWindow({
+    sessionId,
+    onStreamDelta,
+    timeoutMs: firstOutputOverrideMs || providerFirstOutputTimeoutMs(semanticIdleMs),
+  });
+  const firstOutputEnabled = firstOutputOverrideMs > 0 || semanticIdleEnabled;
+
+  // A stalled stream fails with the named stall error, carrying the streamed
+  // partial state so the agent loop can accept a wedged FINAL no-tool summary
+  // as a successful partial-final instead of dropping the result.
+  // pendingToolUse gates out any mid-flight tool call.
+  const abortStalled = (timeoutMs) => {
+    const partial = stallPartial();
+    const err = streamStalledError(LABEL, timeoutMs, { emittedToolCall: partial.emittedToolCall });
+    try {
+      err.partialContent = partial.content;
+      err.partialToolCalls = partial.toolCalls;
+      err.pendingToolUse = partial.pendingToolUse;
+      err.partialModel = partial.model;
+    } catch {
+      /* best-effort enrichment */
+    }
+    abortStream(err);
+  };
+
+  // Initial wait for any server event is governed by the fixed
+  // first-server-event policy; a lower semantic-idle override cannot shorten it.
   let firstServerEventTimer = null;
   const firstServerEventMs = positiveOverride(opts?._firstServerEventTimeoutMs) || PROVIDER_FIRST_BYTE_TIMEOUT_MS;
   const clearFirstServerEvent = () => {
@@ -82,15 +139,15 @@ export function createHttpSseWatchdogs({ opts, reader, totalTimeout, stallPartia
       firstServerEventTimer.unref?.();
     } catch {}
   };
+  // Until the stream's first output the request's first-output window bounds
+  // it. A request that already had output has none: its stream runs under the
+  // semantic idle from its first server event (noteServerEvent).
+  const armFirstOutput = () => {
+    if (!firstOutput.outputSeen && firstOutputEnabled && firstOutput.timeoutMs > 0) {
+      firstOutput.arm(() => abortStalled(firstOutput.timeoutMs));
+    }
+  };
 
-  // SEMANTIC idle watchdog: reset ONLY on meaningful() (text/reasoning/tool
-  // deltas), never on raw bytes/keepalive frames, so a stream that emits some
-  // deltas then goes silent trips a short, named terminal failure instead of
-  // hanging until the 30-min agent watchdog. Disablable via the shared env.
-  let semanticIdleTimer = null;
-  const semanticIdleOverrideMs = positiveOverride(opts?._semanticIdleTimeoutMs);
-  const semanticIdleMs = semanticIdleOverrideMs || PROVIDER_SEMANTIC_IDLE_TIMEOUT_MS;
-  const semanticIdleEnabled = semanticIdleOverrideMs > 0 || PROVIDER_SSE_IDLE_WATCHDOG_ENABLED;
   const clearSemanticIdle = () => {
     if (semanticIdleTimer) {
       clearTimeout(semanticIdleTimer);
@@ -100,43 +157,22 @@ export function createHttpSseWatchdogs({ opts, reader, totalTimeout, stallPartia
   const armSemanticIdle = () => {
     if (!semanticIdleEnabled || !(semanticIdleMs > 0)) return;
     clearSemanticIdle();
-    semanticIdleTimer = setTimeout(() => {
-      const partial = stallPartial();
-      const err = streamStalledError(LABEL, semanticIdleMs, { emittedToolCall: partial.emittedToolCall });
-      // Partial-final recovery: attach the streamed partial state so the
-      // agent loop can accept a wedged FINAL no-tool summary as a successful
-      // partial-final instead of dropping the result. pendingToolUse gates
-      // out any mid-flight tool call.
-      try {
-        err.partialContent = partial.content;
-        err.partialToolCalls = partial.toolCalls;
-        err.pendingToolUse = partial.pendingToolUse;
-        err.partialModel = partial.model;
-      } catch {
-        /* best-effort enrichment */
-      }
-      abortStream(err);
-    }, semanticIdleMs);
+    semanticIdleTimer = setTimeout(() => abortStalled(semanticIdleMs), semanticIdleMs);
     try {
       semanticIdleTimer.unref?.();
     } catch {}
   };
-  // One-shot latch for the first-server-event → semantic-idle handover. Once
-  // the FIRST real SSE server event arrives, the fixed initial deadline is
-  // satisfied and semantic-idle ownership begins. Arming on every parsed event
-  // let a metadata-only stream (repeated response.in_progress, keepalive/ping
-  // frames, unknown event types) refresh the watchdog forever without
-  // producing a single token. Only meaningful progress re-arms it from then on.
-  let semanticIdleArmed = false;
+  // A parsed server event satisfies the first-server-event deadline and, for a
+  // request that already had output, starts the semantic idle (once: only
+  // output re-arms it).
   const noteServerEvent = () => {
     clearFirstServerEvent();
-    if (!semanticIdleArmed) {
-      semanticIdleArmed = true;
-      armSemanticIdle();
-    }
+    if (firstOutput.outputSeen && !semanticIdleTimer) armSemanticIdle();
   };
+  // Semantic output: the first one ends the first-output phase; every one
+  // re-arms the semantic idle.
   const noteMeaningful = () => {
-    semanticIdleArmed = true;
+    firstOutput.noteOutput();
     armSemanticIdle();
   };
 
@@ -151,6 +187,7 @@ export function createHttpSseWatchdogs({ opts, reader, totalTimeout, stallPartia
   const dispose = () => {
     pendingReadReject = null;
     clearFirstServerEvent();
+    firstOutput.clear();
     clearSemanticIdle();
     try {
       reader.releaseLock?.();
@@ -165,9 +202,11 @@ export function createHttpSseWatchdogs({ opts, reader, totalTimeout, stallPartia
   return {
     abortReason: () => abortReason,
     armFirstServerEvent,
+    armFirstOutput,
     clearSemanticIdle,
     noteServerEvent,
     noteMeaningful,
+    semanticSeen: () => firstOutput.outputSeen,
     read,
     dispose,
   };

package/src/runtime/agent/orchestrator/providers/openai-oauth-http-sse.mjs

@@ -183,6 +183,8 @@ export async function sendViaHttpSse({
     totalTimeout,
     stallPartial: () => state.stallPartial(),
     label,
+    sessionId: opts?.sessionId,
+    onStreamDelta,
   });
   const meaningful = (kind = 'semantic') => {
     if (ttftMs == null) ttftMs = Date.now() - sseStartedAt;
@@ -191,12 +193,17 @@ export async function sendViaHttpSse({
       onStreamDelta?.(kind);
     } catch {}
   };
+  // An empty reasoning or message item added: progress only after output.
+  const lifecycle = (kind = 'semantic') => {
+    if (watchdogs.semanticSeen()) meaningful(kind);
+  };
   const state = createHttpSseResponseState({
     body,
     onToolCall,
     onTextDelta,
     onStreamItemStart: typeof opts?.onStreamItemStart === 'function' ? opts.onStreamItemStart : null,
     meaningful,
+    lifecycle,
     onServerEvent: watchdogs.noteServerEvent,
     label,
   });
@@ -210,6 +217,7 @@ export async function sendViaHttpSse({
   let buffer = '';
   try {
     watchdogs.armFirstServerEvent();
+    watchdogs.armFirstOutput();
     while (true) {
       if (totalTimeout.signal?.aborted) {
         watchdogs.clearSemanticIdle();