@iislee/opencodex 2.31.0 → 2.35.0

package/src/adapters/openai-chat.ts

@@ -26,6 +26,11 @@ import {
 } from "../providers/fastwire";
 import { openaiChatCompletionsUrl } from "./openai-chat-url";
 import { stripResponsesOnlyEncryptedMarker } from "./responses-tool-schema";
+import {
+  isXaiSchemaTarget,
+  lookupLocalJsonPointer,
+  normalizeXaiToolParameters,
+} from "./xai-tool-schema";
 import {
   isTranslatorBudgetExceededError,
   retainTranslatedEventBatch,
@@ -922,11 +927,50 @@ function shouldSanitizeZenToolParameters(provider: OcxProviderConfig): boolean {
     || baseUrl === "https://opencode.ai/zen/go/v1";
 }
 
-function isXaiSchemaTarget(provider: OcxProviderConfig): boolean {
+/** Azure Model Router (and Gemini-in-the-pool) 400s Codex MCP schemas whose root is a union. */
+const AZURE_CHAT_FORBIDDEN_ROOT_KEYS = ["oneOf", "anyOf", "allOf", "enum", "const", "not"] as const;
+
+function isAzureOpenAiChatTarget(provider: OcxProviderConfig): boolean {
+  try {
+    const host = new URL(provider.baseUrl).hostname.toLowerCase();
+    return host.endsWith(".openai.azure.com")
+      || host.endsWith(".cognitiveservices.azure.com")
+      || host.endsWith(".services.ai.azure.com")
+      || host.endsWith(".ai.azure.com");
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Azure Foundry Model Router validates every function schema against the strictest model in
+ * the pool (Gemini-shaped): root must be {type:"object"} with no oneOf/anyOf/allOf/enum/
+ * const/not. Codex App MCP tools such as mcp__codex_app__automation_update ship a root
+ * union, which 400s the whole turn. Flatten like Zen, then strip leftover forbidden keys.
+ */
+function sanitizeAzureChatToolParameters(parameters: unknown): Record<string, unknown> {
+  const root = ensureZenRootObjectSchema(parameters);
+  for (const key of AZURE_CHAT_FORBIDDEN_ROOT_KEYS) delete root[key];
+  root.type = "object";
+  if (!root.properties || typeof root.properties !== "object" || Array.isArray(root.properties)) {
+    root.properties = {};
+  }
+  return root;
+}
+
+// Moonshot validates function schemas against a draft-07 reading of `$ref`, where the
+// keyword stands alone and siblings are ignored. It rejects the whole request rather
+// than ignoring them: "not a valid moonshot flavored json schema ... when using $ref,
+// type should be defined in the referenced schema instead of the parent schema".
+const MOONSHOT_SCHEMA_HOSTNAMES = new Set([
+  "api.kimi.com",
+  "api.moonshot.ai",
+  "api.moonshot.cn",
+]);
+
+function isMoonshotSchemaTarget(provider: OcxProviderConfig): boolean {
   try {
-    // Public api.x.ai accepts native root object unions. Only the Grok CLI proxy
-    // 400s on a root oneOf/anyOf, so flattening/omitting is scoped to that host.
-    return new URL(provider.baseUrl).hostname === "cli-chat-proxy.grok.com";
+    return MOONSHOT_SCHEMA_HOSTNAMES.has(new URL(provider.baseUrl).hostname);
   } catch {
     return false;
   }
@@ -964,263 +1008,248 @@ function isXaiObjectSchema(value: unknown): value is Record<string, unknown> {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 
-function stringRequiredFields(value: unknown): string[] {
-  return Array.isArray(value)
-    ? value.filter((item): item is string => typeof item === "string")
-    : [];
+/**
+ * JSON Schema 2020-12 makes `$ref` an in-place applicator: siblings stay in force and are
+ * combined with the referenced schema. Moonshot enforces the older draft-07 reading where
+ * `$ref` must stand alone, and 400s the entire request when a node carries both. Codex's own
+ * deferred tool catalog emits exactly that shape (zod-to-json-schema deduplicates into
+ * `$defs.__schema*` nodes that keep `type`/`minLength`/`format` beside the `$ref`), so the
+ * schema is not something a user can fix from configuration — see issue #2673.
+ *
+ * Inline the referenced schema underneath the node's own keywords, which is what 2020-12 says
+ * the node means, then drop `$ref`. Constraints reach the model instead of being stripped.
+ * The `$defs` bag is preserved: a bare `$ref` (no siblings) is already legal for Moonshot and
+ * is left pointing at its definition rather than expanded, which keeps recursive schemas finite.
+ */
+function moonshotRefTargetKeys(node: Record<string, unknown>): string[] {
+  return Object.keys(node).filter(key => key !== "$ref");
 }
 
-/** Variant keys the merger can keep. Anything else is refused, not silently dropped. */
-const XAI_VARIANT_MERGE_KEYS = new Set([
-  "type",
-  "properties",
-  "required",
-  "additionalProperties",
-  "description",
-  "title",
-  "$comment",
-  "$defs",
-  "definitions",
-]);
+/**
+ * Inlining duplicates the target, so a schema referencing one large definition from many
+ * sibling-carrying nodes can multiply. Bound the total expansions and fall back to a bare
+ * `$ref` once the budget is spent: still valid for Moonshot, just without the node's own
+ * narrowing keywords. Mirrors the node budget in google-tool-schema.ts.
+ */
+const MOONSHOT_MAX_REF_EXPANSIONS = 512;
 
-function decodeJsonPointerToken(token: string): string {
-  return token.replace(/~1/g, "/").replace(/~0/g, "~");
-}
+/**
+ * Expansion count alone does not bound the walk: a deeply nested ref-free schema, or one
+ * large definition repeated across many nodes, still recurses to exhaustion or amplifies the
+ * emitted output. Depth and node budgets close both, and mirror google-tool-schema.ts.
+ */
+const MOONSHOT_MAX_SCHEMA_DEPTH = 64;
+const MOONSHOT_MAX_SCHEMA_NODES = 4_096;
 
-function lookupLocalJsonPointer(root: unknown, ref: string): unknown {
-  if (ref === "#" || ref === "#/") return root;
-  if (!ref.startsWith("#/")) return undefined;
-  let current: unknown = root;
-  for (const token of ref.slice(2).split("/").map(decodeJsonPointerToken)) {
-    if (!isXaiObjectSchema(current) || !Object.hasOwn(current, token)) return undefined;
-    current = current[token];
+/**
+ * Assertion keywords whose meaning under a `$ref` is CONJUNCTION, not replacement. A node
+ * carrying `required: ["b"]` beside a target requiring `["a"]` means both are required;
+ * letting the sibling win emitted a schema that no longer described the tool.
+ */
+function unionRequired(target: unknown, sibling: unknown): unknown {
+  if (!Array.isArray(target) || !Array.isArray(sibling)) return sibling;
+  const seen = new Set<unknown>();
+  const out: unknown[] = [];
+  for (const name of [...target, ...sibling]) {
+    if (seen.has(name)) continue;
+    seen.add(name);
+    out.push(name);
   }
-  return current;
+  return out;
 }
 
-/** Resolve local `#/` `$ref`s. Unresolvable or cyclic refs return undefined. */
-function resolveXaiSchemaRefs(
-  schema: unknown,
-  root: Record<string, unknown>,
-  stack: Set<string> = new Set(),
-): unknown | undefined {
-  if (!isXaiObjectSchema(schema)) return schema;
-  if (typeof schema.$ref === "string") {
-    const ref = schema.$ref;
-    if (stack.has(ref)) return undefined;
-    const target = lookupLocalJsonPointer(root, ref);
-    if (target === undefined) return undefined;
-    stack.add(ref);
-    const resolvedTarget = resolveXaiSchemaRefs(target, root, stack);
-    stack.delete(ref);
-    if (resolvedTarget === undefined) return undefined;
-    const rest: Record<string, unknown> = { ...schema };
-    delete rest.$ref;
-    if (Object.keys(rest).length === 0) return resolvedTarget;
-    const resolvedRest = resolveXaiSchemaRefs(rest, root, stack);
-    if (resolvedRest === undefined || !isXaiObjectSchema(resolvedTarget) || !isXaiObjectSchema(resolvedRest)) {
-      return undefined;
-    }
-    return composeXaiObjectSchemas(resolvedTarget, resolvedRest);
-  }
-
-  const resolved: Record<string, unknown> = {};
-  for (const [key, value] of Object.entries(schema)) {
-    if ((key === "oneOf" || key === "anyOf") && Array.isArray(value)) {
-      const items: unknown[] = [];
-      for (const item of value) {
-        const next = resolveXaiSchemaRefs(item, root, stack);
-        if (next === undefined) return undefined;
-        items.push(next);
-      }
-      resolved[key] = items;
-      continue;
-    }
-    if (key === "properties" && isXaiObjectSchema(value)) {
-      const properties: Record<string, unknown> = {};
-      for (const [name, property] of Object.entries(value)) {
-        const next = resolveXaiSchemaRefs(property, root, stack);
-        if (next === undefined) return undefined;
-        properties[name] = next;
-      }
-      resolved[key] = properties;
-      continue;
-    }
-    resolved[key] = value;
-  }
-  return resolved;
-}
+/**
+ * Keywords whose values are DATA, not schemas.
+ *
+ * Recursing into them rewrote user data: an `enum` listing a literal object that happens
+ * to carry a `"$ref"` string had that key stripped as if it were a schema reference, so a
+ * value the tool declared as legal silently changed shape. These are copied through.
+ */
+const MOONSHOT_DATA_VALUED_KEYWORDS = new Set(["enum", "const", "default", "examples"]);
 
-function xaiVariantIsConcreteObject(variant: Record<string, unknown>): boolean {
-  if (variant.type !== undefined && variant.type !== "object") return false;
-  return Object.keys(variant).every(key => XAI_VARIANT_MERGE_KEYS.has(key));
-}
+/**
+ * Numeric assertions whose intersection is a bound, and which direction tightens.
+ *
+ * `$ref` under 2020-12 is an in-place applicator: the node and its target BOTH apply, so
+ * the emitted schema must be their INTERSECTION. The previous code overwrote the target
+ * with the node and called that "the narrower reading", which holds only when the node
+ * happens to be narrower. A node declaring `minLength: 1` beside a target declaring
+ * `minLength: 5` shipped `minLength: 1` - a contract weaker than either side asked for,
+ * emitted silently, which is the same failure mode the `required` composition fixed for
+ * set-valued keywords.
+ *
+ * "max" means the surviving value is the larger of the two (lower bounds), "min" the
+ * smaller (upper bounds). A keyword absent from this table keeps the overwrite: for
+ * `type`, `format`, `description` and friends there is no ordering to intersect along,
+ * and the node is the more specific statement.
+ */
+const MOONSHOT_BOUND_KEYWORDS: Record<string, "max" | "min"> = {
+  minLength: "max",
+  minItems: "max",
+  minProperties: "max",
+  minimum: "max",
+  exclusiveMinimum: "max",
+  maxLength: "min",
+  maxItems: "min",
+  maxProperties: "min",
+  maximum: "min",
+  exclusiveMaximum: "min",
+};
 
-function variantProperties(variant: Record<string, unknown>): Record<string, unknown> {
-  return isXaiObjectSchema(variant.properties) ? variant.properties : {};
+/**
+ * Intersect one numeric bound. Either side being absent or non-finite yields the other,
+ * because an unstated bound constrains nothing - returning `undefined` there would drop
+ * a constraint the remaining side genuinely made.
+ */
+function intersectBound(target: unknown, sibling: unknown, direction: "max" | "min"): unknown {
+  const a = typeof target === "number" && Number.isFinite(target) ? target : null;
+  const b = typeof sibling === "number" && Number.isFinite(sibling) ? sibling : null;
+  if (a === null) return b === null ? sibling : sibling;
+  if (b === null) return target;
+  return direction === "max" ? Math.max(a, b) : Math.min(a, b);
 }
 
 /**
- * Independent per-property anyOf is lossless only when every property name exists
- * on every variant (absence is meaningful under xAI's default additionalProperties:
- * false, and promoting a branch-local key also tightens explicit-true variants)
- * and at most one of those shared properties has a conflicting schema.
+ * Compose two `properties` maps. A property named in BOTH the referenced target and the
+ * node is the same conjunction problem `required` had: letting the sibling win discards
+ * the target's constraints for that member. Merge the two member schemas so neither side
+ * loses its keywords. Shared member bounds are the same conjunction one level down,
+ * and nested object members recurse through this helper instead of replacing the target.
  */
-function xaiPropertyMergeIsLossless(variants: Record<string, unknown>[]): boolean {
-  const names = new Set<string>();
-  const props = variants.map(variant => {
-    const properties = variantProperties(variant);
-    for (const name of Object.keys(properties)) names.add(name);
-    return properties;
-  });
-  let schemaConflicts = 0;
-  for (const name of names) {
-    const values = props.map(property => property[name]);
-    if (values.some(value => value === undefined)) return false;
-    if (values.some(value => JSON.stringify(value) !== JSON.stringify(values[0]))) schemaConflicts += 1;
+function composeProperties(
+  target: Record<string, unknown>,
+  sibling: Record<string, unknown>,
+): Record<string, unknown> {
+  const combined: Record<string, unknown> = Object.create(null) as Record<string, unknown>;
+  for (const [name, sub] of Object.entries(target)) combined[name] = sub;
+  for (const [name, sub] of Object.entries(sibling)) {
+    const existing = combined[name];
+    if (isXaiObjectSchema(existing) && isXaiObjectSchema(sub)) {
+      const member: Record<string, unknown> = Object.create(null) as Record<string, unknown>;
+      for (const [k, v] of Object.entries(existing)) member[k] = v;
+      for (const [k, v] of Object.entries(sub)) {
+        if (k === "required") {
+          member[k] = unionRequired(member[k], v);
+          continue;
+        }
+        if (k === "properties" && isXaiObjectSchema(member[k]) && isXaiObjectSchema(v)) {
+          member[k] = composeProperties(member[k] as Record<string, unknown>, v);
+          continue;
+        }
+        const boundDirection = MOONSHOT_BOUND_KEYWORDS[k];
+        if (boundDirection && k in member) {
+          member[k] = intersectBound(member[k], v, boundDirection);
+          continue;
+        }
+        member[k] = v;
+      }
+      combined[name] = member;
+      continue;
+    }
+    combined[name] = sub;
   }
-  return schemaConflicts <= 1;
-}
-
-function xaiRequiredSetsMatch(variants: Record<string, unknown>[]): boolean {
-  const serialized = variants.map(variant => [...stringRequiredFields(variant.required)].sort().join("\0"));
-  return serialized.every(value => value === serialized[0]);
+  return combined;
 }
 
-function mergeXaiAdditionalProperties(
-  variants: Record<string, unknown>[],
-): { ok: true; value?: unknown } | { ok: false } {
-  const values = variants.map(variant => variant.additionalProperties);
-  const explicit = values.filter(value => value !== undefined);
-  if (explicit.length === 0) return { ok: true };
-  if (explicit.length !== values.length) return { ok: false };
-  const hasFalse = explicit.some(value => value === false);
-  const permissive = explicit.filter(value => value !== false);
-  if (hasFalse && permissive.length > 0) return { ok: false };
-  if (hasFalse) return { ok: true, value: false };
-  const unique: unknown[] = [];
-  const seen = new Set<string>();
-  for (const value of permissive) {
-    const key = JSON.stringify(value);
-    if (seen.has(key)) continue;
-    seen.add(key);
-    unique.push(value);
-  }
-  if (unique.length !== 1) return { ok: false };
-  return { ok: true, value: unique[0] };
+interface MoonshotNormalizeState {
+  activeRefs: Set<string>;
+  remainingExpansions: number;
+  remainingNodes: number;
 }
 
-/** Compose root siblings into a branch so properties/required are not overwritten. */
-function composeXaiObjectSchemas(
-  inherited: Record<string, unknown>,
-  branch: Record<string, unknown>,
-): Record<string, unknown> {
-  const composed: Record<string, unknown> = { ...inherited, ...branch };
-  const inheritedProps = isXaiObjectSchema(inherited.properties) ? inherited.properties : undefined;
-  const branchProps = isXaiObjectSchema(branch.properties) ? branch.properties : undefined;
-  if (inheritedProps || branchProps) {
-    const properties: Record<string, unknown> = { ...(inheritedProps ?? {}) };
-    for (const [name, value] of Object.entries(branchProps ?? {})) {
-      const inheritedValue = inheritedProps?.[name];
-      properties[name] = inheritedValue !== undefined && JSON.stringify(inheritedValue) !== JSON.stringify(value)
-        ? { allOf: [inheritedValue, value] }
-        : value;
-    }
-    composed.properties = properties;
+function normalizeMoonshotSchemaNode(
+  node: unknown,
+  root: Record<string, unknown>,
+  state: MoonshotNormalizeState,
+  depth = 0,
+): unknown {
+  if (Array.isArray(node)) {
+    if (depth >= MOONSHOT_MAX_SCHEMA_DEPTH) return [];
+    return node.map(item => normalizeMoonshotSchemaNode(item, root, state, depth + 1));
   }
-  const required = [...new Set([
-    ...stringRequiredFields(inherited.required),
-    ...stringRequiredFields(branch.required),
-  ])];
-  if (required.length > 0) composed.required = required;
-  else delete composed.required;
-  return composed;
-}
+  if (!isXaiObjectSchema(node)) return node;
 
-function expandXaiRootObjectSchemas(schema: unknown): Record<string, unknown>[] | undefined {
-  if (!isXaiObjectSchema(schema)) return undefined;
-  const compositionKey = ["oneOf", "anyOf"].find(key => Array.isArray(schema[key]));
-  if (!compositionKey) {
-    if (schema.type !== undefined && schema.type !== "object") return undefined;
-    return [{ ...schema, type: "object" }];
-  }
+  // Fail closed for this node rather than emitting a partially weakened schema: an empty
+  // object is the one shape that asserts nothing it cannot back up.
+  if (depth >= MOONSHOT_MAX_SCHEMA_DEPTH || state.remainingNodes <= 0) return {};
+  state.remainingNodes -= 1;
 
-  const siblings = Object.fromEntries(Object.entries(schema).filter(([key]) => key !== compositionKey));
-  const branches = schema[compositionKey];
-  if (!Array.isArray(branches)) return undefined;
-  const expanded: Record<string, unknown>[] = [];
-  for (const branch of branches) {
-    const variants = expandXaiRootObjectSchemas(branch);
-    if (!variants) return undefined;
-    for (const variant of variants) expanded.push(composeXaiObjectSchemas(siblings, variant));
-  }
-  return expanded.length > 0 ? expanded : undefined;
-}
+  const ref = node.$ref;
+  const hasSiblings = moonshotRefTargetKeys(node).length > 0;
 
-function mergeXaiPropertySchemas(values: unknown[]): unknown {
-  const unique: unknown[] = [];
-  const serialized = new Set<string>();
-  for (const value of values) {
-    const key = JSON.stringify(value);
-    if (serialized.has(key)) continue;
-    serialized.add(key);
-    unique.push(value);
-  }
-  return unique.length === 1 ? unique[0] : { anyOf: unique };
-}
+  if (typeof ref === "string" && hasSiblings) {
+    // A cycle cannot be inlined. Keeping the bare `$ref` is the lossy-but-valid fallback:
+    // Moonshot accepts it, and the alternative (dropping the ref) would erase the recursion.
+    if (state.activeRefs.has(ref) || state.remainingExpansions <= 0) return { $ref: ref };
 
-/**
- * The Grok CLI proxy rejects a function parameter schema whose root remains oneOf/anyOf.
- * Flatten only when the merge is lossless: local $refs resolve, every variant is a concrete
- * object whose keys we can preserve, required sets match, additionalProperties does not change
- * meaning, every property name exists on every variant, and at most one property schema
- * differs. Otherwise omit the tool rather than emit a weaker schema.
- */
-function normalizeXaiToolParameters(parameters: unknown): Record<string, unknown> | undefined {
-  if (!isXaiObjectSchema(parameters)) return undefined;
-  const resolved = resolveXaiSchemaRefs(parameters, parameters);
-  if (!isXaiObjectSchema(resolved)) return undefined;
-
-  const normalizedRoot = { ...resolved };
-  delete normalizedRoot.$schema;
-
-  const variants = expandXaiRootObjectSchemas(normalizedRoot);
-  if (!variants) return undefined;
-  if (variants.length === 1) {
-    return xaiVariantIsConcreteObject(variants[0]) ? variants[0] : undefined;
-  }
-  if (!variants.every(xaiVariantIsConcreteObject) || !xaiRequiredSetsMatch(variants)) return undefined;
-  const additionalProperties = mergeXaiAdditionalProperties(variants);
-  if (!additionalProperties.ok) return undefined;
-  if (!xaiPropertyMergeIsLossless(variants)) return undefined;
-
-  const metadata = Object.fromEntries(Object.entries(normalizedRoot).filter(([key]) => key !== "oneOf" && key !== "anyOf" && key !== "type"));
-  delete metadata.properties;
-  delete metadata.required;
-  delete metadata.additionalProperties;
-
-  const propertyValues = new Map<string, unknown[]>();
-  for (const variant of variants) {
-    if (!variant.properties || typeof variant.properties !== "object" || Array.isArray(variant.properties)) continue;
-    for (const [name, value] of Object.entries(variant.properties as Record<string, unknown>)) {
-      const values = propertyValues.get(name) ?? [];
-      values.push(value);
-      propertyValues.set(name, values);
+    const target = lookupLocalJsonPointer(root, ref);
+    if (isXaiObjectSchema(target)) {
+      state.remainingExpansions -= 1;
+      state.activeRefs.add(ref);
+      const resolvedTarget = normalizeMoonshotSchemaNode(target, root, state, depth + 1);
+      state.activeRefs.delete(ref);
+      const merged: Record<string, unknown> = Object.create(null) as Record<string, unknown>;
+      if (isXaiObjectSchema(resolvedTarget)) {
+        for (const [key, value] of Object.entries(resolvedTarget)) merged[key] = value;
+      }
+      // "Alongside the target" is conjunction, not replacement. For most keywords the node
+      // narrows the target and overwriting is the narrower reading, but `required` and
+      // `properties` are set-valued: letting the sibling win DROPPED the target's own
+      // members, so a tool requiring `a` beside a node requiring `b` shipped requiring only
+      // `b`. Those two compose; everything else keeps the narrowing overwrite.
+      for (const [key, value] of Object.entries(node)) {
+        if (key === "$ref") continue;
+        if (MOONSHOT_DATA_VALUED_KEYWORDS.has(key)) {
+          merged[key] = value;
+          continue;
+        }
+        const normalized = normalizeMoonshotSchemaNode(value, root, state, depth + 1);
+        if (key === "required") {
+          merged[key] = unionRequired(merged[key], normalized);
+          continue;
+        }
+        if (key === "properties" && isXaiObjectSchema(merged[key]) && isXaiObjectSchema(normalized)) {
+          merged[key] = composeProperties(merged[key] as Record<string, unknown>, normalized);
+          continue;
+        }
+        // Numeric bounds intersect rather than overwrite: both the node and its target
+        // apply, so the surviving bound is the stricter of the two in whichever direction
+        // that keyword tightens.
+        const boundDirection = MOONSHOT_BOUND_KEYWORDS[key];
+        if (boundDirection && key in merged) {
+          merged[key] = intersectBound(merged[key], normalized, boundDirection);
+          continue;
+        }
+        merged[key] = normalized;
+      }
+      return merged;
     }
+
+    // Unresolvable pointer: a remote ref, a malformed path, or a non-object target. Dropping
+    // the ref and keeping the siblings silently discards whatever the reference constrained,
+    // which is the one outcome we cannot detect downstream. A bare `$ref` is lossy in the
+    // other direction - it loses the node's own keywords - but it preserves the identity of
+    // what was asked for, and Moonshot accepts it.
+    return { $ref: ref };
   }
 
-  const properties = Object.fromEntries(
-    [...propertyValues].map(([name, values]) => [name, mergeXaiPropertySchemas(values)]),
-  );
-  const required = stringRequiredFields(variants[0]?.required);
+  const out: Record<string, unknown> = Object.create(null) as Record<string, unknown>;
+  for (const [key, value] of Object.entries(node)) {
+    out[key] = key === "$ref" || MOONSHOT_DATA_VALUED_KEYWORDS.has(key)
+      ? value
+      : normalizeMoonshotSchemaNode(value, root, state, depth + 1);
+  }
+  return out;
+}
 
-  return {
-    ...metadata,
-    type: "object",
-    properties,
-    ...(required.length > 0 ? { required } : {}),
-    ...("value" in additionalProperties ? { additionalProperties: additionalProperties.value } : {}),
-  };
+function normalizeMoonshotToolParameters(parameters: unknown): Record<string, unknown> {
+  const rooted = ensureRootObjectType(parameters);
+  const normalized = normalizeMoonshotSchemaNode(rooted, rooted, {
+    activeRefs: new Set<string>(),
+    remainingExpansions: MOONSHOT_MAX_REF_EXPANSIONS,
+    remainingNodes: MOONSHOT_MAX_SCHEMA_NODES,
+  });
+  return isXaiObjectSchema(normalized) ? normalized : rooted;
 }
 
 function toolsToChatFormat(parsed: OcxParsedRequest, provider: OcxProviderConfig): unknown[] | undefined {
@@ -1228,10 +1257,14 @@ function toolsToChatFormat(parsed: OcxParsedRequest, provider: OcxProviderConfig
   const tools = parsed.context.tools.filter(toolChoiceToolPredicate(parsed.options.toolChoice, parsed.context.tools));
   if (tools.length === 0) return undefined;
   const xaiTarget = isXaiSchemaTarget(provider);
+  const moonshotTarget = !xaiTarget && isMoonshotSchemaTarget(provider);
   const formatted = tools.flatMap(t => {
-    const parameters = stripResponsesOnlyEncryptedMarker(xaiTarget
+    const normalized = xaiTarget
       ? normalizeXaiToolParameters(t.parameters)
-      : ensureRootObjectType(t.parameters));
+      : moonshotTarget
+        ? normalizeMoonshotToolParameters(t.parameters)
+        : ensureRootObjectType(t.parameters);
+    const parameters = stripResponsesOnlyEncryptedMarker(normalized);
 
     if (parameters === undefined) return [];
     return [{
@@ -1249,17 +1282,22 @@ function toolsToChatFormat(parsed: OcxParsedRequest, provider: OcxProviderConfig
 
 function toolsToChatFormatForProvider(parsed: OcxParsedRequest, provider: OcxProviderConfig): unknown[] | undefined {
   const base = toolsToChatFormat(parsed, provider);
-  if (!base || !shouldSanitizeZenToolParameters(provider)) return base;
+  const azureChat = isAzureOpenAiChatTarget(provider);
+  const zenChat = shouldSanitizeZenToolParameters(provider);
+  if (!base || (!zenChat && !azureChat)) return base;
   return base.map(tool => {
     if (!tool || typeof tool !== "object") return tool;
     const functionDef = (tool as { function?: Record<string, unknown> }).function;
     if (!functionDef || typeof functionDef !== "object") return tool;
+    const parameters = azureChat
+      ? sanitizeAzureChatToolParameters(functionDef.parameters ?? {})
+      : ensureZenRootObjectSchema(functionDef.parameters ?? {});
+    const nextFunction: Record<string, unknown> = { ...functionDef, parameters };
+    // strict: true plus a flattened schema is rejected by Gemini-in-the-pool routers.
+    if (azureChat) delete nextFunction.strict;
     return {
       ...tool,
-      function: {
-        ...functionDef,
-        parameters: ensureZenRootObjectSchema(functionDef.parameters ?? {}),
-      },
+      function: nextFunction,
     };
   });
 }
@@ -1932,8 +1970,28 @@ export function createOpenAIChatAdapter(provider: OcxProviderConfig): ProviderAd
         const choice = rawChoice;
         if (choice.finish_reason === "error") return [upstreamErrorEvent(choice.error, usage)];
         if (!choice.message) return [{ type: "error", message: "upstream response contained no choices", ...(usage ? { usage } : {}) }];
+        // `!choice.message` splits this input class on TRUTHINESS, not on shape: `null` and `0` fail
+        // closed here, while `"text"`, `true` and `[{...}]` pass and every property read below yields
+        // `undefined` — so a choice claiming an assistant message completed as a SUCCESSFUL EMPTY
+        // turn, stranding any tool call it claimed. The one line above already validates the choice
+        // container this way; its message was left on a truthiness test.
+        //
+        // Every non-record is rejected, arrays included. The google adapter does carve out `[]` for
+        // `content`, but that carve-out is specific to a protobuf-derived wire where a repeated
+        // field can spell an empty message — and `content` is genuinely an ARRAY of blocks there.
+        // `message` is a record on a plain-JSON wire that already has `{}`, so importing the
+        // exception would be an analogy rather than evidence. `[{"content":"…"}]` is the case that
+        // matters: it discards a complete answer, #2232's `content: [{ parts: [...] }]` one adapter over.
+        //
+        // Read through `unknown` rather than the declared type: `choices` is a cast over wire data,
+        // so its `message?: Record<string, unknown>` is an assertion the upstream never made, and
+        // narrowing against it is what let the missing check look type-safe.
+        const rawMessage: unknown = choice.message;
+        if (!isRecord(rawMessage)) {
+          return [invalidChoicesEvent(usage)];
+        }
 
-        const msg = choice.message;
+        const msg = rawMessage as Record<string, unknown>;
         const reasoningText = reasoningTextFrom(msg);
         if (reasoningText !== undefined) events.push({ type: "reasoning_raw_delta", text: reasoningText });
         if (typeof msg.content === "string") events.push({ type: "text_delta", text: msg.content });