mixdog 1.2.1 → 1.2.3

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

@@ -1,6 +1,7 @@
 // Transcript lowering is independent of request/turn metadata. A retained
 // message must have the same wire representation in every subsequent request.
 import { providerReplayItems } from './lib/provider-replay.mjs';
+import { responsesEffortUpdates } from './effort-configuration.mjs';
 import { ensureResponsesCallOutputs } from './lib/wire-pairing.mjs';
 import { normalizeContentForOpenAIResponses, splitToolContentForOpenAIResponses } from './media-normalization.mjs';
 import {
@@ -8,8 +9,30 @@ import {
   isCustomToolCallRecord,
   nativeToolSearchCallInput,
   nativeToolSearchOutputInput,
+  toolCallNamespace,
 } from './custom-tool-wire.mjs';
 
+// A call record that carries a Responses namespace replays it beside `name`.
+const namespaceField = (call) => {
+  const namespace = toolCallNamespace(call);
+  return namespace ? { namespace } : {};
+};
+
+// A replayed native tool_search item for a model that has no tool_search tool:
+// a client call becomes the load_tool function call (its output is lowered
+// from the tool message), server-executed calls and outputs are dropped.
+function withoutNativeToolSearch(item) {
+  if (item?.type === 'tool_search_output') return null;
+  if (item?.type !== 'tool_search_call') return item;
+  if (item.execution === 'server' || !item.call_id) return null;
+  return {
+    type: 'function_call',
+    call_id: item.call_id,
+    name: 'load_tool',
+    arguments: typeof item.arguments === 'string' ? item.arguments : JSON.stringify(item.arguments ?? {}),
+  };
+}
+
 /**
  * One tool result → its wire item. Which item depends on how the call was
  * lowered: a custom tool answers with custom_tool_call_output, a native
@@ -17,16 +40,13 @@ import {
  * media, since that item carries no text field), everything else with
  * function_call_output.
  */
-function pushToolResult(
-  m,
-  { out, pendingToolMedia, pendingToolLoads, customToolCallNameById, nativeSearchCalls, opts }
-) {
-  const { output, mediaContent } = splitToolContentForOpenAIResponses(m.content);
-  if (customToolCallNameById.has(m.toolCallId || '')) {
+function pushToolResult(m, { out, pendingToolMedia, pendingToolLoads, customToolCallIds, nativeSearchCalls, opts }) {
+  const { output, mediaContent } = (opts.splitToolContent || splitToolContentForOpenAIResponses)(m.content);
+  if (customToolCallIds.has(m.toolCallId || '')) {
+    // Documented custom_tool_call_output shape: call_id + output (+ id).
     out.push({
       type: 'custom_tool_call_output',
       call_id: m.toolCallId || '',
-      name: customToolCallNameById.get(m.toolCallId || '') || undefined,
       output,
     });
     if (mediaContent) pendingToolMedia.push(...mediaContent);
@@ -53,7 +73,8 @@ function pushToolResult(
   // A function result (e.g. Skill) cannot carry schemas. Tools it already
   // loaded ride a runtime load_tool pair emitted after the batch's outputs;
   // only a result from another native family falls back to a load hint.
-  const loadedNames = (m.nativeToolSearch?.openaiTools || []).map((tool) => tool.name);
+  const loadedNames =
+    opts.nativeToolSearch === false ? [] : (m.nativeToolSearch?.openaiTools || []).map((tool) => tool.name);
   const loadOutput = loadedNames.length
     ? nativeToolSearchOutputInput(m, opts.nativeToolSearchProvider || 'openai-oauth')
     : null;
@@ -84,18 +105,21 @@ function pushToolResult(
  * lowered as a custom tool or a native search call so the matching result
  * lowers the same way.
  */
-function pushAssistantToolCalls(toolCalls, { out, customToolCallNameById, nativeSearchCalls }) {
+function pushAssistantToolCalls(toolCalls, { out, customToolCallIds, nativeSearchCalls, nativeToolSearch }) {
   for (const tc of toolCalls) {
-    const nativeSearchCall = nativeToolSearchCallInput(tc);
+    // A model without native tool_search replays its load_tool call as the
+    // plain function call it was declared as.
+    const nativeSearchCall = nativeToolSearch ? nativeToolSearchCallInput(tc) : null;
     if (nativeSearchCall) {
       nativeSearchCalls.set(tc.id, nativeSearchCall);
       out.push(nativeSearchCall);
     } else if (isCustomToolCallRecord(tc)) {
-      if (tc.id) customToolCallNameById.set(tc.id, tc.name || '');
+      if (tc.id) customToolCallIds.add(tc.id);
       out.push({
         type: 'custom_tool_call',
         call_id: tc.id,
         name: tc.name,
+        ...namespaceField(tc),
         input: customToolInputFromArguments(tc.name, tc.arguments),
       });
     } else {
@@ -103,20 +127,41 @@ function pushAssistantToolCalls(toolCalls, { out, customToolCallNameById, native
         type: 'function_call',
         call_id: tc.id,
         name: tc.name === 'tool_search' ? 'load_tool' : tc.name,
+        ...namespaceField(tc),
         arguments: JSON.stringify(tc.arguments),
       });
     }
   }
 }
 
+/**
+ * Messages → Responses input items, native-aware. Defaults are the first-party
+ * OpenAI lowering. Gateways that speak the same item types opt in through:
+ *  - `replayProvider`: the providerReplay owner tag accepted for ordered
+ *    replay (default 'openai-responses'); any other owner is never replayed.
+ *  - `replayOwnedReasoning`: keep reasoning items of an accepted ordered
+ *    replay even when `replayEncryptedReasoning` (flattened message
+ *    reasoning) is off.
+ *  - `reasoningByMessageIndex`: same-owner reasoning from provider state,
+ *    injected before the message at that index (or after the last one).
+ *  - `includeSystem`, `nativePdf`, `splitToolContent`, `startIndex`: the
+ *    gateway's system/media/continuation handling.
+ */
 export function convertMessagesToResponsesInput(messages, opts = {}) {
   const out = [];
   const pendingToolMedia = [];
   const pendingToolLoads = [];
-  const customToolCallNameById = new Map();
+  const customToolCallIds = new Set();
   const nativeSearchCalls = new Map();
   const replayEncryptedReasoning = opts.replayEncryptedReasoning === true;
   const wireParity = opts.codexWireParity === true;
+  const replayOwner = opts.replayProvider || 'openai-responses';
+  const replayOwnedReasoning = opts.replayOwnedReasoning ?? replayEncryptedReasoning;
+  // Native tool_search is a per-model capability (gpt-5.4 and later on the
+  // public API); every other caller keeps it.
+  const nativeToolSearch = opts.nativeToolSearch !== false;
+  const nativePdf = opts.nativePdf;
+  const contentOpts = (role) => (nativePdf === undefined ? { role } : { role, nativePdf });
   const wireMessage = (role, content, phase) => ({
     ...(wireParity ? { type: 'message' } : {}),
     role,
@@ -156,33 +201,29 @@ export function convertMessagesToResponsesInput(messages, opts = {}) {
     if (!pendingToolMedia.length) return;
     out.push(wireMessage('user', pendingToolMedia.splice(0)));
   };
-  // An update on a tool result applies after its whole batch; one on a user
-  // message before it. Adjacent updates are rejected, so a batch update that
-  // a user message directly follows yields to that message's own.
-  let afterBatch = null;
-  for (const m of messages) {
-    if (!m || m.role === 'system') continue;
-    const changedEffort = opts.effortProjection?.updates.get(m);
+  const effortUpdates = responsesEffortUpdates(opts.effortProjection);
+  for (let messageIndex = opts.startIndex || 0; messageIndex < messages.length; messageIndex += 1) {
+    const m = messages[messageIndex];
+    if (!m || (m.role === 'system' && opts.includeSystem !== true)) continue;
+    const updates = effortUpdates.before(m);
     if (m.role === 'tool') {
-      pushToolResult(m, { out, pendingToolMedia, pendingToolLoads, customToolCallNameById, nativeSearchCalls, opts });
-      if (changedEffort) afterBatch = changedEffort;
+      pushToolResult(m, { out, pendingToolMedia, pendingToolLoads, customToolCallIds, nativeSearchCalls, opts });
       continue;
     }
     flushToolMedia();
-    if (changedEffort || afterBatch) out.push({ type: 'configuration_update', reasoning: { effort: changedEffort || afterBatch } });
-    afterBatch = null;
+    out.push(...updates);
     // Preserve original assistant phases and item order even when encrypted
     // reasoning is explicitly disabled. Never replay another provider's data.
     const orderedReplay =
       m.role === 'assistant'
-        ? providerReplayItems(m, 'openai-responses')?.filter(
-            (item) => replayEncryptedReasoning || item?.type !== 'reasoning'
-          )
+        ? providerReplayItems(m, replayOwner)?.filter((item) => replayOwnedReasoning || item?.type !== 'reasoning')
         : undefined;
     if (orderedReplay?.length) {
-      for (const item of orderedReplay) {
+      for (const replayItem of orderedReplay) {
+        const item = nativeToolSearch ? replayItem : withoutNativeToolSearch(replayItem);
+        if (!item) continue;
         if (item?.type === 'custom_tool_call' && item.call_id) {
-          customToolCallNameById.set(item.call_id, item.name || '');
+          customToolCallIds.add(item.call_id);
         }
         if (item?.type === 'tool_search_call' && item.call_id) {
           nativeSearchCalls.set(item.call_id, item);
@@ -191,28 +232,30 @@ export function convertMessagesToResponsesInput(messages, opts = {}) {
       }
       continue;
     }
+    if (opts.reasoningByMessageIndex?.has(messageIndex)) out.push(...opts.reasoningByMessageIndex.get(messageIndex));
     pushReasoningItems(m, 'before');
     if (m.role === 'assistant' && Array.isArray(m.toolCalls) && m.toolCalls.length) {
       // Legacy sessions may have only flattened messages and reasoning.
       if (m.content)
         out.push(
-          wireMessage('assistant', normalizeContentForOpenAIResponses(m.content, { role: 'assistant' }), m.phase)
+          wireMessage('assistant', normalizeContentForOpenAIResponses(m.content, contentOpts('assistant')), m.phase)
         );
       pushReasoningItems(m, 'after');
-      pushAssistantToolCalls(m.toolCalls, { out, customToolCallNameById, nativeSearchCalls });
+      pushAssistantToolCalls(m.toolCalls, { out, customToolCallIds, nativeSearchCalls, nativeToolSearch });
       continue;
     }
     out.push(
       wireMessage(
-        m.role === 'assistant' ? 'assistant' : 'user',
-        normalizeContentForOpenAIResponses(m.content, { role: m.role }),
+        m.role === 'assistant' || m.role === 'system' ? m.role : 'user',
+        normalizeContentForOpenAIResponses(m.role === 'system' ? m.content || '' : m.content, contentOpts(m.role)),
         m.phase
       )
     );
     pushReasoningItems(m, 'after');
   }
   flushToolMedia();
-  if (afterBatch) out.push({ type: 'configuration_update', reasoning: { effort: afterBatch } });
+  if (opts.reasoningByMessageIndex?.has(messages.length)) out.push(...opts.reasoningByMessageIndex.get(messages.length));
+  out.push(...effortUpdates.end());
   // Wire-level pairing guard: replay envelopes can carry a call whose
   // result never committed (cancel/abort). The provider hard-rejects the
   // unpaired call, so synthesize the missing outputs here.

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,24 @@ 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 +165,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 +218,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 +273,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 } : {}),
   };