mixdog 1.2.2 → 1.2.4

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

@@ -0,0 +1,183 @@
+// Shared by openai-compat-responses-native.test.mjs and the one-off generator
+// that produced openai-compat-responses-head-parity.json by running these same
+// captures against the pre-change (HEAD) converters.
+import { sendCompatResponses } from './openai-compat-responses.mjs';
+import { OpenAICompatProvider } from './openai-compat.mjs';
+import { buildRequestBody } from './openai-responses-payload.mjs';
+import { createProviderReplay } from './lib/provider-replay.mjs';
+
+export const SERVER_CALL = {
+  type: 'tool_search_call',
+  id: 'ts_srv',
+  call_id: null,
+  execution: 'server',
+  arguments: { query: 'q' },
+};
+export const SERVER_OUTPUT = {
+  type: 'tool_search_output',
+  id: 'tso_srv',
+  call_id: null,
+  execution: 'server',
+  tools: [],
+};
+export const REPLY = { type: 'message', role: 'assistant', content: [{ type: 'output_text', text: 'ok' }] };
+
+export const ROUTES = [
+  ['opencode-go', 'gpt-5.5'],
+  ['muse-code', 'muse-spark'],
+  ['command-code', 'gpt-5.5'],
+  ['custom-cmd', 'openai/gpt-5.6-sol'],
+  ['openrouter', 'openai/gpt-5.5'],
+  ['xai', 'grok-4'],
+  ['opencode-go', 'grok-4'],
+];
+export const FIRST_PARTY = [
+  ['openai', 'gpt-5.5'],
+  ['openai-oauth', 'gpt-5.5'],
+];
+
+export const replayOwner = (name) => `compat-responses:${name}`;
+
+const search = (name) => ({
+  provider: name,
+  openaiTools: [{ type: 'function', name: 'x', description: 'd', parameters: { type: 'object', properties: {} } }],
+});
+
+export function nativeHistory() {
+  return [
+    { role: 'user', content: 'go' },
+    {
+      role: 'assistant',
+      content: '',
+      toolCalls: [
+        { id: 'ts1', name: 'load_tool', arguments: { names: ['x'] }, nativeType: 'tool_search_call' },
+        { id: 'cu1', name: 'apply_patch', arguments: { patch: 'P' }, nativeType: 'custom_tool_call' },
+        { id: 'fn1', name: 'Read', arguments: { path: 'a' } },
+      ],
+    },
+    { role: 'tool', toolCallId: 'ts1', content: 'loaded' },
+    { role: 'tool', toolCallId: 'cu1', content: 'patched' },
+    { role: 'tool', toolCallId: 'fn1', content: 'file' },
+    { role: 'user', content: 'next' },
+  ];
+}
+
+// Left by a previous openai-oauth route: native search/custom calls, native
+// search results carrying loaded tools, phase-tagged assistant turns, a Skill
+// result with loadable tools, and a foreign openai-responses replay.
+export function oauthHistory() {
+  return [
+    { role: 'system', content: 'sys' },
+    { role: 'user', content: 'go' },
+    { role: 'assistant', content: 'working', phase: 'commentary', toolCalls: [] },
+    {
+      role: 'assistant',
+      content: 'looking',
+      phase: 'commentary',
+      reasoningItems: [{ id: 'rs', encrypted_content: 'ENC', summary: [] }],
+      toolCalls: [
+        { id: 'ts1', name: 'load_tool', arguments: { names: ['x'] }, nativeType: 'tool_search_call' },
+        { id: 'cu1', name: 'apply_patch', arguments: { patch: 'P' }, nativeType: 'custom_tool_call' },
+        { id: 'sk1', name: 'Skill', arguments: { name: 's' } },
+      ],
+    },
+    { role: 'tool', toolCallId: 'ts1', content: 'loaded', nativeToolSearch: search('openai-oauth') },
+    { role: 'tool', toolCallId: 'cu1', content: 'patched' },
+    { role: 'tool', toolCallId: 'sk1', content: 'skill', nativeToolSearch: search('openai-oauth') },
+    {
+      role: 'assistant',
+      content: '',
+      toolCalls: [{ id: 'f2', name: 'Read', arguments: { path: 'a' } }],
+      providerReplay: createProviderReplay('openai-responses', [
+        { type: 'tool_search_call', call_id: 'ts9', execution: 'client', arguments: {} },
+      ]),
+    },
+    { role: 'tool', toolCallId: 'f2', content: 'file' },
+    { role: 'user', content: 'next' },
+  ];
+}
+
+// Same-owner replay envelope holding a server-executed search pair.
+export function serverSearchReplayHistory(owner) {
+  return [
+    { role: 'user', content: 'find tools' },
+    {
+      role: 'assistant',
+      content: 'done',
+      providerReplay: createProviderReplay(owner, [
+        { type: 'reasoning', id: 'rs_1', encrypted_content: 'ENC', summary: [] },
+        SERVER_CALL,
+        SERVER_OUTPUT,
+        { type: 'function_call', call_id: 'c1', name: 'Read', arguments: '{}' },
+      ]),
+      toolCalls: [{ id: 'c1', name: 'Read', arguments: {} }],
+    },
+    { role: 'tool', toolCallId: 'c1', content: 'ok' },
+    { role: 'user', content: 'next' },
+  ];
+}
+
+// Pre-change flag-off cases: [label, history(name), providerState?]
+export const COMPAT_CASES = [
+  ['native', () => nativeHistory()],
+  ['oauth', () => oauthHistory()],
+  [
+    'own-search-output',
+    (name) => {
+      const h = nativeHistory();
+      h[2] = { ...h[2], nativeToolSearch: search(name) };
+      return h;
+    },
+  ],
+  ['server-replay', (name, owner = replayOwner(name)) => serverSearchReplayHistory(owner)],
+];
+
+export function compatProvider(name, config = {}) {
+  const requests = [];
+  const provider = Object.assign(Object.create(OpenAICompatProvider.prototype), {
+    name,
+    config: { preconnect: false, ...config },
+    nativePdf: true,
+    client: {
+      responses: {
+        create: async (params) => {
+          requests.push(structuredClone(params));
+          return (async function* () {
+            yield {
+              type: 'response.completed',
+              response: { id: 'resp-1', model: params.model, status: 'completed', output: [REPLY] },
+            };
+          })();
+        },
+      },
+    },
+  });
+  return { provider, requests };
+}
+
+export async function captureCompat(name, model, history, opts = {}, config = {}) {
+  const { provider, requests } = compatProvider(name, config);
+  await sendCompatResponses(provider, history, model, [], { sessionId: 'sess-1', ...opts });
+  return requests[0];
+}
+
+export function captureFirstParty(name, model, history) {
+  return JSON.parse(
+    JSON.stringify(buildRequestBody(history, model, [], { promptCacheProvider: name, sessionId: 'sess-1' }))
+  );
+}
+
+export async function captureAll() {
+  const out = {};
+  for (const [name, model] of ROUTES) {
+    for (const [label, build] of COMPAT_CASES) {
+      out[`compat/${name}/${model}/${label}`] = await captureCompat(name, model, build(name));
+    }
+  }
+  for (const [name, model] of FIRST_PARTY) {
+    for (const [label, build] of COMPAT_CASES) {
+      out[`first-party/${name}/${label}`] = captureFirstParty(name, model, build(name, 'openai-responses'));
+    }
+  }
+  return out;
+}

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

@@ -22,6 +22,7 @@ import {
   toXaiResponsesInput,
   xaiSystemInstructions,
 } from './openai-compat-wire.mjs';
+import { nativeDeferredFamilyForRoute } from './wire-route.mjs';
 import { preparePdfTextForProvider } from './media-normalization.mjs';
 import { normalizeOpencodeGoReasoningEffort } from './openai-compat-xai.mjs';
 import { isCustomProviderName, resolveCustomReasoning } from './custom-reasoning.mjs';
@@ -65,6 +66,7 @@ function resolveReasoning(provider, useModel, opts) {
 function customEffortProjection(provider, useModel, messages, opts) {
   if (!isCustomProviderName(provider.name)) return null;
   const projection = projectEffortConfiguration(messages, provider.name, useModel, {
+    ...provider.config,
     ...opts,
     protocol: 'openai-responses',
   });
@@ -87,21 +89,74 @@ function customEffortProjection(provider, useModel, messages, opts) {
   return { ...projection, initialEffort, effort: current, updates };
 }
 
+// Whether the endpoint takes `prompt_cache_key`. An explicit
+// `opts.responsesPromptCacheKey` / `config.responsesPromptCacheKey` boolean
+// decides; otherwise only custom routes (which always had it) send it.
+function supportsPromptCacheKey(provider, opts) {
+  const declared = opts.responsesPromptCacheKey ?? provider.config?.responsesPromptCacheKey;
+  return typeof declared === 'boolean' ? declared : isCustomProviderName(provider.name);
+}
+
+// Native Responses items (tool_search_call/output, custom_tool_call/output) in
+// replayed history are strictly opt-in: only a route that declares
+// `responsesNativeItems: true` (opts or config) gets the first-party lowering.
+// Every other route keeps the function-only lowering byte for byte.
+function supportsNativeResponsesItems(provider, opts) {
+  return (
+    (opts.responsesNativeItems ?? provider.config?.responsesNativeItems) === true ||
+    hasNativeDeferredTools(provider, opts)
+  );
+}
+
+// A session whose pinned route verified native deferred tools on the Responses
+// wire (flag off in every PROFILES entry today): tool_search is declared
+// natively and loaded tools replay as tool_search_output.
+function hasNativeDeferredTools(provider, opts) {
+  return nativeDeferredFamilyForRoute(provider.name, opts.wireRoute ?? opts.session?.wireRoute) === 'openai';
+}
+
 /**
- * A custom route's session identity: its prompt_cache_key and session
+ * A route's session identity: its prompt_cache_key and (custom routes) session
  * headers, '' without a session. The session wins over the provider-scoped
  * cache key, so parallel sessions never evict each other; a one-shot role
  * ('shared' scope, a fresh session per call) keys on the provider key instead.
  * Never the effort, so an effort change keeps the cache routing.
  */
 function customSessionCacheKey(provider, opts) {
-  if (!isCustomProviderName(provider.name)) return '';
+  if (!supportsPromptCacheKey(provider, opts)) return '';
   const explicit = opts.promptCacheKey || opts.providerCacheKey || opts.session?.promptCacheKey;
   return normalizeCacheKey(
     opts.promptCacheScope === 'shared' ? explicit || opts.sessionId : opts.sessionId || explicit
   );
 }
 
+// HTTP header names are case-insensitive. Do not shadow explicit SDK
+// defaults, combine differently-cased identities, or stringify null deletions.
+function customSessionHeaders(provider, sessionCacheKey, requestHeaders) {
+  if (!sessionCacheKey) return requestHeaders;
+  const headers = { 'session-id': sessionCacheKey, 'x-client-request-id': sessionCacheKey };
+  const clientOptions = provider.config?.clientOptions || {};
+  const configured = Object.hasOwn(clientOptions, 'defaultHeaders')
+    ? clientOptions.defaultHeaders
+    : provider.defaultHeaders;
+  const entries = (source) =>
+    source instanceof Headers || Array.isArray(source) ? source : Object.entries(source || {});
+  const hasValue = (value) => (Array.isArray(value) ? value.some((item) => item !== undefined) : value !== undefined);
+  for (const source of [configured, requestHeaders]) {
+    for (const [name, value] of entries(source)) {
+      if (hasValue(value)) delete headers[name.toLowerCase()];
+    }
+  }
+  if (requestHeaders instanceof Headers) {
+    const merged = new Headers(requestHeaders);
+    for (const [name, value] of Object.entries(headers)) merged.set(name, value);
+    return merged;
+  }
+  if (Array.isArray(requestHeaders)) return [...Object.entries(headers), ...requestHeaders];
+  const supplied = Object.fromEntries(Object.entries(requestHeaders || {}).filter(([, value]) => hasValue(value)));
+  return { ...headers, ...supplied };
+}
+
 /** The request body: lowered transcript plus the per-turn knobs (output cap,
  *  tools and tool choice, reasoning effort, session cache key). */
 function buildCompatResponsesParams({
@@ -126,7 +181,11 @@ function buildCompatResponsesParams({
   const maxOutputTokens = resolveCompatMaxOutputTokens(opts);
   if (maxOutputTokens) params.max_output_tokens = maxOutputTokens;
   if (tools?.length) {
-    params.tools = toResponsesTools(tools, { provider: provider.name });
+    params.tools = toResponsesTools(tools, {
+      provider: provider.name,
+      onToolExcluded: opts.onToolExcluded,
+      ...(hasNativeDeferredTools(provider, opts) ? { nativeDeferredTools: true } : {}),
+    });
     params.parallel_tool_calls = true;
   }
   applyCompatToolChoice(params, opts);
@@ -207,6 +266,22 @@ async function streamCompatResponses({ provider, params, label, signal, opts, he
   }
 }
 
+// OpenRouter's Responses endpoint is stateless: it does not store responses or
+// resolve `previous_response_id`. Imported server-side continuation state (a
+// previous id, or a stored response) is rejected up front rather than sent.
+function assertOpenRouterStateless(provider, opts) {
+  if (provider.name !== 'openrouter') return;
+  const imported = opts.providerState?.[COMPAT_RESPONSES_STATE_KEY];
+  const previous = typeof imported?.previousResponseId === 'string' && imported.previousResponseId !== '';
+  if (!previous && imported?.store !== true) return;
+  throw Object.assign(
+    new Error(
+      'openrouter Responses is stateless: imported previous_response_id / store:true continuation state is not supported'
+    ),
+    { code: 'OPENROUTER_RESPONSES_STATELESS_ONLY', provider: provider.name }
+  );
+}
+
 /**
  * Send one turn over `POST {baseURL}/responses` (streaming) using the
  * provider's existing OpenAI SDK client. Returns the same result shape as
@@ -229,6 +304,7 @@ async function sendCompatResponsesOnce(provider, messages, useModel, tools, opts
   }
   const label = `${provider.name}:responses`;
   messages = await preparePdfTextForProvider(messages, provider);
+  assertOpenRouterStateless(provider, opts);
   const effortProjection = customEffortProjection(provider, useModel, messages, opts);
   const sessionCacheKey = customSessionCacheKey(provider, opts);
   const { input, previousResponseId, continuationResetReason } = toXaiResponsesInput(messages, opts.providerState, {
@@ -237,6 +313,7 @@ async function sendCompatResponsesOnce(provider, messages, useModel, tools, opts
     stateKey: COMPAT_RESPONSES_STATE_KEY,
     replayProvider,
     providerName: provider.name,
+    nativeLowering: supportsNativeResponsesItems(provider, opts),
     nativePdf: provider.nativePdf,
     // Opt-in: system prompts travel as top-level `instructions`, not input items.
     includeSystem: provider.config?.responsesSystemAsInstructions !== true,
@@ -254,8 +331,10 @@ async function sendCompatResponsesOnce(provider, messages, useModel, tools, opts
     sessionCacheKey,
   });
   // The session identity also travels as headers; caller headers win.
-  const headers = sessionCacheKey
-    ? { 'session-id': sessionCacheKey, 'x-client-request-id': sessionCacheKey, ...opts.requestHeaders }
+  // Custom routes only: a gateway route that opts into prompt_cache_key keeps
+  // its own headers.
+  const headers = isCustomProviderName(provider.name)
+    ? customSessionHeaders(provider, sessionCacheKey, opts.requestHeaders)
     : opts.requestHeaders;
 
   try {
@@ -287,7 +366,7 @@ async function sendCompatResponsesOnce(provider, messages, useModel, tools, opts
   const messageIndex = Array.isArray(messages) ? messages.length : 0;
   const encryptedReasoningHistory = [
     ...(Array.isArray(priorState?.encryptedReasoningHistory) ? priorState.encryptedReasoningHistory : []),
-    ...(reasoningItems.length ? [{ messageIndex, items: reasoningItems }] : []),
+    ...(reasoningItems.length ? [{ messageIndex, items: reasoningItems, owner: replayProvider }] : []),
   ];
   const searchSources = collectCompatResponseSearchSources(response);
   const usageSummary = usage ? responsesUsage(usage) : undefined;
@@ -296,6 +375,7 @@ async function sendCompatResponsesOnce(provider, messages, useModel, tools, opts
     model: response?.model || useModel,
     toolCalls: streamed.toolCalls,
     stopReason: streamed.stopReason || null,
+    ...(streamed.refusal ? { refusal: streamed.refusal } : {}),
     ...(streamed.stopReason === 'length' && (streamed.content || '').length > 0 ? { truncated: true } : {}),
     citations: searchSources.citations.length ? searchSources.citations : undefined,
     webSearchCalls: searchSources.webSearchCalls.length ? searchSources.webSearchCalls : undefined,
@@ -306,6 +386,7 @@ async function sendCompatResponsesOnce(provider, messages, useModel, tools, opts
         previousResponseId: null,
         responseId: response?.id || null,
         store: false,
+        owner: replayProvider,
         encryptedReasoningItems: reasoningItems,
         encryptedReasoningHistory,
         seenMessageCount: messageIndex,

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

@@ -21,13 +21,18 @@
 //     and jittered by jitterRatio (the advice of the excepted statuses stays raw).
 //   recycleDispatcherOn5xx — a retried 5xx rebuilds the shared HTTP pool.
 //   adviceAtLeastBackoff — the advice is a floor under the jittered backoff step.
+//   firstByteRetries — a header or first-chunk timeout (`timeoutPhase`) is
+//     retried at most this many times, each retry on a doubled window capped
+//     at PROVIDER_MAX_BEFORE_WARN_MS; other transient errors keep the ladder.
 // Every stop is provider-terminal: the profile's limits are final, so the
 // agent loop never re-runs a stopped or exhausted request (see
 // COMPAT_RETRY_POLICY).
 import { markProviderRecoveryExhausted } from './retry-classifier.mjs';
 import { retryAfterMsFromError } from './provider-error-kind.mjs';
 import { STREAM_TRANSPORTS, stampStreamOutcome } from './lib/stream-outcome.mjs';
-import { jitterDelayMs } from './retry-backoff.mjs';
+import { DEFAULT_BACKOFF_MS, DEFAULT_MAX_ATTEMPTS, jitterDelayMs } from './retry-backoff.mjs';
+import { PROVIDER_MAX_BEFORE_WARN_MS, firstBytePolicyBudget, firstByteWindowMs } from '../stall-policy.mjs';
+import { isFirstByteTimeout } from '../../../shared/provider-timeout-phase.mjs';
 
 const statusOf = (err) => Number(err?.httpStatus || err?.status || err?.response?.status || 0);
 
@@ -75,9 +80,11 @@ export const COMPAT_RETRY_PROFILES = Object.freeze({
   }),
   // server budget 8 retries (2s doubling to 30s,
   // ±10%), rate-limit budget 5 retries; 408, 409, 501 and 505 are terminal
-  // (425 stays retryable); a Retry-After beyond 300s is not waited out.
+  // (425 stays retryable); a Retry-After beyond 300s is not waited out. A
+  // first-byte timeout gets one longer retry instead of the whole ladder.
   'mimo-oauth': Object.freeze({
     maxAttempts: 9,
+    firstByteRetries: 1,
     backoffMs: [2000, 2000, 4000, 8000, 16000, 30000],
     retryJitterRatio: 0.1,
     statusRetryCaps: { 429: 5 },
@@ -112,6 +119,40 @@ export function compatRetryOptions(providerName) {
   };
 }
 
+// The provider's first-byte policy (see firstByteWindowMs) on a base window:
+// a profile's `firstByteRetries` caps first-byte retries on a doubling window;
+// without it every attempt keeps the base window.
+function compatFirstBytePolicy(providerName, baseMs) {
+  return {
+    timeoutMs: baseMs,
+    maxMs: PROVIDER_MAX_BEFORE_WARN_MS,
+    retries: COMPAT_RETRY_PROFILES[providerName]?.firstByteRetries ?? null,
+  };
+}
+
+/** First-byte window of an attempt after `timeouts` first-byte timeouts. */
+export function compatFirstByteWindowMs(providerName, baseMs, timeouts = 0) {
+  return firstByteWindowMs(compatFirstBytePolicy(providerName, baseMs), timeouts);
+}
+
+/**
+ * First-response budget of a chat profile that sets its own first-byte window
+ * (`firstByteTimeoutMs`, applied to the headers and to the first chunk): the
+ * worst case over the profile's whole ladder, where drops and 5xx use up
+ * attempts and backoff alongside the first-byte timeouts the profile permits
+ * (see firstBytePolicyBudget). Null for a profile on the shared window, which
+ * the agent watchdog's default already covers.
+ */
+export function compatFirstResponseBudget(providerName, chatProfile) {
+  const windowMs = Number(chatProfile?.firstByteTimeoutMs);
+  if (!(windowMs > 0)) return null;
+  const options = compatRetryOptions(providerName);
+  return firstBytePolicyBudget(compatFirstBytePolicy(providerName, windowMs), {
+    attempts: options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS,
+    backoffMs: options.backoffMs ?? DEFAULT_BACKOFF_MS,
+  });
+}
+
 function profileStops(profile, err, { attempt, elapsedMs }) {
   const status = statusOf(err);
   if (profile.terminalStatuses?.includes(status)) return true;
@@ -170,10 +211,11 @@ export function withCompatRetryProfile(providerName, attemptFn) {
   const profile = COMPAT_RETRY_PROFILES[providerName];
   if (!profile) return attemptFn;
   let emptyRetries = 0;
+  let firstByteTimeouts = 0;
   return async (ctx) => {
     const startedAt = Date.now();
     try {
-      const result = await attemptFn(ctx);
+      const result = await attemptFn({ ...ctx, firstByteTimeouts });
       if (profile.retryEmptyResponse && isEmptyNormalFinish(result)) {
         const bound = profile.retryEmptyResponse === true ? Infinity : profile.retryEmptyResponse;
         if (emptyRetries < bound) {
@@ -183,6 +225,12 @@ export function withCompatRetryProfile(providerName, attemptFn) {
       }
       return result;
     } catch (err) {
+      if (profile.firstByteRetries != null && isFirstByteTimeout(err) && !ctx?.signal?.aborted) {
+        firstByteTimeouts += 1;
+        if (firstByteTimeouts > profile.firstByteRetries) {
+          throw markProviderRecoveryExhausted(err, { owner: `${providerName}-first-byte`, terminal: true });
+        }
+      }
       if (profileStops(profile, err, { attempt: ctx?.attempt | 0, elapsedMs: Date.now() - startedAt })) {
         throw markProviderRecoveryExhausted(err, { owner: `${providerName}-retry-profile`, terminal: true });
       }

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

@@ -31,6 +31,7 @@ import {
   finalizeResponsesStream,
   unresolvedSalvageError,
 } from './openai-compat-responses-state.mjs';
+import { createRefusals, refusalResultFields } from './openai-ws-response-state/refusals.mjs';
 import { responsesUsage } from './openai-compat-response-normalization.mjs';
 import { noteAbandonedUsage } from '../../../shared/llm/usage-context.mjs';
 
@@ -151,7 +152,12 @@ export async function consumeCompatResponsesStream(
     throw stampOutcome(unresolved);
   }
   try {
-    return finalizeResponsesStream(state, { leakedCalls, parseResponsesToolCalls, responseOutputText, label });
+    const result = finalizeResponsesStream(state, { leakedCalls, parseResponsesToolCalls, responseOutputText, label });
+    // The terminal output bundle's refusal parts join the streamed ones (keyed
+    // by item id + content index, so copies of one part fold into one text).
+    state.refusals ||= createRefusals();
+    for (const item of result.response?.output || []) state.refusals.absorbMessage(item);
+    return { ...result, ...refusalResultFields(state.refusals, result.content) };
   } catch (err) {
     attachPartialState(err, state, leakedCalls);
     throw stampOutcome(err);

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

@@ -37,6 +37,8 @@ export function extractCompatCachedTokens(usage) {
     usage?.input_tokens_details?.cached_tokens,
     usage?.prompt_cache_hit_tokens,
     usage?.cached_prompt_text_tokens,
+    // Together reports it top-level; first-positive wins, so it never stacks on a nested count.
+    usage?.cached_tokens,
   ];
   for (const v of candidates) {
     const n = Number(v);