mixdog 1.2.2 → 1.2.4

package/src/runtime/agent/orchestrator/providers/openai-responses-payload-parity.fixture.json

@@ -0,0 +1,323 @@
+{
+ "openai|gpt-5.5": {
+  "model": "gpt-5.5",
+  "instructions": "Sys",
+  "input": [
+   {
+    "role": "user",
+    "content": [
+     {
+      "type": "input_text",
+      "text": "hi"
+     }
+    ]
+   }
+  ],
+  "tools": [
+   {
+    "type": "function",
+    "name": "read",
+    "description": "r",
+    "parameters": {
+     "type": "object",
+     "properties": {}
+    },
+    "strict": false
+   },
+   {
+    "type": "tool_search",
+    "execution": "client",
+    "description": "l",
+    "parameters": {
+     "type": "object",
+     "properties": {}
+    }
+   }
+  ],
+  "tool_choice": "auto",
+  "parallel_tool_calls": true,
+  "reasoning": {
+   "effort": "high",
+   "summary": "auto"
+  },
+  "store": false,
+  "stream": true,
+  "include": [
+   "reasoning.encrypted_content"
+  ],
+  "prompt_cache_key": "mixdog-openai-9d2848824f0e8f27c7",
+  "text": {
+   "verbosity": "low"
+  }
+ },
+ "openai|gpt-5.4": {
+  "model": "gpt-5.4",
+  "instructions": "Sys",
+  "input": [
+   {
+    "role": "user",
+    "content": [
+     {
+      "type": "input_text",
+      "text": "hi"
+     }
+    ]
+   }
+  ],
+  "tools": [
+   {
+    "type": "function",
+    "name": "read",
+    "description": "r",
+    "parameters": {
+     "type": "object",
+     "properties": {}
+    },
+    "strict": false
+   },
+   {
+    "type": "tool_search",
+    "execution": "client",
+    "description": "l",
+    "parameters": {
+     "type": "object",
+     "properties": {}
+    }
+   }
+  ],
+  "tool_choice": "auto",
+  "parallel_tool_calls": true,
+  "reasoning": {
+   "effort": "high",
+   "summary": "auto"
+  },
+  "store": false,
+  "stream": true,
+  "include": [
+   "reasoning.encrypted_content"
+  ],
+  "prompt_cache_key": "mixdog-openai-23e138e99281d0cc66",
+  "text": {
+   "verbosity": "low"
+  }
+ },
+ "openai|gpt-5.6-sol": {
+  "model": "gpt-5.6-sol",
+  "instructions": "Sys",
+  "input": [
+   {
+    "role": "user",
+    "content": [
+     {
+      "type": "input_text",
+      "text": "hi"
+     }
+    ]
+   }
+  ],
+  "tools": [
+   {
+    "type": "function",
+    "name": "read",
+    "description": "r",
+    "parameters": {
+     "type": "object",
+     "properties": {}
+    },
+    "strict": false
+   },
+   {
+    "type": "tool_search",
+    "execution": "client",
+    "description": "l",
+    "parameters": {
+     "type": "object",
+     "properties": {}
+    }
+   }
+  ],
+  "tool_choice": "auto",
+  "parallel_tool_calls": true,
+  "reasoning": {
+   "effort": "high",
+   "summary": "auto"
+  },
+  "store": false,
+  "stream": true,
+  "include": [
+   "reasoning.encrypted_content"
+  ],
+  "prompt_cache_key": "mixdog-openai-b61ada2751af9f3cdc",
+  "text": {
+   "verbosity": "low"
+  }
+ },
+ "openai-oauth|gpt-5.5": {
+  "model": "gpt-5.5",
+  "instructions": "Sys",
+  "input": [
+   {
+    "type": "message",
+    "role": "user",
+    "content": [
+     {
+      "type": "input_text",
+      "text": "hi"
+     }
+    ],
+    "internal_chat_message_metadata_passthrough": {}
+   }
+  ],
+  "tools": [
+   {
+    "type": "function",
+    "name": "read",
+    "description": "r",
+    "parameters": {
+     "type": "object",
+     "properties": {}
+    },
+    "strict": false
+   },
+   {
+    "type": "tool_search",
+    "execution": "client",
+    "description": "l",
+    "parameters": {
+     "type": "object",
+     "properties": {}
+    }
+   }
+  ],
+  "tool_choice": "auto",
+  "parallel_tool_calls": true,
+  "reasoning": {
+   "effort": "high",
+   "summary": "auto"
+  },
+  "store": false,
+  "stream": true,
+  "stream_options": {
+   "reasoning_summary_delivery": "sequential_cutoff"
+  },
+  "include": [
+   "reasoning.encrypted_content"
+  ],
+  "prompt_cache_key": "parity",
+  "text": {
+   "verbosity": "low"
+  }
+ },
+ "openai-oauth|gpt-5.4": {
+  "model": "gpt-5.4",
+  "instructions": "Sys",
+  "input": [
+   {
+    "type": "message",
+    "role": "user",
+    "content": [
+     {
+      "type": "input_text",
+      "text": "hi"
+     }
+    ],
+    "internal_chat_message_metadata_passthrough": {}
+   }
+  ],
+  "tools": [
+   {
+    "type": "function",
+    "name": "read",
+    "description": "r",
+    "parameters": {
+     "type": "object",
+     "properties": {}
+    },
+    "strict": false
+   },
+   {
+    "type": "tool_search",
+    "execution": "client",
+    "description": "l",
+    "parameters": {
+     "type": "object",
+     "properties": {}
+    }
+   }
+  ],
+  "tool_choice": "auto",
+  "parallel_tool_calls": true,
+  "reasoning": {
+   "effort": "high",
+   "summary": "auto"
+  },
+  "store": false,
+  "stream": true,
+  "stream_options": {
+   "reasoning_summary_delivery": "sequential_cutoff"
+  },
+  "include": [
+   "reasoning.encrypted_content"
+  ],
+  "prompt_cache_key": "parity",
+  "text": {
+   "verbosity": "low"
+  }
+ },
+ "openai-oauth|gpt-5.6-sol": {
+  "model": "gpt-5.6-sol",
+  "instructions": "Sys",
+  "input": [
+   {
+    "type": "message",
+    "role": "user",
+    "content": [
+     {
+      "type": "input_text",
+      "text": "hi"
+     }
+    ],
+    "internal_chat_message_metadata_passthrough": {}
+   }
+  ],
+  "tools": [
+   {
+    "type": "function",
+    "name": "read",
+    "description": "r",
+    "parameters": {
+     "type": "object",
+     "properties": {}
+    },
+    "strict": false
+   },
+   {
+    "type": "tool_search",
+    "execution": "client",
+    "description": "l",
+    "parameters": {
+     "type": "object",
+     "properties": {}
+    }
+   }
+  ],
+  "tool_choice": "auto",
+  "parallel_tool_calls": true,
+  "reasoning": {
+   "effort": "high",
+   "summary": "auto"
+  },
+  "store": false,
+  "stream": true,
+  "stream_options": {
+   "reasoning_summary_delivery": "sequential_cutoff"
+  },
+  "include": [
+   "reasoning.encrypted_content"
+  ],
+  "prompt_cache_key": "parity",
+  "text": {
+   "verbosity": "low"
+  }
+ }
+}

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

@@ -3,14 +3,22 @@ import { projectEffortConfiguration } from './effort-configuration.mjs';
 import { convertMessagesToResponsesInput } from './openai-responses-input.mjs';
 export { convertMessagesToResponsesInput } from './openai-responses-input.mjs';
 import { buildStableProviderPromptCacheKey, resolveProviderPromptCacheLane } from '../agent-runtime/cache-strategy.mjs';
+import { acceptedWireTools } from './lib/claude-bridge-schema.mjs';
 import { isResponsesFreeformTool, toResponsesCustomTool } from './custom-tool-wire.mjs';
 import { _envFlag } from './openai-oauth-http-sse.mjs';
 import { findCachedCodexModel } from './openai-oauth-catalog.mjs';
 import { resolveOpenAiServiceTier } from './openai-service-tier.mjs';
+import {
+  openAiPublicSupportsReasoning,
+  openAiPublicSupportsToolSearch,
+  openAiPublicSupportsVerbosity,
+} from './openai-model-capabilities.mjs';
 import { daybreakAccessPrograms } from '../../../shared/llm/openai-daybreak.mjs';
 
-export function toOpenAIResponsesTool(t) {
-  if (t?.name === 'load_tool' || t?.name === 'tool_search') {
+// `nativeToolSearch: false` (public API models before gpt-5.4) keeps load_tool
+// a plain function tool instead of the native tool_search tool.
+export function toOpenAIResponsesTool(t, { nativeToolSearch = true } = {}) {
+  if (nativeToolSearch && (t?.name === 'load_tool' || t?.name === 'tool_search')) {
     return {
       type: 'tool_search',
       execution: 'client',
@@ -95,8 +103,8 @@ function environmentContextItem(environmentText, promptCacheProvider) {
   };
 }
 
-function responsesInclude(opts) {
-  const include = ['reasoning.encrypted_content'];
+function responsesInclude(opts, reasoningCapable) {
+  const include = reasoningCapable ? ['reasoning.encrypted_content'] : [];
   for (const item of Array.isArray(opts.nativeInclude) ? opts.nativeInclude : []) {
     const value = String(item || '').trim();
     if (value && !include.includes(value)) include.push(value);
@@ -106,16 +114,30 @@ function responsesInclude(opts) {
 
 // `nativeTools` are server-hosted Responses tools (for example web_search)
 // and must be passed through without wrapping them as function tools.
-function responsesToolsList(tools, opts) {
-  const functionTools = tools?.length ? tools.map(toOpenAIResponsesTool) : [];
+function responsesToolsList(tools, opts, nativeToolSearch) {
+  // Freeform tools go out as grammar (no JSON schema); every other `parameters`
+  // must be a valid 2020-12 object schema -- lowered when it is not, left out
+  // and reported when it still is not.
+  const sendable = tools?.length
+    ? acceptedWireTools(
+        tools,
+        'openai',
+        opts.onToolExcluded,
+        `[${opts.promptCacheProvider || 'openai-oauth'}] tool`,
+        isResponsesFreeformTool
+      )
+    : [];
+  const functionTools = sendable.map((t) => toOpenAIResponsesTool(t, { nativeToolSearch }));
   const nativeTools = Array.isArray(opts.nativeTools) ? opts.nativeTools.filter((t) => t && typeof t === 'object') : [];
   return functionTools.length || nativeTools.length ? [...nativeTools, ...functionTools] : null;
 }
 
-function requestedMaxOutputTokens(opts) {
+// The public API honors an explicit caller limit; the OAuth/Codex backend only
+// receives it behind MIXDOG_OPENAI_OAUTH_SEND_MAX_OUTPUT_TOKENS.
+function requestedMaxOutputTokens(opts, promptCacheProvider) {
   const maxOutputTokens = Number(opts.maxOutputTokens ?? opts.outputTokens ?? opts.max_output_tokens);
   const send =
-    _envFlag('MIXDOG_OPENAI_OAUTH_SEND_MAX_OUTPUT_TOKENS', false) &&
+    (promptCacheProvider === 'openai' || _envFlag('MIXDOG_OPENAI_OAUTH_SEND_MAX_OUTPUT_TOKENS', false)) &&
     Number.isFinite(maxOutputTokens) &&
     maxOutputTokens > 0;
   return send ? Math.floor(maxOutputTokens) : null;
@@ -149,6 +171,11 @@ function replaysEncryptedReasoning(opts, promptCacheProvider) {
 // WIRE-VERIFIED (40 response.create captures, 2026-07-03): the wire
 // carries reasoning as {"effort":"..."} with NO summary field on gpt-5.5.
 function responsesReasoningFields(model, effortProjection, opts, promptCacheProvider) {
+  // Public API models without reasoning get no reasoning field at all; the
+  // Codex route keeps its defaults.
+  if (promptCacheProvider === 'openai' && !openAiPublicSupportsReasoning(model)) {
+    return { reasoning: null, streamOptions: null };
+  }
   const supportsReasoningSummary = _codexModelSupportsReasoningSummaries(model);
   return {
     reasoning: {
@@ -197,29 +224,36 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
   const opts = sendOpts || {};
   const promptCacheProvider = opts.promptCacheProvider || 'openai-oauth';
   const effortProjection = projectEffortConfiguration(messages, promptCacheProvider, model, opts);
+  // Public API capability gates per model (openai-model-capabilities.mjs);
+  // the Codex route keeps its own defaults.
+  const publicApi = promptCacheProvider === 'openai';
+  const reasoningCapable = !publicApi || openAiPublicSupportsReasoning(model);
+  const nativeToolSearch = !publicApi || openAiPublicSupportsToolSearch(model);
   const input = convertMessagesToResponsesInput(messages, {
     effortProjection,
     providerState: opts.providerState,
     model,
     nativeToolSearchProvider: promptCacheProvider,
-    replayEncryptedReasoning: replaysEncryptedReasoning(opts, promptCacheProvider),
+    nativeToolSearch,
+    replayEncryptedReasoning: reasoningCapable && replaysEncryptedReasoning(opts, promptCacheProvider),
     codexWireParity: promptCacheProvider === 'openai-oauth',
   });
   if (environmentText) input.unshift(environmentContextItem(environmentText, promptCacheProvider));
   const { reasoning, streamOptions } = responsesReasoningFields(model, effortProjection, opts, promptCacheProvider);
   const serviceTier = requestedServiceTier(model, opts);
-  const maxOutputTokens = requestedMaxOutputTokens(opts);
+  const maxOutputTokens = requestedMaxOutputTokens(opts, promptCacheProvider);
   const toolChoice = opts.toolChoice || 'auto';
-  const toolsList = responsesToolsList(tools, opts);
+  const toolsList = responsesToolsList(tools, opts, nativeToolSearch);
+  const include = responsesInclude(opts, reasoningCapable);
   const promptCacheKey = responsesPromptCacheKey(promptCacheProvider, opts, {
     model,
     instructions,
     toolsList,
-    effort: reasoning.effort,
+    effort: reasoning ? reasoning.effort : undefined,
     serviceTier,
     toolChoice,
   });
-  const verbosity = requestedVerbosity(opts);
+  const verbosity = !publicApi || openAiPublicSupportsVerbosity(model) ? requestedVerbosity(opts) : null;
   // Daybreak Blue rides on the ChatGPT route only, and only for a model that
   // accepts it; the server still decides entitlement.
   const accessPrograms =
@@ -245,14 +279,14 @@ export function buildRequestBody(messages, model, tools, sendOpts) {
     ...(toolsList ? { tools: toolsList } : {}),
     tool_choice: toolChoice,
     parallel_tool_calls: true,
-    reasoning,
+    ...(reasoning ? { reasoning } : {}),
     store: process.env.MIXDOG_OAI_STORE === 'true',
     stream: true,
     ...(streamOptions ? { stream_options: streamOptions } : {}),
-    include: responsesInclude(opts),
+    ...(include.length ? { include } : {}),
     ...(serviceTier ? { service_tier: serviceTier } : {}),
     prompt_cache_key: promptCacheKey,
-    text: { verbosity },
+    ...(verbosity ? { text: { verbosity } } : {}),
     ...(accessPrograms ? { access_programs: accessPrograms } : {}),
     ...(maxOutputTokens ? { max_output_tokens: maxOutputTokens } : {}),
   };

package/src/runtime/agent/orchestrator/providers/openai-ws-delta.mjs

@@ -279,7 +279,7 @@ function _stripResponseItemsFromHead(items, responseItems) {
 // Official OpenAI Responses WebSocket guide: response.create WS frames mirror
 // the Responses body EXCEPT the transport-only fields `stream`/`background`,
 // which the socket carries implicitly and the guide says to omit. This set is
-// stripped from a frame (any build shape) only when omitTransportFields is on.
+// always stripped from a frame (any build shape).
 const TRANSPORT_ONLY_FRAME_FIELDS = new Set(['stream', 'background']);
 
 // Canonical response.create frame builder. Every WS send (main full-frame
@@ -293,14 +293,9 @@ const TRANSPORT_ONLY_FRAME_FIELDS = new Set(['stream', 'background']);
 // response, so dropping them here strips the system/lead prompt from every
 // continuation turn. Only an empty instructions string is omitted.
 // Full frames pass the body unchanged and keep every key in place.
-// omitTransportFields is used by wire-parity helpers to drop stream/background.
-export function _buildResponseCreateFrame(
-  body,
-  { previousResponseId = null, inputOverride, omitTransportFields = false } = {}
-) {
+export function _buildResponseCreateFrame(body, { previousResponseId = null, inputOverride } = {}) {
   const src = body && typeof body === 'object' ? body : {};
   if (previousResponseId == null && inputOverride === undefined) {
-    if (!omitTransportFields) return { type: 'response.create', ...src };
     const frame = { type: 'response.create' };
     for (const key of Object.keys(src)) {
       if (TRANSPORT_ONLY_FRAME_FIELDS.has(key)) continue;
@@ -310,7 +305,7 @@ export function _buildResponseCreateFrame(
   }
   const frame = { type: 'response.create' };
   for (const key of Object.keys(src)) {
-    if (omitTransportFields && TRANSPORT_ONLY_FRAME_FIELDS.has(key)) continue;
+    if (TRANSPORT_ONLY_FRAME_FIELDS.has(key)) continue;
     if (key === 'instructions') {
       const instr = src.instructions;
       if (typeof instr === 'string' && instr.length) frame.instructions = instr;
@@ -366,17 +361,10 @@ export function _computeDelta({ entry, body, traceProvider }) {
   if (!entry?.lastRequestSansInput || !entry.lastResponseId) {
     return { mode: 'full', reason: 'no_anchor', frame: buildFrame(body) };
   }
-  // Public OpenAI resolves previous_response_id out of its response STORE, so
-  // an anchor only exists when the anchored response was stored. store:false
-  // there — e.g. an explicit MIXDOG_OAI_STORE=0 opt-out on the openai-direct
-  // provider — makes a continuation frame fail with
-  // previous_response_not_found, so the opt-out degrades to full frames.
-  // openai-oauth/Codex (per-WS-session server state) and xAI (in-connection
-  // ZDR continuation with encrypted reasoning) both anchor without the store
-  // and are deliberately excluded from this gate.
-  if (traceProvider === 'openai-direct' && body?.store !== true) {
-    return { mode: 'full', reason: 'store_disabled', frame: buildFrame(body) };
-  }
+  // WebSocket mode keeps the latest response in a connection-local cache, so
+  // previous_response_id continues on the same socket even with store:false.
+  // If the server no longer has the anchor (previous_response_not_found), the
+  // caller recovers with a full-context frame.
   if (!deltaForce && !deltaRefs && !entry.turnState) {
     return { mode: 'full', reason: 'delta_missing_turn_state', frame: buildFrame(body) };
   }

package/src/runtime/agent/orchestrator/providers/openai-ws-response-state/refusals.mjs

@@ -0,0 +1,60 @@
+// Refusal content of one Responses stream. The model's refusal arrives as
+// `response.refusal.delta` / `response.refusal.done` and as a
+// `{type:'refusal', refusal}` content part of the message item
+// (output_item.done and the terminal output bundle). Parts are keyed by item
+// id + content index so the streamed, item-done and terminal copies of one
+// part fold into one text; a full (done / final-part) text replaces the
+// accumulated deltas. Shared by the WS and HTTP/SSE collectors.
+export function createRefusals() {
+  const parts = new Map();
+  const keyOf = (itemId, contentIndex) => `${itemId || ''}:${Number.isInteger(contentIndex) ? contentIndex : 0}`;
+
+  return {
+    /** response.refusal.delta */
+    delta(event) {
+      if (typeof event?.delta !== 'string') return;
+      const key = keyOf(event.item_id, event.content_index);
+      parts.set(key, (parts.get(key) || '') + event.delta);
+    },
+    /** response.refusal.done */
+    done(event) {
+      if (typeof event?.refusal !== 'string') return;
+      parts.set(keyOf(event.item_id, event.content_index), event.refusal);
+    },
+    /** A message item's refusal parts. Returns whether it carried any. */
+    absorbMessage(item) {
+      if (item?.type !== 'message' || !Array.isArray(item.content)) return false;
+      let found = false;
+      item.content.forEach((part, index) => {
+        if (part?.type !== 'refusal' || typeof part.refusal !== 'string') return;
+        found = true;
+        // An id-less item cannot be matched to its streamed copy; the
+        // streamed text already stands for it.
+        if (!item.id && parts.size > 0) return;
+        parts.set(keyOf(item.id, index), part.refusal);
+      });
+      return found;
+    },
+    get seen() {
+      return parts.size > 0;
+    },
+    get text() {
+      return [...parts.values()].filter(Boolean).join('\n');
+    },
+  };
+}
+
+/** The typed stop reason of a refused turn (read by the agent loop). */
+export const REFUSAL_STOP_REASON = 'refusal';
+
+/** Result fields for a refused turn — the shared result shape:
+ *    stopReason: REFUSAL_STOP_REASON
+ *    refusal:    the refusal text (joined parts; may be '')
+ *    content:    the output_text, or the refusal text when there was none
+ *  so a refusal never reads as an empty successful answer. Empty object when
+ *  the response carried no refusal. */
+export function refusalResultFields(refusals, content) {
+  if (!refusals.seen) return {};
+  const refusal = refusals.text;
+  return { content: content || refusal, refusal, stopReason: REFUSAL_STOP_REASON };
+}