mixdog 1.2.5 → 1.3.0

package/src/runtime/agent/orchestrator/providers/lib/oauth-page.mjs

@@ -31,17 +31,61 @@ function escapeHtml(value) {
     .replaceAll("'", ''');
 }
 
-function renderPage({ heading, message, details }) {
-  const title = escapeHtml(heading);
+// The callback servers do not know the app language, so the default is
+// bilingual (Korean first). A known language picks one copy.
+const COPY = {
+  ko: {
+    successTitle: '로그인 완료',
+    successBody: (name) => `${name} 로그인이 완료되었습니다. 이 탭을 닫고 Mixdog로 돌아가 주세요.`,
+    failureTitle: '로그인 실패',
+    failureBody: 'Mixdog로 돌아가 다시 시도해 주세요.',
+    reason: '사유',
+    close: '닫기',
+  },
+  en: {
+    successTitle: 'Sign-in complete',
+    successBody: (name) => `You are signed in to ${name}. You can close this tab and return to Mixdog.`,
+    failureTitle: 'Sign-in failed',
+    failureBody: 'Return to Mixdog and try again.',
+    reason: 'Reason',
+    close: 'Close',
+  },
+};
+
+function renderPage({ kind, providerName, reason, lang }) {
+  const langs = lang === 'ko' || lang === 'en' ? [lang] : ['ko', 'en'];
+  const blocks = langs
+    .map((code, index) => {
+      const copy = COPY[code];
+      const title = kind === 'success' ? copy.successTitle : copy.failureTitle;
+      const body = kind === 'success' ? copy.successBody(providerName) : copy.failureBody;
+      const tag = index === 0 ? 'h1' : 'h2';
+      return `<section lang="${code}" class="${index === 0 ? 'primary' : 'secondary'}">
+      <${tag}>${escapeHtml(title)}</${tag}>
+      <p>${escapeHtml(body)}</p>
+    </section>`;
+    })
+    .join('\n    ');
+  const reasonBlock = reason
+    ? `<div class="reason"><span>${langs.map((code) => COPY[code].reason).join(' / ')}</span>${escapeHtml(reason)}</div>`
+    : '';
+  const close = langs.map((code) => COPY[code].close).join(' · ');
+  const documentTitle = escapeHtml(
+    `${langs.map((code) => COPY[code][kind === 'success' ? 'successTitle' : 'failureTitle']).join(' / ')} · Mixdog`
+  );
   return `<!doctype html>
-<html lang="en">
+<html lang="${langs[0]}">
 <head>
   <meta charset="utf-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1" />
-  <title>${title} · Mixdog</title>
+  <meta name="color-scheme" content="dark light" />
+  <title>${documentTitle}</title>
   <style>
+    :root { --bg: #f6f7f9; --fg: #0f172a; --muted: #475569; --card: #ffffff; --line: #d9dee6; --ok: #15803d; --bad: #b91c1c; --link: #1d4ed8; }
+    @media (prefers-color-scheme: dark) {
+      :root { --bg: #07080b; --fg: #f8fafc; --muted: #94a3b8; --card: #0f1116; --line: #232733; --ok: #4ade80; --bad: #f87171; --link: #93c5fd; }
+    }
     * { box-sizing: border-box; }
-    html { color-scheme: dark; }
     body {
       margin: 0;
       min-height: 100vh;
@@ -49,32 +93,65 @@ function renderPage({ heading, message, details }) {
       align-items: center;
       justify-content: center;
       padding: 24px;
-      background: #07080b;
-      color: #f8fafc;
-      font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif;
+      background: var(--bg);
+      color: var(--fg);
+      font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", "Malgun Gothic", "Apple SD Gothic Neo", "Noto Sans KR", Roboto, Arial, sans-serif;
       text-align: center;
     }
-    main { width: 100%; max-width: 560px; display: flex; flex-direction: column; align-items: center; }
-    .logo { width: 72px; height: 72px; margin-bottom: 24px; }
+    main {
+      width: 100%;
+      max-width: 520px;
+      padding: 40px 32px 32px;
+      background: var(--card);
+      border: 1px solid var(--line);
+      border-radius: 16px;
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+    }
+    .logo { width: 72px; height: 72px; margin-bottom: 20px; }
     .logo svg { width: 100%; height: 100%; display: block; }
-    h1 { margin: 0 0 10px; font-size: 28px; line-height: 1.15; font-weight: 650; }
-    p { margin: 0; line-height: 1.7; color: #94a3b8; font-size: 15px; }
-    .details {
-      margin-top: 16px;
-      font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", monospace;
+    h1, h2 { margin: 0 0 6px; line-height: 1.2; font-weight: 650; }
+    h1 { font-size: 28px; color: ${kind === 'success' ? 'var(--ok)' : 'var(--bad)'}; }
+    h2 { font-size: 16px; color: var(--muted); font-weight: 600; }
+    p { margin: 0; line-height: 1.7; color: var(--muted); font-size: 15px; }
+    section.secondary { margin-top: 18px; }
+    .reason {
+      margin-top: 20px;
+      width: 100%;
+      padding: 12px 14px;
+      border: 1px solid var(--line);
+      border-radius: 10px;
+      text-align: left;
+      font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
       font-size: 13px;
-      color: #94a3b8;
+      color: var(--fg);
       white-space: pre-wrap;
       word-break: break-word;
     }
+    .reason span { display: block; margin-bottom: 4px; color: var(--muted); font-family: inherit; font-size: 12px; }
+    button {
+      margin-top: 24px;
+      min-width: 120px;
+      height: 40px;
+      padding: 0 20px;
+      border: 1px solid var(--line);
+      border-radius: 10px;
+      background: transparent;
+      color: var(--fg);
+      font: inherit;
+      font-size: 14px;
+      cursor: pointer;
+    }
+    button:hover { border-color: var(--muted); }
   </style>
 </head>
 <body>
   <main>
     <div class="logo">${LOGO_SVG}</div>
-    <h1>${title}</h1>
-    <p>${escapeHtml(message)}</p>
-    ${details ? `<div class="details">${escapeHtml(details)}</div>` : ''}
+    ${blocks}
+    ${reasonBlock}
+    <button type="button" onclick="window.close()">${escapeHtml(close)}</button>
   </main>
 </body>
 </html>`;
@@ -82,13 +159,10 @@ function renderPage({ heading, message, details }) {
 
 export const OAUTH_PAGE_CONTENT_TYPE = 'text/html; charset=utf-8';
 
-export function oauthSuccessHtml(providerName) {
-  return renderPage({
-    heading: 'Authentication successful',
-    message: `Signed in to ${providerName}. You can close this tab and return to Mixdog.`,
-  });
+export function oauthSuccessHtml(providerName, { lang } = {}) {
+  return renderPage({ kind: 'success', providerName, lang });
 }
 
-export function oauthErrorHtml(message, details) {
-  return renderPage({ heading: 'Authentication failed', message, details });
+export function oauthErrorHtml(reason, { lang } = {}) {
+  return renderPage({ kind: 'failure', reason, lang });
 }

package/src/runtime/agent/orchestrator/providers/lib/send-callbacks.mjs

@@ -8,5 +8,29 @@ export function streamCallbacks(opts) {
     onToolCall: functionOrNull(opts.onToolCall),
     onTextDelta: functionOrNull(opts.onTextDelta),
     onTextReset: functionOrNull(opts.onTextReset),
+    onStreamItemStart: functionOrNull(opts.onStreamItemStart),
   };
 }
+
+/** Tell the caller a provider output item started streaming: `{ kind: 'tool' }`
+ *  for a client tool call whose arguments are still on the way, `{ kind:
+ *  'text', phase }` for an assistant message that names its phase
+ *  (`commentary` / `final_answer`). A listener failure never reaches the
+ *  stream. */
+export function reportStreamItemStart(onStreamItemStart, detail) {
+  if (typeof onStreamItemStart !== 'function' || !detail) return;
+  try {
+    onStreamItemStart(detail);
+  } catch {}
+}
+
+const ASSISTANT_PHASES = new Set(['commentary', 'final_answer']);
+
+/** What a Responses output item tells `reportStreamItemStart`: a client tool
+ *  call, an assistant message carrying its phase, or nothing (null). */
+export function responsesItemStart(item) {
+  const type = item?.type;
+  if (type === 'function_call' || type === 'custom_tool_call' || type === 'tool_search_call') return { kind: 'tool' };
+  if (type === 'message' && ASSISTANT_PHASES.has(item.phase)) return { kind: 'text', phase: item.phase };
+  return null;
+}

package/src/runtime/agent/orchestrator/providers/oauth-credential-probes.mjs

@@ -5,6 +5,7 @@ import { resolvePluginData } from '../../../shared/plugin-paths.mjs';
 import { boundProviderAuthPath } from '../../../shared/provider-auth-binding.mjs';
 import { cursorTokenExpiry } from './cursor-auth.mjs';
 import { isValidMuseCredentialDocument } from './muse-code-oauth-tokens.mjs';
+import { isValidOpenCodeGoCredentialDocument } from './opencode-go-oauth-tokens.mjs';
 import { developerOptionEnabled, developerOptionForProvider } from '../../../shared/developer-options.mjs';
 import { modelProxyClientMode } from '../../../shared/model-proxy-mode.mjs';
 
@@ -198,6 +199,17 @@ function museCodeOAuthState() {
   );
 }
 
+function openCodeGoOAuthState() {
+  const paths = [
+    boundProviderAuthPath('opencode-go-oauth') ||
+      process.env.OPENCODE_GO_OAUTH_CREDENTIALS_PATH ||
+      join(resolvePluginData(), 'opencode-go-oauth.json'),
+  ];
+  return memoProbe('opencode-go-oauth', paths, () =>
+    resolveProbeState(paths, (docs) => docs.some(isValidOpenCodeGoCredentialDocument))
+  );
+}
+
 // Antigravity needs a resolved Cloud project alongside the tokens: without it
 // every request 400s, so a half-finished login must not enable the provider.
 function antigravityOAuthState() {
@@ -270,6 +282,7 @@ const OAUTH_PROBE_STATES = new Map([
   ['mimo-oauth', mimoOAuthState],
   ['cursor-oauth', cursorOAuthState],
   ['antigravity-oauth', antigravityOAuthState],
+  ['opencode-go-oauth', openCodeGoOAuthState],
 ]);
 
 // Dev-only OAuth providers (Antigravity, Cursor). Each is hidden and treated as

package/src/runtime/agent/orchestrator/providers/oauth-usage.mjs

@@ -869,7 +869,8 @@ async function measureUsage(provider, providerObj, routeInfo) {
       provider === 'cursor-api' ||
       provider === 'antigravity-oauth' ||
       provider === 'muse-code-oauth' ||
-      provider === 'command-code-oauth') &&
+      provider === 'command-code-oauth' ||
+      provider === 'opencode-go-oauth') &&
     typeof providerObj?.getUsageSnapshot === 'function'
   ) {
     return await providerObj.getUsageSnapshot();

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

@@ -187,6 +187,7 @@ export async function sendCompatChat(provider, messages, useModel, tools, opts)
                 onStreamDelta: opts.onStreamDelta,
                 onToolCall: opts.onToolCall,
                 onTextDelta: opts.onTextDelta,
+                onStreamItemStart: opts.onStreamItemStart,
                 parseToolCalls,
                 // Known tool names for the leaked-tool-call guard:
                 // recovered leaked calls only synthesize when they name

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

@@ -4,6 +4,7 @@
  * reasoning aliases, tool_calls deltas, finish reason and usage.
  */
 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 { chatContentParts } from '../openai-compat-reasoning-field.mjs';
 
@@ -58,7 +59,10 @@ export function applyCompatChunk(state, chunk) {
   if (Array.isArray(delta?.tool_calls) && delta.tool_calls.length) {
     reportProgress(state, 'tool');
   }
+  const toolsBefore = state.toolAcc.byKey.size;
   mergeToolCallDelta(state.toolAcc, delta?.tool_calls);
+  // A tool call's first delta: its arguments are still streaming.
+  if (state.toolAcc.byKey.size > toolsBefore) reportStreamItemStart(state.onStreamItemStart, { kind: 'tool' });
   if (choice?.finish_reason) {
     state.stopReason = choice.finish_reason;
     drainLeakedCalls(state);

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

@@ -22,6 +22,7 @@ export function createCompatStreamState({
   onStreamDelta,
   onToolCall,
   onTextDelta,
+  onStreamItemStart,
 }) {
   const toolDedupe = createToolCallDedupe();
   return {
@@ -30,6 +31,7 @@ export function createCompatStreamState({
     onStreamDelta,
     onToolCall,
     onTextDelta,
+    onStreamItemStart,
     semanticIdleDeadlineAt: 0,
     sawFirstEvent: false,
     content: '',
@@ -86,7 +88,7 @@ export function isIncompleteFinishReason(finishReason) {
 
 /** Whether `finish_reason` confirms a normal end of the turn: present, not an
  *  incomplete outcome and not a gateway-reported failure (network_error/error). */
-export function isNormalFinishReason(finishReason) {
+function isNormalFinishReason(finishReason) {
   return (
     Boolean(finishReason) && !isIncompleteFinishReason(finishReason) && !failingFinishReasonError(finishReason, '')
   );

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

@@ -39,6 +39,7 @@ export async function consumeCompatChatCompletionStream(
     onStreamDelta,
     onToolCall,
     onTextDelta,
+    onStreamItemStart,
     parseToolCalls,
     knownToolNames,
     semanticIdleTimeoutMs,
@@ -55,6 +56,7 @@ export async function consumeCompatChatCompletionStream(
     onStreamDelta,
     onToolCall,
     onTextDelta,
+    onStreamItemStart,
   });
   reportTransport(state);
   const iterator = stream[Symbol.asyncIterator]();

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

@@ -47,23 +47,68 @@ export function extractCompatReasoningEffort(model) {
   return null;
 }
 
+const ERROR_BODY_LIMIT = 4096;
+// An echoed key prefix this long (or the whole key, if shorter) is redacted.
+const ECHOED_KEY_PREFIX_MIN = 8;
+
+// Replaces the request key, and any run of its first ECHOED_KEY_PREFIX_MIN or
+// more characters ("Incorrect API key provided: xai-abcd****"), in `value`.
+function redactRequestKey(value, key) {
+  if (!key) return value;
+  const min = Math.min(ECHOED_KEY_PREFIX_MIN, key.length);
+  let out = '';
+  for (let i = 0; i < value.length; ) {
+    let n = 0;
+    while (n < key.length && value[i + n] === key[n]) n += 1;
+    if (n >= min) {
+      out += '[redacted]';
+      i += n;
+    } else {
+      out += value[i];
+      i += 1;
+    }
+  }
+  return out;
+}
+
+// A refused /models request keeps the provider's own reason (status plus the
+// body's code/type/message) so the UI can say why the list is empty. The
+// message stays `<name> models <status>`; the body rides on `providerError`,
+// with the request key (`apiKey`) redacted from it.
+async function compatModelsError(name, res, apiKey = '') {
+  const error = Object.assign(new Error(`${name} models ${res.status}`), { status: res.status });
+  try {
+    const body = JSON.parse((await res.text()).slice(0, ERROR_BODY_LIMIT));
+    const nested = body?.error && typeof body.error === 'object' ? body.error : null;
+    const text = (value) => (typeof value === 'string' && value ? redactRequestKey(value, apiKey) : undefined);
+    const providerError = {
+      message: text(body?.error) ?? text(nested?.message) ?? text(body?.message),
+      code: text(nested?.code) ?? text(body?.code),
+      type: text(nested?.type) ?? text(body?.type),
+    };
+    if (providerError.message || providerError.code || providerError.type) error.providerError = providerError;
+  } catch {
+    // A body that is not JSON adds no detail.
+  }
+  return error;
+}
+
 // `keyless` omits the Authorization header entirely (keyless endpoints);
 // `signal` aborts the request together with the list timeout.
 export async function fetchCompatModelItems(provider, { signal = null, keyless = false } = {}) {
   const name = provider.name;
   const timeout = createTimeoutSignal(signal, MODEL_LIST_TIMEOUT_MS, `${name} model list`);
   try {
+    const apiKey = keyless ? '' : resolveProviderApiKey(name, provider.config || provider);
     const res = await fetch(`${String(provider.baseURL || '').replace(/\/+$/, '')}/models`, {
       method: 'GET',
       headers: {
-        ...(keyless
-          ? {}
-          : { Authorization: `Bearer ${resolveProviderApiKey(name, provider.config || provider) || 'no-key'}` }),
+        ...(keyless ? {} : { Authorization: `Bearer ${apiKey || 'no-key'}` }),
         ...(provider.defaultHeaders || {}),
       },
       signal: timeout.signal,
     });
-    if (!res.ok) throw Object.assign(new Error(`${provider.name} models ${res.status}`), { status: res.status });
+    if (!res.ok) throw await compatModelsError(provider.name, res, apiKey);
     const data = await res.json();
     if (Array.isArray(data?.data)) return data.data;
     if (Array.isArray(data)) return data;

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

@@ -9,13 +9,6 @@ export const OPENAI_COMPAT_PRESETS = {
     baseURL: 'https://api.x.ai/v1',
     defaultModel: 'grok-4.5',
   },
-  // OpenCode Go - low-cost coding-model subscription gateway.
-  'opencode-go': {
-    baseURL: 'https://opencode.ai/inference/go/v1',
-    defaultModel: 'glm-5.2',
-    // The gateway expects an application User-Agent (not the SDK default).
-    extraHeaders: { 'User-Agent': 'mixdog' },
-  },
   openrouter: {
     baseURL: 'https://openrouter.ai/api/v1',
     defaultModel: 'openrouter/auto',

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

@@ -14,6 +14,7 @@ import { truncatedCompatStreamError, parseCompletedToolCallArgumentsJson } from
 import { incompleteReasonFromEvent, isMaxOutputIncompleteReason } from './lib/responses-terminal-fields.mjs';
 import { responsesUsage } from './openai-compat-response-normalization.mjs';
 import { normalizeGatewayErrorDetail } from './provider-error-kind.mjs';
+import { reportStreamItemStart, responsesItemStart } from './lib/send-callbacks.mjs';
 
 // An incomplete response was still billed: carry its reported usage on the
 // error so the provider-boundary accounting records it.
@@ -194,6 +195,7 @@ function onOutputItemAdded(event, state, ctx) {
     state.toolTracker?.mark(event.item);
     state.toolInFlight = true;
   }
+  reportStreamItemStart(ctx.onStreamItemStart, responsesItemStart(event.item));
   signal(ctx, state.toolInFlight ? 'tool' : 'semantic');
 }
 
@@ -249,7 +251,11 @@ function onRefusalDone(event, state, ctx) {
 
 function onOutputItemDone(event, state, ctx) {
   const item = event.item || {};
-  if (item.type === 'message') refusalsOf(state).absorbMessage(item);
+  if (item.type === 'message') {
+    refusalsOf(state).absorbMessage(item);
+    // A stream that names the phase only on the finished item.
+    reportStreamItemStart(ctx.onStreamItemStart, responsesItemStart(item));
+  }
   if (item.type === 'function_call') {
     const itemId = reconcileCompatFunctionCallItem(state, item, ctx.label, ctx.onToolCall);
     // Drop the resolved function item from pendingCalls before

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

@@ -243,6 +243,7 @@ async function streamCompatResponses({ provider, params, label, signal, opts, he
             onStreamDelta: opts.onStreamDelta,
             onToolCall: opts.onToolCall,
             onTextDelta: opts.onTextDelta,
+            onStreamItemStart: opts.onStreamItemStart,
             parseResponsesToolCalls,
             responseOutputText,
             knownToolNames: knownToolNamesFromResponsesTools(params.tools),

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

@@ -51,6 +51,7 @@ export async function consumeCompatResponsesStream(
     onStreamDelta,
     onToolCall,
     onTextDelta,
+    onStreamItemStart,
     parseResponsesToolCalls,
     responseOutputText,
     knownToolNames,
@@ -89,6 +90,7 @@ export async function consumeCompatResponsesStream(
     onStreamDelta: reportProgress,
     onToolCall,
     onTextDelta,
+    onStreamItemStart,
     relayLeakText,
   };
   const stampOutcome = createResponsesOutcomeStamper(state, leakedCalls);

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

@@ -134,6 +134,7 @@ export async function sendXaiResponses(provider, messages, useModel, tools, opts
             onStreamDelta: opts.onStreamDelta,
             onToolCall: opts.onToolCall,
             onTextDelta: opts.onTextDelta,
+            onStreamItemStart: opts.onStreamItemStart,
             parseResponsesToolCalls,
             responseOutputText,
             knownToolNames: knownToolNamesFromResponsesTools(params.tools),

package/src/runtime/agent/orchestrator/providers/openai-error-contract.mjs

@@ -14,14 +14,6 @@ import { retryAfterMsFromError, sleepWithAbort } from './retry-classifier.mjs';
 
 const isObject = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
 
-// Explicit quota / billing refusals: waiting never helps, so no retry layer
-// may treat them as an ordinary rate limit.
-const QUOTA_OR_BILLING_CODE_RE = /quota|billing|usage_limit|usage_not_included/;
-
-export function isQuotaOrBillingCode(code) {
-  return QUOTA_OR_BILLING_CODE_RE.test(String(code || '').toLowerCase());
-}
-
 /**
  * Parse an HTTP error body ONCE into its contract fields. `message` is the
  * body's own message (untruncated); callers truncate for diagnostics.
@@ -211,7 +203,8 @@ export function applyErrorContract(err, { status, headers, code, error, event }
       err.status = n;
       err.httpStatus = n;
     }
-    const wireHeaders = headers ?? error?.headers ?? event?.error?.headers ?? event?.response?.error?.headers ?? event?.headers;
+    const wireHeaders =
+      headers ?? error?.headers ?? event?.error?.headers ?? event?.response?.error?.headers ?? event?.headers;
     if (wireHeaders && typeof wireHeaders === 'object') err.headers = wireHeaders;
     const rawCode = code ?? error?.code ?? error?.type ?? null;
     if (typeof rawCode === 'string' && rawCode.trim()) err.code = rawCode.trim().toLowerCase();
@@ -225,7 +218,13 @@ export function applyErrorContract(err, { status, headers, code, error, event }
       if (err.retryAfterAt == null) err.retryAfterAt = Date.now() + retryAfterMs;
     }
     const type = typeof error?.type === 'string' ? error.type.trim().toLowerCase() : '';
-    const mapped = typedWireErrorMessage({ code: err.code || '', type, error, headers: err.headers, resetAt: err.resetAt });
+    const mapped = typedWireErrorMessage({
+      code: err.code || '',
+      type,
+      error,
+      headers: err.headers,
+      resetAt: err.resetAt,
+    });
     if (mapped) applyTypedWireMessage(err, mapped, error?.message);
   } catch {}
   return err;
@@ -238,7 +237,12 @@ export function applyErrorContract(err, { status, headers, code, error, event }
  * makes unknown codes default-retryable).
  */
 export function markContentFilter(err, reason) {
-  if (String(reason || '').trim().toLowerCase() !== 'content_filter') return err;
+  if (
+    String(reason || '')
+      .trim()
+      .toLowerCase() !== 'content_filter'
+  )
+    return err;
   err.code = 'content_filter';
   err.providerErrorCode = 'content_filter';
   return err;
@@ -260,7 +264,8 @@ export function httpResponseError({ label, status, headers, text, initialRespons
 }
 
 // The route decides the HTTP/SSE label: the api-key `openai` provider is not OAuth.
-export const httpLabel = (auth) => (auth?.type === 'openai-direct' ? 'OpenAI HTTP fallback' : 'OpenAI OAuth HTTP fallback');
+export const httpLabel = (auth) =>
+  auth?.type === 'openai-direct' ? 'OpenAI HTTP fallback' : 'OpenAI OAuth HTTP fallback';
 
 /**
  * Changing transport must not bypass the server's retry deadline.

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

@@ -5,8 +5,9 @@
  */
 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 }) {
+export function createResponseEvents({ state, items, text, outcome, meaningful, onServerEvent, onStreamItemStart }) {
   const output = createOutputItemEvents({ state, items, meaningful });
   const terminal = createTerminalFrameEvents({ state, items, text, outcome, meaningful });
 
@@ -34,6 +35,7 @@ export function createResponseEvents({ state, items, text, outcome, meaningful,
         break;
       case 'response.output_item.added':
         output.onOutputItemAdded(event.item);
+        reportStreamItemStart(onStreamItemStart, responsesItemStart(event.item));
         break;
       case 'response.function_call_arguments.delta':
       case 'response.custom_tool_call_input.delta':
@@ -54,6 +56,8 @@ export function createResponseEvents({ state, items, text, outcome, meaningful,
         break;
       case 'response.output_item.done':
         output.onOutputItemDone(event.item || {});
+        // A stream that names the phase only on the finished message.
+        if (event.item?.type === 'message') reportStreamItemStart(onStreamItemStart, responsesItemStart(event.item));
         break;
       case 'response.completed':
         terminal.onCompleted(event);

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

@@ -25,13 +25,22 @@ import { createResponseEvents } from './openai-http-sse-response-state/response-
  * @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 {(detail: object) => void} [deps.onStreamItemStart]  a tool call or phased message started
  */
-export function createHttpSseResponseState({ body, onToolCall, onTextDelta, meaningful, onServerEvent, label }) {
+export function createHttpSseResponseState({
+  body,
+  onToolCall,
+  onTextDelta,
+  onStreamItemStart = null,
+  meaningful,
+  onServerEvent,
+  label,
+}) {
   const state = createResponseState(label);
   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 });
+  const events = createResponseEvents({ state, items, text, outcome, meaningful, onServerEvent, onStreamItemStart });
 
   return {
     handleEvent: events.handleEvent,

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

@@ -195,6 +195,7 @@ export async function sendViaHttpSse({
     body,
     onToolCall,
     onTextDelta,
+    onStreamItemStart: typeof opts?.onStreamItemStart === 'function' ? opts.onStreamItemStart : null,
     meaningful,
     onServerEvent: watchdogs.noteServerEvent,
     label,