@bitkyc08/opencodex 2.59.0 → 2.61.0-preview.20260922

package/src/providers/registry/model-seeds.ts

@@ -177,6 +177,15 @@ export const META_MUSE_REASONING_EFFORTS = ["minimal", "low", "medium", "high",
 export const META_MUSE_REASONING_EFFORT_MAP: Record<string, string> = Object.fromEntries(
   META_MUSE_REASONING_EFFORTS.map(effort => [effort, effort]),
 );
+/*
+ * Muse Code credentials have a separate capability contract. Meta's authenticated
+ * /muse-code/models roster advertises max for both 1.3 models, and the Responses API
+ * accepts it when the request identifies the Muse client surface.
+ */
+export const META_MUSE_CODE_REASONING_EFFORTS = [...META_MUSE_REASONING_EFFORTS, "max"];
+export const META_MUSE_CODE_REASONING_EFFORT_MAP: Record<string, string> = Object.fromEntries(
+  META_MUSE_CODE_REASONING_EFFORTS.map(effort => [effort, effort]),
+);
 /** Both Muse Spark 1.3 tiers publish a 1,048,576-token window (dev.meta.ai/docs/models). */
 export const META_MUSE_CONTEXT_WINDOW = 1_048_576;
 export const META_MUSE_MODELS = ["muse-spark-1.3", "muse-spark-1.3-contributor"];
@@ -633,11 +642,26 @@ export const ALIBABA_TOKEN_PLAN_PRESERVE_REASONING = [
 export const KIMI_K3_STANDARD_CONTEXT_WINDOW = 262_144;
 export const KIMI_K3_1M_CONTEXT_WINDOW = 1_048_576;
 export const KIMI_CODING_K3_MODELS = ["k3", "k3[1m]"];
+// 260921 Kimi K2.8: `kimi-for-coding` is the stable subscription alias Moonshot re-points
+// at each coding release. Live GET /coding/v1/models lists only kimi-for-coding[-highspeed],
+// k3, k3-256k — the k2.x ids are retired from the subscription endpoint. Since K2.8 Preview
+// the alias serves an adjustable low/high/max thinking ladder (same wire map as k3) and a
+// 1M context ceiling. Verified live 260921: 350K-token request accepted; upstream rejects
+// with "model token limit: 1048576" beyond that.
+// Evidence: https://www.kimi.com/code/docs/en/kimi-code/models.html
+export const KIMI_CODING_K28_MODELS = ["kimi-for-coding"];
+export const KIMI_CODING_LIVE_MODELS = [...KIMI_CODING_K3_MODELS, ...KIMI_CODING_K28_MODELS];
+export const KIMI_CODING_ADJUSTABLE_THINKING_MODELS = [...KIMI_CODING_LIVE_MODELS];
 export const KIMI_LEGACY_API_MODELS = ["kimi-k2.7-code", "kimi-k2.7-code-highspeed", "kimi-k2.6", "kimi-k2.5"];
 export const KIMI_API_MODELS = ["kimi-k3", ...KIMI_LEGACY_API_MODELS];
-export const KIMI_CODING_MODELS = [...KIMI_CODING_K3_MODELS, ...KIMI_LEGACY_API_MODELS, "kimi-for-coding"];
-export const KIMI_THINKING_MODELS = KIMI_CODING_MODELS;
-export const KIMI_CODING_NO_REASONING_MODELS = KIMI_CODING_MODELS.filter(id => !KIMI_CODING_K3_MODELS.includes(id));
+// Every kimi coding preset record - picker, context windows, locked-parameter lists -
+// derives from the live ids only. seeding a retired id in a metadata list would re-arm
+// the model-rename migration on every boot (#5066): the list holds the retired id but
+// not the live alias, so the residue guard cannot skip it. The retired ids survive only
+// in KIMI_LEGACY_API_MODELS (moonshot platform API records); model-rename-migration
+// repairs saved rows still naming them.
+export const KIMI_THINKING_MODELS = KIMI_CODING_LIVE_MODELS;
+export const KIMI_CODING_NO_REASONING_MODELS = KIMI_CODING_LIVE_MODELS.filter(id => !KIMI_CODING_ADJUSTABLE_THINKING_MODELS.includes(id));
 export const KIMI_API_NO_REASONING_MODELS = KIMI_API_MODELS.filter(id => id !== "kimi-k3");
 export const KIMI_CODING_K3_REASONING_EFFORTS = ["low", "high", "max"];
 export const KIMI_CODING_K3_REASONING_EFFORT_MAP: Record<string, string> = {
@@ -649,19 +673,19 @@ export const KIMI_CODING_K3_REASONING_EFFORT_MAP: Record<string, string> = {
   max: "max",
 };
 export const KIMI_CODING_REASONING_EFFORTS = Object.fromEntries(
-  KIMI_CODING_MODELS.map(id => [id, KIMI_CODING_K3_MODELS.includes(id) ? KIMI_CODING_K3_REASONING_EFFORTS : []]),
+  KIMI_CODING_LIVE_MODELS.map(id => [id, KIMI_CODING_ADJUSTABLE_THINKING_MODELS.includes(id) ? KIMI_CODING_K3_REASONING_EFFORTS : []]),
 );
 export const KIMI_CODING_DEFAULT_REASONING_EFFORTS = Object.fromEntries(
-  KIMI_CODING_K3_MODELS.map(id => [id, "max"]),
+  KIMI_CODING_ADJUSTABLE_THINKING_MODELS.map(id => [id, "max"]),
 );
 export const KIMI_CODING_REASONING_EFFORT_MAPS = Object.fromEntries(
-  KIMI_CODING_K3_MODELS.map(id => [id, KIMI_CODING_K3_REASONING_EFFORT_MAP]),
+  KIMI_CODING_ADJUSTABLE_THINKING_MODELS.map(id => [id, KIMI_CODING_K3_REASONING_EFFORT_MAP]),
 );
 export const KIMI_API_REASONING_EFFORTS = Object.fromEntries(
   KIMI_API_MODELS.map(id => [id, id === "kimi-k3" ? ["max"] : []]),
 );
-export const KIMI_LOCKED_PARAMETER_MODELS = KIMI_CODING_MODELS;
-export const KIMI_AUTO_TOOL_CHOICE_ONLY_MODELS = ["kimi-k2.7-code", "kimi-k2.7-code-highspeed", "kimi-for-coding"];
+export const KIMI_LOCKED_PARAMETER_MODELS = KIMI_CODING_LIVE_MODELS;
+export const KIMI_AUTO_TOOL_CHOICE_ONLY_MODELS = ["kimi-for-coding"];
 export const KIMI_API_MODEL_CONTEXT_WINDOWS: Record<string, number> = Object.fromEntries(
   KIMI_API_MODELS.map(id => [id, id === "kimi-k3" ? KIMI_K3_1M_CONTEXT_WINDOW : 262_144]),
 );
@@ -749,10 +773,10 @@ export const NVIDIA_NIM_NO_VISION_MODELS = [
   "poolside/laguna-xs-2.1", "z-ai/glm-5.3", "z-ai/glm-5.2",
 ];
 export const KIMI_CODING_MODEL_CONTEXT_WINDOWS: Record<string, number> = Object.fromEntries(
-  KIMI_CODING_MODELS.map(id => [id, id === "k3[1m]" ? KIMI_K3_1M_CONTEXT_WINDOW : KIMI_K3_STANDARD_CONTEXT_WINDOW]),
+  KIMI_CODING_LIVE_MODELS.map(id => [id, (id === "k3[1m]" || KIMI_CODING_K28_MODELS.includes(id)) ? KIMI_K3_1M_CONTEXT_WINDOW : KIMI_K3_STANDARD_CONTEXT_WINDOW]),
 );
 export const KIMI_CODING_MODEL_INPUT_MODALITIES = Object.fromEntries(
-  KIMI_CODING_K3_MODELS.map(id => [id, ["text", "image"]]),
+  KIMI_CODING_ADJUSTABLE_THINKING_MODELS.map(id => [id, ["text", "image"]]),
 );
 export const NEURALWATT_REASONING_HISTORY_MODELS = [
   "glm-5.3", "glm-5.3-short", "glm-5.3-flash",
@@ -1017,3 +1041,25 @@ export const OPPER_TEXT_ONLY_MODELS = ["deepseek-v4-pro", "kimi-k3"];
 export const OPPER_MODEL_INPUT_MODALITIES: Record<string, string[]> = Object.fromEntries(
   OPPER_MODELS.map(id => [id, OPPER_TEXT_ONLY_MODELS.includes(id) ? ["text"] : ["text", "image"]]),
 );
+
+export const STEPFUN_MODELS = [
+  "step-5-preview",
+  "step-3.5-flash",
+  "step-3.7-flash",
+];
+
+export const STEPFUN_MODEL_CONTEXT_WINDOWS: Record<string, number> = {
+  "step-5-preview": 1_000_000,
+  "step-3.5-flash": 256_000,
+  "step-3.7-flash": 256_000,
+};
+
+export const STEPFUN_MODEL_INPUT_MODALITIES: Record<string, string[]> = {
+  "step-5-preview": ["text", "image"],
+  "step-3.5-flash": ["text"],
+  "step-3.7-flash": ["text", "image"],
+};
+
+export const STEPFUN_NO_VISION_MODELS = ["step-3.5-flash"];
+
+export const STEPFUN_REASONING_EFFORTS = ["low", "medium", "high"];

package/src/providers/registry/types.ts

@@ -264,6 +264,8 @@ export interface ProviderRegistryEntry {
   modelServiceTierCapabilityBaseUrlGuard?: (baseUrl: string) => boolean;
   /** Registry default for plaintext reasoning replay; see `OcxProviderConfig.preserveResponsesReasoningContent`. Registry-only like `supportsServiceTier`. */
   preserveResponsesReasoningContent?: boolean;
+  /** Registry default for dropping replayed reasoning items for Responses upstreams that reject them. */
+  dropResponsesReasoningItems?: boolean;
   /** Registry defaults for per-model Codex reasoning propagation; explicit user keys win during enrichment. */
   modelSupportsReasoningSummaries?: Record<string, boolean>;
   /** Registry defaults for per-model Codex Responses verbosity support. */

package/src/providers/resolved-model-policy-merge.ts

@@ -0,0 +1,167 @@
+import type { OcxProviderConfig } from "../types";
+import { MODEL_ADAPTER_OVERRIDE_ALLOWED } from "../types";
+import type { InboundWire, ModelWireDefault, ProviderRegistryEntry } from "./registry/types";
+
+export type StaticPolicySource =
+  | "operator" | "operator-capability" | "captured-auth"
+  | "registry" | "hard-pin" | "provider-default" | "unknown";
+
+export function detachedClone<T>(value: T): T {
+  if (Array.isArray(value)) return value.map(item => detachedClone(item)) as T;
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value as Record<string, unknown>)
+      .map(([key, nested]) => [key, detachedClone(nested)])) as T;
+  }
+  return value;
+}
+
+export function recursivelyFreeze<T>(value: T): T {
+  if (!value || typeof value !== "object" || Object.isFrozen(value)) return value;
+  for (const nested of Object.values(value as Record<string, unknown>)) recursivelyFreeze(nested);
+  return Object.freeze(value);
+}
+
+export function scalar<T>(operator: T | undefined, registry: T | undefined): [T | undefined, StaticPolicySource] {
+  if (operator !== undefined) return [detachedClone(operator), "operator"];
+  if (registry !== undefined) return [detachedClone(registry), "registry"];
+  return [undefined, "unknown"];
+}
+
+export function mapFill<T>(
+  registry: Readonly<Record<string, T>> | undefined,
+  operator: Readonly<Record<string, T>> | undefined,
+): [Record<string, T> | undefined, StaticPolicySource] {
+  if (!registry && !operator) return [undefined, "unknown"];
+  return [detachedClone({ ...(registry ?? {}), ...(operator ?? {}) }), operator ? "operator" : "registry"];
+}
+
+export function nestedMapFill(
+  registry: Readonly<Record<string, Record<string, string>>> | undefined,
+  operator: Readonly<Record<string, Record<string, string>>> | undefined,
+): [Record<string, Record<string, string>> | undefined, StaticPolicySource] {
+  if (!registry && !operator) return [undefined, "unknown"];
+  const merged: Record<string, Record<string, string>> = {};
+  for (const [key, value] of Object.entries(registry ?? {})) merged[key] = { ...value };
+  for (const [key, value] of Object.entries(operator ?? {})) {
+    merged[key] = { ...(merged[key] ?? {}), ...value };
+  }
+  return [merged, operator ? "operator" : "registry"];
+}
+
+export function positiveCapMap(
+  registry: Readonly<Record<string, number>> | undefined,
+  operator: Readonly<Record<string, number>> | undefined,
+): [Record<string, number> | undefined, StaticPolicySource] {
+  if (!registry && !operator) return [undefined, "unknown"];
+  const merged = { ...(registry ?? {}) };
+  for (const [key, value] of Object.entries(operator ?? {})) {
+    merged[key] = typeof merged[key] === "number" ? Math.min(merged[key]!, value) : value;
+  }
+  return [merged, operator ? "operator" : "registry"];
+}
+
+export function stableUnion(
+  registry: readonly string[] | undefined,
+  operator: readonly string[] | undefined,
+): [string[] | undefined, StaticPolicySource] {
+  if (!registry && !operator) return [undefined, "unknown"];
+  return [[...new Set([...(registry ?? []), ...(operator ?? [])])], operator ? "operator" : "registry"];
+}
+
+export function staticHeaders(
+  registry: Readonly<Record<string, string>> | undefined,
+  operator: Readonly<Record<string, string>> | undefined,
+): [Record<string, string> | undefined, StaticPolicySource] {
+  if (!registry && !operator) return [undefined, "unknown"];
+  if (!registry) return [{ ...(operator ?? {}) }, "operator"];
+  if (!operator) return [{ ...registry }, "registry"];
+  const claimed = new Set(Object.keys(operator).map(name => name.toLowerCase()));
+  const merged: Record<string, string> = { ...operator };
+  for (const [name, value] of Object.entries(registry)) {
+    if (!claimed.has(name.toLowerCase())) merged[name] = value;
+  }
+  return [merged, "operator"];
+}
+
+export function resolvedBaseUrl(
+  entry: Readonly<ProviderRegistryEntry> | undefined,
+  provider: Readonly<OcxProviderConfig>,
+): [string, StaticPolicySource] {
+  if (!entry) return [provider.baseUrl, "operator"];
+  const configured = typeof provider.baseUrl === "string" ? provider.baseUrl.trim() : "";
+  const configuredIsResolved = configured.length > 0 && !/\{[^}]*\}/.test(configured);
+  if (entry.allowBaseUrlOverride && !configuredIsResolved) {
+    throw new Error(`Invalid baseUrl for provider "${entry.id}": expected a nonblank URL without unresolved placeholders`);
+  }
+  return (/\{[^}]*\}/.test(entry.baseUrl) || entry.allowBaseUrlOverride) && configuredIsResolved
+    ? [configured, "operator"]
+    : [entry.baseUrl, "registry"];
+}
+
+export function sameStringArray(left: readonly string[] | undefined, right: readonly string[]): boolean {
+  return left?.length === right.length && left.every((value, index) => value === right[index]);
+}
+
+/** Legacy config-map lookup: exact id, colon family, then case-folded exact id. */
+export function legacyModelValue<T>(record: Readonly<Record<string, T>> | undefined, modelId: string): T | undefined {
+  if (!record) return undefined;
+  if (Object.hasOwn(record, modelId)) return record[modelId];
+  const colon = modelId.indexOf(":");
+  if (colon > 0 && Object.hasOwn(record, modelId.slice(0, colon))) return record[modelId.slice(0, colon)];
+  const folded = modelId.toLowerCase();
+  return Object.entries(record).find(([key]) => key.toLowerCase() === folded)?.[1];
+}
+
+/** Provenance from the same merged-key walk as legacyModelValue. */
+export function legacyModelSource<T>(
+  operator: Readonly<Record<string, T>> | undefined,
+  registry: Readonly<Record<string, T>> | undefined,
+  modelId: string,
+): StaticPolicySource {
+  const merged = { ...(registry ?? {}), ...(operator ?? {}) };
+  let winningKey: string | undefined;
+  if (Object.hasOwn(merged, modelId)) winningKey = modelId;
+  const colon = modelId.indexOf(":");
+  if (winningKey === undefined && colon > 0 && Object.hasOwn(merged, modelId.slice(0, colon))) {
+    winningKey = modelId.slice(0, colon);
+  }
+  if (winningKey === undefined) {
+    const folded = modelId.toLowerCase();
+    winningKey = Object.keys(merged).find(key => key.toLowerCase() === folded);
+  }
+  if (winningKey === undefined) return "unknown";
+  return Object.hasOwn(operator ?? {}, winningKey) ? "operator" : "registry";
+}
+
+export function anthropicFamilyContextWindow(
+  record: Readonly<Record<string, number>> | undefined,
+  id: string,
+): number | undefined {
+  if (!record || !id.toLowerCase().startsWith("claude-")) return undefined;
+  let candidate = id;
+  while (true) {
+    const cut = candidate.lastIndexOf("-");
+    if (cut <= 0 || !/^\d+$/.test(candidate.slice(cut + 1))) return undefined;
+    candidate = candidate.slice(0, cut);
+    const value = record[candidate]
+      ?? Object.entries(record).find(([key]) => key.toLowerCase() === candidate.toLowerCase())?.[1];
+    if (typeof value === "number" && value > 0) return value;
+  }
+}
+
+export function wireDefault(
+  declared: ModelWireDefault | undefined,
+  provider: Readonly<OcxProviderConfig>,
+  entry: Readonly<ProviderRegistryEntry> | undefined,
+  inbound: InboundWire,
+  effectiveAuthMode: OcxProviderConfig["authMode"] | undefined,
+): string | undefined {
+  if (declared === undefined || !MODEL_ADAPTER_OVERRIDE_ALLOWED.has(provider.adapter)) return undefined;
+  if (typeof declared !== "string") {
+    if (!declared.inbound.includes(inbound)) return undefined;
+    const authMode = effectiveAuthMode ?? provider.authMode ?? entry?.authKind;
+    if (declared.authModes && authMode && !declared.authModes.includes(authMode)) return undefined;
+  }
+  const wire = typeof declared === "string" ? declared : declared.wire;
+  return MODEL_ADAPTER_OVERRIDE_ALLOWED.has(wire) ? wire : undefined;
+}