mixdog 1.2.2 → 1.2.3

package/src/runtime/agent/orchestrator/providers/openai-direct-request.mjs

@@ -1,28 +1,20 @@
-import { getModelMetadataSync } from '../../../shared/llm/model-catalog.mjs';
+import {
+  openAiCatalogMeta,
+  openAiSupportsExtendedRetention,
+  openAiUsesPromptCacheOptions,
+} from './openai-model-capabilities.mjs';
 
-// Public Responses contracts are independent of the OAuth backend. Every
-// capability here comes from the model catalog (the service-tier price columns
-// and the cache-write rate), so a model the catalog lists works without an
-// edit. Only a model no catalog describes (cold install) falls back to the
-// documented ids known before the catalogs carried these columns.
-const SNAPSHOT_SUFFIX = /-\d{4}-\d{2}-\d{2}$/;
+// Public Responses contracts are independent of the OAuth backend. Service
+// tiers come from the model catalog (the service-tier price columns), so a
+// model the catalog lists works without an edit. Only a model no catalog
+// describes (cold install) falls back to the documented ids known before the
+// catalogs carried these columns.
 const PRE_CATALOG_GPT_56_PLUS =
   /^(?:gpt-6-(?:astra|sol|luna)|gpt-6\.1-sol|gpt-5\.6-(?:sol|terra|luna))(?:-\d{4}-\d{2}-\d{2})?$/;
 const PRE_CATALOG_EARLIER_FAST = /^gpt-5\.(?:5|4|4-mini)(?:-\d{4}|$)/;
 const PRE_CATALOG_ULTRAFAST = /^(?:gpt-6-astra|gpt-6\.1-sol)(?:-\d{4}-\d{2}-\d{2})?$/;
 const modelId = (model) => String(model?.id || model || '').trim();
 
-// The catalog metadata of one model. A dated snapshot reads as its undated
-// alias when only the alias is listed.
-function openAiCatalogMeta(model) {
-  const id = String(model?.id || model || '').trim();
-  for (const candidate of new Set([id, id.replace(SNAPSHOT_SUFFIX, '')])) {
-    const meta = candidate ? getModelMetadataSync(candidate, 'openai') : null;
-    if (meta) return meta;
-  }
-  return null;
-}
-
 export function openAiDirectSupportsFast(model) {
   const meta = openAiCatalogMeta(model);
   // The catalog's declaration (true or false) decides; a published Priority
@@ -40,13 +32,13 @@ export function openAiDirectSupportsUltrafast(model) {
   return PRE_CATALOG_ULTRAFAST.test(modelId(model));
 }
 
-// OpenAI bills prompt-cache writes from GPT-5.6 on, and exactly those models
-// take prompt_cache_options in place of prompt_cache_retention, so a published
-// cache-write rate selects the new form.
 // https://developers.openai.com/api/docs/guides/prompt-caching
+// GPT-5.6 and later: prompt_cache_options.ttl. Earlier models: 24h
+// prompt_cache_retention only on the documented extended-retention list;
+// every other model gets no lifetime field (never inferred from pricing).
 function promptCacheForm(model) {
-  const writeRate = openAiCatalogMeta(model)?.cacheWriteCostPerM > 0;
-  return writeRate || PRE_CATALOG_GPT_56_PLUS.test(modelId(model)) ? 'options' : 'retention';
+  if (openAiUsesPromptCacheOptions(model) || PRE_CATALOG_GPT_56_PLUS.test(modelId(model))) return 'options';
+  return openAiSupportsExtendedRetention(model) ? 'retention' : null;
 }
 
 export function applyOpenAIDirectCachePolicy(body, model, storeResponses) {

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

@@ -6,6 +6,8 @@
  */
 import { recomputeToolInFlight } from '../response-state.mjs';
 import { parseJsonObject } from '../response-items.mjs';
+import { withToolCallNamespace } from '../../custom-tool-wire.mjs';
+import { isIncompleteToolItem } from '../../lib/responses-terminal-fields.mjs';
 
 function outputItemKind(item) {
   if (item.type === 'reasoning') return 'reasoning';
@@ -19,10 +21,10 @@ export function createOutputItemEvents({ state, items, meaningful }) {
   const onOutputItemAdded = (item) => {
     if (item?.type === 'function_call') {
       toolTracker.mark(item);
-      state.pendingCalls.set(item.id || '', {
-        name: item.name || '',
-        callId: item.call_id || '',
-      });
+      state.pendingCalls.set(
+        item.id || '',
+        withToolCallNamespace({ name: item.name || '', callId: item.call_id || '' }, item)
+      );
       state.toolInFlight = true;
     } else if (item?.type === 'tool_search_call') {
       // Mark tool_search as in-flight the moment the item is added,
@@ -66,12 +68,15 @@ export function createOutputItemEvents({ state, items, meaningful }) {
       meaningful('tool');
       return;
     }
-    const call = {
-      id: pending?.callId || event.call_id || '',
-      name: pending?.name || event.name || '',
-      arguments: parseJsonObject(event.arguments),
-      _pendingItemId: itemId,
-    };
+    const call = withToolCallNamespace(
+      {
+        id: pending?.callId || event.call_id || '',
+        name: pending?.name || event.name || '',
+        arguments: parseJsonObject(event.arguments),
+        _pendingItemId: itemId,
+      },
+      pending
+    );
     state.toolCalls.push(call);
     if (call.id && call.name) {
       delete call._pendingItemId;
@@ -81,9 +86,17 @@ export function createOutputItemEvents({ state, items, meaningful }) {
   };
 
   const onOutputItemDone = (item) => {
+    if (isIncompleteToolItem(item)) {
+      // Server-truncated call: stays in flight, never collected or replayed.
+      toolTracker.mark(item);
+      state.toolInFlight = true;
+      meaningful('tool');
+      return;
+    }
     items.pushResponseItem(item);
     items.pushReasoningItem(item);
     items.pushWebSearchCall(item);
+    state.refusals.absorbMessage(item);
     if (item.type === 'function_call') {
       const tc = state.toolCalls.find((t) => t._pendingItemId === (item.id || ''));
       if (tc) items.completePendingCall(tc, item);

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

@@ -8,6 +8,7 @@ import { typedStatusFrom } from '../../retry-classifier.mjs';
 import {
   endTurnFromEvent,
   incompleteReasonFromEvent,
+  isIncompleteToolItem,
   isMaxOutputIncompleteReason,
 } from '../../lib/responses-terminal-fields.mjs';
 import { applyErrorContract, markContentFilter } from '../../openai-error-contract.mjs';
@@ -36,6 +37,13 @@ export function createTerminalFrameEvents({ state, items, text, outcome, meaning
   const absorbCompletedOutput = (output) => {
     let reported = false;
     for (const item of output) {
+      if (isIncompleteToolItem(item)) {
+        state.toolTracker.mark(item);
+        state.toolInFlight = true;
+        meaningful('tool');
+        reported = true;
+        continue;
+      }
       items.pushResponseItem(item);
       if (item.type === 'message') {
         if (text.absorbCompletedMessage(item)) reported = true;
@@ -101,26 +109,39 @@ export function createTerminalFrameEvents({ state, items, text, outcome, meaning
       }
       throw err;
     }
+    for (const item of event.response?.output || []) {
+      if (isIncompleteToolItem(item)) {
+        state.toolTracker.mark(item);
+        state.toolInFlight = true;
+      }
+    }
     if (toolInputPending(state)) {
+      // Same carried state as the WS path: text (leak-guard tail flushed),
+      // the calls already complete and dispatched, model and billed usage.
+      text.flushLeak();
       const err = outcome.stampToolSafety(new Error(`${state.label} ${frame} (max_output_tokens) with tool call in flight`));
+      outcome.attachStreamPartial(err);
       err.streamStalled = true;
       err.pendingToolUse = true;
-      err.partialContent = state.content;
-      err.partialModel = state.model || undefined;
+      err.incompleteReason = reason;
       if (state.usage) err.partialUsage = state.usage;
       throw err;
     }
     state.completed = true;
     state.stopReason = 'length';
+    state.incompleteReason = reason;
   };
 
   const onDone = (event) => {
-    if (!event.response || event.response.status === 'completed') {
-      if (event.response) absorbTerminalResponse(event.response);
+    if (!event.response) {
       state.completed = true;
       // Terminal success frame for streams that never emit a separate
       // response.completed — same optional end_turn.
       setEndTurn(event);
+    } else if (event.response.status === 'completed') {
+      // Same terminal as response.completed: usage, end_turn and the output
+      // bundle reconciled through the same deduplicated collectors.
+      onCompleted(event);
     } else if (event.response.status === 'failed') {
       const msg = event.response?.error?.message || 'response.done failed';
       const err = new Error(`${state.label} response.done failed: ${msg}`);

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

@@ -42,6 +42,16 @@ export function createResponseEvents({ state, items, text, outcome, meaningful,
       case 'response.function_call_arguments.done':
         output.onFunctionCallArgumentsDone(event);
         break;
+      // Refusal text is collected for the typed refusal result, never relayed
+      // as visible answer text.
+      case 'response.refusal.delta':
+        state.refusals.delta(event);
+        meaningful('semantic');
+        break;
+      case 'response.refusal.done':
+        state.refusals.done(event);
+        meaningful('semantic');
+        break;
       case 'response.output_item.done':
         output.onOutputItemDone(event.item || {});
         break;

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

@@ -5,7 +5,12 @@
  * pending function_call completion.
  */
 import { makeInvalidToolArgsMarker } from '../lib/openai-tool-args.mjs';
-import { customToolCallFromResponseItem, nativeToolSearchCallFromArguments } from '../custom-tool-wire.mjs';
+import {
+  customToolCallFromResponseItem,
+  nativeToolSearchCallFromArguments,
+  qualifiedToolCallName,
+  withToolCallNamespace,
+} from '../custom-tool-wire.mjs';
 
 // Completed function_call.arguments parse for the OpenAI Responses stream.
 // A function_call item arrives only on a completion/done signal, so a
@@ -37,7 +42,7 @@ export function createResponseItems({ state, onToolCall }) {
     if (!call?.id) return;
     if (state.emittedToolCallIds.has(call.id)) return;
     state.emittedToolCallIds.add(call.id);
-    if (!state.toolDedupe.shouldDispatch(call.name, call.arguments, call.id)) return;
+    if (!state.toolDedupe.shouldDispatch(qualifiedToolCallName(call), call.arguments, call.id)) return;
     state.emittedToolCall = true;
     try {
       onToolCall?.(call);
@@ -77,6 +82,8 @@ export function createResponseItems({ state, onToolCall }) {
   };
   const pushToolSearchCall = (item) => {
     if (item?.type !== 'tool_search_call') return;
+    // Server-executed search already ran inside the response; replay-only.
+    if (item.execution === 'server') return;
     const callId = item.call_id || item.id || '';
     if (!callId || state.toolCalls.some((t) => t.id === callId)) return;
     let args = {};
@@ -104,6 +111,7 @@ export function createResponseItems({ state, onToolCall }) {
   const completePendingCall = (tc, item) => {
     if (!tc.id && item.call_id) tc.id = item.call_id;
     if (!tc.name && item.name) tc.name = item.name;
+    withToolCallNamespace(tc, item);
     if (tc.id && tc.name) {
       delete tc._pendingItemId;
       emitToolCall(tc);
@@ -119,11 +127,14 @@ export function createResponseItems({ state, onToolCall }) {
     if (tc) {
       completePendingCall(tc, item);
     } else if (item.call_id && item.name) {
-      const call = {
-        id: item.call_id,
-        name: item.name,
-        arguments: parseJsonObject(item.arguments),
-      };
+      const call = withToolCallNamespace(
+        {
+          id: item.call_id,
+          name: item.name,
+          arguments: parseJsonObject(item.arguments),
+        },
+        item
+      );
       state.toolCalls.push(call);
       emitToolCall(call);
     }

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

@@ -9,6 +9,7 @@ import { dedupeToolCallList } from '../lib/leaked-toolcall.mjs';
 import { _displayCodexModel } from '../openai-codex-model.mjs';
 import { createProviderReplay } from '../lib/provider-replay.mjs';
 import { createResponseStamps } from './response-stamps.mjs';
+import { refusalResultFields } from '../openai-ws-response-state/refusals.mjs';
 
 export function createResponseOutcome({ state }) {
   const { stampToolSafety, stampOutcome, stallPartial, stampStreamError, attachStreamPartial, endedEarlyError } =
@@ -74,6 +75,7 @@ export function createResponseOutcome({ state }) {
       webSearchCalls: state.webSearchCalls.length ? state.webSearchCalls : undefined,
       usage: state.usage || undefined,
       stopReason: state.stopReason || undefined,
+      incompleteReason: state.incompleteReason || undefined,
       // Only present when the terminal frame carried the wire field.
       ...(typeof state.endTurn === 'boolean' ? { endTurn: state.endTurn } : {}),
       // Text-only max-output cutoff (status:'incomplete'/reason=max_output_tokens
@@ -83,6 +85,8 @@ export function createResponseOutcome({ state }) {
       ...(state.stopReason === 'length' && state.content.length > 0 ? { truncated: true } : {}),
       responseId: state.responseId || undefined,
       serviceTier: state.serviceTier || undefined,
+      // A refused turn: typed stop reason and the refusal text.
+      ...refusalResultFields(state.refusals, state.content),
     };
   };
 

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

@@ -7,6 +7,7 @@
  */
 import { createActiveToolItemTracker } from '../tool-stream-state.mjs';
 import { createToolCallDedupe } from '../lib/leaked-toolcall.mjs';
+import { createRefusals } from '../openai-ws-response-state/refusals.mjs';
 
 export function createResponseState(label) {
   return {
@@ -31,8 +32,12 @@ export function createResponseState(label) {
     citationKeys: new Set(),
     webSearchCalls: [],
     webSearchCallKeys: new Set(),
+    // Refusal parts (streamed and final), folded into one typed refusal.
+    refusals: createRefusals(),
     completed: false,
     stopReason: null,
+    // Why a max-output cutoff completed the turn (response.incomplete_details).
+    incompleteReason: null,
     // Normalized wire `end_turn` from the terminal frame; undefined unless the
     // server actually supplied a boolean.
     endTurn: undefined,

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

@@ -97,10 +97,18 @@ export function createTextRelay({ state, body, onTextDelta, meaningful, emitTool
   };
   const absorbCompletedMessage = (item) => {
     let reported = false;
+    // Decided once per message item (as the WS completed-item fold does), so
+    // every content part of an item with no streamed text is absorbed rather
+    // than only the first one that fills `state.content`.
+    const absorbText = !state.content;
     for (const part of item.content || []) {
-      if (!state.content && part.type === 'output_text' && absorbCompletedText(part)) reported = true;
+      if (absorbText && part.type === 'output_text' && absorbCompletedText(part)) reported = true;
       if (part.type === 'output_text') pushOutputTextAnnotations(part, state.citations, state.citationKeys);
     }
+    if (state.refusals.absorbMessage(item)) {
+      meaningful('semantic');
+      reported = true;
+    }
     return reported;
   };
 

package/src/runtime/agent/orchestrator/providers/openai-model-capabilities.mjs

@@ -0,0 +1,80 @@
+// Public OpenAI API model capabilities for Responses request construction.
+// Catalog metadata decides where it declares a capability; otherwise the
+// documented model-family rules below apply. The Codex (openai-oauth) route is
+// separate: its backend serves only current GPT-5.x models and keeps its own
+// defaults, so none of these gates apply to it.
+//   reasoning:    https://developers.openai.com/api/docs/guides/reasoning/
+//   tool_search:  https://developers.openai.com/api/docs/guides/tools-tool-search/ (gpt-5.4 and later)
+//   cache:        https://developers.openai.com/api/docs/guides/prompt-caching/
+import { getModelMetadataSync } from '../../../shared/llm/model-catalog.mjs';
+
+const SNAPSHOT_SUFFIX = /-\d{4}-\d{2}-\d{2}$/;
+const modelId = (model) => String(model?.id || model || '').trim();
+
+// The catalog metadata of one model. A dated snapshot reads as its undated
+// alias when only the alias is listed.
+export function openAiCatalogMeta(model) {
+  const id = modelId(model);
+  for (const candidate of new Set([id, id.replace(SNAPSHOT_SUFFIX, '')])) {
+    const meta = candidate ? getModelMetadataSync(candidate, 'openai') : null;
+    if (meta) return meta;
+  }
+  return null;
+}
+
+// gpt-5.4 -> [5, 4]; gpt-6-astra -> [6, 0]; non-GPT ids -> null.
+// A bare multi-digit major with no minor or family suffix (gpt-60) is not a
+// generation id.
+function gptVersion(id) {
+  const m = /^gpt-(\d+)(?:\.(\d+))?(?=-|$)/.exec(id);
+  if (!m || (m[1].length > 1 && m[2] === undefined && m[0] === id)) return null;
+  return [Number(m[1]), Number(m[2] || 0)];
+}
+const atLeast = (version, major, minor) =>
+  Boolean(version) && (version[0] > major || (version[0] === major && version[1] >= minor));
+
+// Reasoning models: the o-series and GPT-5 and later (gpt-5-chat-latest is the
+// non-reasoning chat snapshot).
+export function openAiPublicSupportsReasoning(model) {
+  const flag = openAiCatalogMeta(model)?.supportsReasoning;
+  if (typeof flag === 'boolean') return flag;
+  const id = modelId(model);
+  if (/^gpt-5-chat/.test(id)) return false;
+  return /^o\d/.test(id) || atLeast(gptVersion(id), 5, 0);
+}
+
+// text.verbosity is documented for GPT-5 and later.
+export function openAiPublicSupportsVerbosity(model) {
+  return atLeast(gptVersion(modelId(model)), 5, 0);
+}
+
+// Native tool_search: Responses API gpt-5.4 and later.
+export function openAiPublicSupportsToolSearch(model) {
+  return atLeast(gptVersion(modelId(model)), 5, 4);
+}
+
+// GPT-5.6 and later take prompt_cache_options.ttl instead of prompt_cache_retention.
+export function openAiUsesPromptCacheOptions(model) {
+  return atLeast(gptVersion(modelId(model)), 5, 6);
+}
+
+// Documented extended (24h) prompt_cache_retention list; dated snapshots read
+// as their alias.
+const EXTENDED_RETENTION = new Set([
+  'gpt-5.5',
+  'gpt-5.5-pro',
+  'gpt-5.4',
+  'gpt-5.2',
+  'gpt-5.1-codex-max',
+  'gpt-5.1',
+  'gpt-5.1-codex',
+  'gpt-5.1-codex-mini',
+  'gpt-5.1-chat-latest',
+  'gpt-5',
+  'gpt-5-codex',
+  'gpt-4.1',
+]);
+export function openAiSupportsExtendedRetention(model) {
+  const id = modelId(model);
+  return EXTENDED_RETENTION.has(id) || EXTENDED_RETENTION.has(id.replace(SNAPSHOT_SUFFIX, ''));
+}

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

@@ -102,7 +102,9 @@ export function createOpenAiOAuthDispatch({
     for (const [key, expiresAt] of provider._httpFallbackUntilByPoolKey) {
       if (!(expiresAt > now)) provider._httpFallbackUntilByPoolKey.delete(key);
     }
-    return (provider._httpFallbackUntilByPoolKey.get(poolKey) || 0) > now;
+    // A forked transport scope follows its session's switch; it records its own.
+    const sessionUntil = opts.sessionId ? provider._httpFallbackUntilByPoolKey.get(opts.sessionId) || 0 : 0;
+    return Math.max(provider._httpFallbackUntilByPoolKey.get(poolKey) || 0, sessionUntil) > now;
   };
   const markStickyHttpFallback = () => {
     if (!poolKey) return;

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

@@ -20,6 +20,8 @@ import { httpLabel } from './openai-error-contract.mjs';
 import { openHttpSseResponse } from './openai-http-sse-request.mjs';
 import { createHttpSseWatchdogs } from './openai-http-sse-watchdogs.mjs';
 import { createHttpSseResponseState } from './openai-http-sse-response-state.mjs';
+import { codexUserAgent, codexVersionHeader } from './codex-client-meta.mjs';
+import { _codexBetaFeatures } from './openai-ws-headers.mjs';
 export { _envFlag };
 
 function _sseEventsFromBuffer(buffer) {
@@ -73,6 +75,11 @@ export function _buildOpenAIHttpFallbackHeaders({
     originator: CODEX_OAUTH_ORIGINATOR,
     'chatgpt-account-id': auth.account_id || '',
     'x-client-request-id': randomBytes(16).toString('hex'),
+    // Codex identity shared with the WS handshake (build_responses_headers);
+    // WS-only OpenAI-Beta value stays HTTP-specific above.
+    'User-Agent': codexUserAgent(),
+    version: codexVersionHeader(),
+    'x-codex-beta-features': _codexBetaFeatures(),
   };
   if (cacheKey && !statelessConversation) {
     const sid = String(cacheKey);

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

@@ -152,6 +152,11 @@ export class OpenAIOAuthProvider {
     return this.tokens;
   }
 
+  /** Drop a disposed transport scope's sticky transport record. */
+  releaseTransportScope(scope) {
+    this._httpFallbackUntilByPoolKey.delete(scope);
+  }
+
   send(messages, model, tools, sendOpts) {
     return withEffortConfigurationFallback('openai-oauth', model, sendOpts || {}, (opts) =>
       this._sendOnce(messages, model, tools, opts)
@@ -207,7 +212,8 @@ export class OpenAIOAuthProvider {
     // session. cacheKey is body.prompt_cache_key and affects prompt-cache
     // routing only; Codex handshake identity comes from sendOpts and remains
     // independent so a future cache-lane policy cannot merge conversations.
-    const poolKey = opts.sessionId || null;
+    // A forked request runs in its own transport scope (transport-scope.mjs).
+    const poolKey = opts.transportScope || opts.sessionId || null;
     const cacheKey = body.prompt_cache_key || resolveProviderCacheKey(opts, 'openai-oauth');
     const iteration = Number.isFinite(Number(opts.iteration)) ? Number(opts.iteration) : null;
     const sendWs = typeof opts._sendViaWebSocketFn === 'function' ? opts._sendViaWebSocketFn : sendViaWebSocket;