omnigateway 0.12.5 → 0.12.7

package/bin/omni.js

@@ -25741,7 +25741,7 @@ function mergeHeaders(base, overrides) {
 
 // packages/providers/src/anthropic/profile.ts
 var host = stainlessHost(process.platform, process.arch);
-var ANTHROPIC_CLI_VERSION = env("OMNI_ANTHROPIC_CLI_VERSION", "2.1.258");
+var ANTHROPIC_CLI_VERSION = env("OMNI_ANTHROPIC_CLI_VERSION", "2.1.278");
 var anthropicProfile = {
   headers: [
     ["User-Agent", env("OMNI_UA_ANTHROPIC", `claude-cli/${ANTHROPIC_CLI_VERSION} (external, cli)`)],
@@ -26769,6 +26769,265 @@ async function* decodeAnthropic(messages, opts = {}) {
   }
 }
 
+// packages/providers/src/responseFormat.ts
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function readResponseFormatResult(req) {
+  const openai = req.vendor?.openai;
+  const chat = openai?.response_format;
+  if (chat !== undefined) {
+    if (!isRecord(chat) || chat.type !== "json_schema")
+      return { kind: "malformed" };
+    return fromSpec(chat.json_schema);
+  }
+  const responses = openai?.text;
+  if (isRecord(responses) && responses.format !== undefined)
+    return fromSpec(responses.format);
+  if (responses !== undefined)
+    return { kind: "malformed" };
+  const messages = req.vendor?.anthropic?.output_config;
+  if (isRecord(messages) && messages.format !== undefined)
+    return fromSpec(messages.format);
+  if (messages !== undefined)
+    return { kind: "malformed" };
+  return { kind: "absent" };
+}
+function readableFormat(spec) {
+  return isRecord(spec) && (spec.type === undefined || spec.type === "json_schema") && isRecord(spec.schema);
+}
+function canSerialize(value) {
+  if (typeof value === "bigint")
+    return false;
+  if (typeof value !== "object" || value === null)
+    return true;
+  const seen = new WeakSet;
+  const stack = [value];
+  while (stack.length > 0) {
+    const node2 = stack.pop();
+    if (node2 === undefined)
+      break;
+    if (seen.has(node2))
+      continue;
+    seen.add(node2);
+    if (typeof node2.toJSON === "function") {
+      try {
+        const res = node2.toJSON();
+        if (typeof res === "bigint")
+          return false;
+      } catch {
+        return false;
+      }
+    }
+    const values3 = Array.isArray(node2) ? node2 : Object.values(node2);
+    for (const val of values3) {
+      if (typeof val === "bigint")
+        return false;
+      if (typeof val === "object" && val !== null) {
+        stack.push(val);
+      }
+    }
+  }
+  return true;
+}
+function fromSpec(spec) {
+  if (!readableFormat(spec))
+    return { kind: "malformed" };
+  const schema = spec.schema;
+  if (!isRecord(schema))
+    return { kind: "malformed" };
+  if (isCyclic(schema) || tooDeepToSerialize(schema) || !canSerialize(schema)) {
+    return { kind: "tooDeep" };
+  }
+  return {
+    kind: "readable",
+    format: {
+      schema,
+      name: typeof spec.name === "string" && spec.name.length > 0 ? spec.name : "response"
+    }
+  };
+}
+function forEachSubschema(nodes, visit2) {
+  for (const node2 of nodes) {
+    for (const [key, value] of Object.entries(node2)) {
+      if (SUBSCHEMA_MAP.includes(key) && isRecord(value)) {
+        for (const member of Object.values(value))
+          if (isRecord(member))
+            visit2(member, node2);
+      } else if (SUBSCHEMA_LIST.includes(key) && Array.isArray(value)) {
+        for (const member of value)
+          if (isRecord(member))
+            visit2(member, node2);
+      } else if (SUBSCHEMA.includes(key) && isRecord(value)) {
+        visit2(value, node2);
+      }
+    }
+  }
+}
+function isCyclic(schema) {
+  const onPath = new Set;
+  const done = new WeakSet;
+  const stack = [{ node: schema, entering: true }];
+  while (stack.length > 0) {
+    const frame = stack.pop();
+    if (frame === undefined)
+      break;
+    const node2 = frame.node;
+    if (!frame.entering) {
+      onPath.delete(node2);
+      done.add(node2);
+      continue;
+    }
+    if (onPath.has(node2))
+      return true;
+    if (done.has(node2))
+      continue;
+    onPath.add(node2);
+    stack.push({ node: node2, entering: false });
+    if (Array.isArray(node2)) {
+      for (const item of node2) {
+        if (typeof item === "object" && item !== null) {
+          stack.push({ node: item, entering: true });
+        }
+      }
+    } else {
+      for (const val of Object.values(node2)) {
+        if (typeof val === "object" && val !== null) {
+          stack.push({ node: val, entering: true });
+        }
+      }
+    }
+  }
+  return false;
+}
+function tooDeepToSerialize(schema) {
+  let level = [schema];
+  for (let depth = 0;depth < MAX_DEPTH2; depth++) {
+    const next = [];
+    const seenThisLevel = new WeakSet;
+    forEachSubschema(level, (member) => {
+      if (seenThisLevel.has(member))
+        return;
+      seenThisLevel.add(member);
+      next.push(member);
+    });
+    if (next.length === 0)
+      return false;
+    level = next;
+  }
+  return true;
+}
+function moveToResponsesText(req, body, provider) {
+  const raw = body.response_format;
+  delete body.response_format;
+  const malformedText = body.text !== undefined && !isRecord(body.text);
+  if (malformedText)
+    delete body.text;
+  const read = readResponseFormatResult(req);
+  const clientText = isRecord(body.text) ? body.text : undefined;
+  const clientFormat = clientText?.format;
+  if (readableFormat(clientFormat) && read.kind === "readable")
+    return;
+  const malformedFormat = clientText !== undefined && clientFormat !== undefined;
+  const text = clientText === undefined ? undefined : { ...clientText };
+  if (text !== undefined)
+    delete text.format;
+  if (malformedFormat)
+    body.text = text;
+  if (read.kind === "readable") {
+    const format = read.format;
+    body.text = {
+      ...text,
+      format: { type: "json_schema", name: format.name, schema: format.schema, strict: true }
+    };
+    return `${provider}:response-format-translated`;
+  }
+  if (isRecord(raw) && raw.type === "json_object") {
+    body.text = { ...text, format: { type: "json_object" } };
+    return `${provider}:response-format-translated`;
+  }
+  if (read.kind === "tooDeep")
+    return `${provider}:response-schema-too-deep`;
+  if (raw !== undefined || malformedText || malformedFormat) {
+    return `${provider}:response-format-dropped`;
+  }
+  return;
+}
+function closeObjects(schema, stats) {
+  if (stats !== undefined) {
+    stats.changed = false;
+    stats.truncated = false;
+  }
+  return closeNode(schema, 0, stats ?? { changed: false, truncated: false }, new Map);
+}
+var SUBSCHEMA = [
+  "items",
+  "additionalItems",
+  "additionalProperties",
+  "contains",
+  "contentSchema",
+  "if",
+  "then",
+  "else",
+  "not",
+  "propertyNames",
+  "unevaluatedItems",
+  "unevaluatedProperties"
+];
+var SUBSCHEMA_LIST = ["anyOf", "allOf", "oneOf", "prefixItems", "items"];
+var SUBSCHEMA_MAP = [
+  "properties",
+  "patternProperties",
+  "$defs",
+  "definitions",
+  "dependentSchemas",
+  "dependencies"
+];
+var MAX_DEPTH2 = 64;
+function closeNode(schema, depth, stats, memo2) {
+  if (depth >= MAX_DEPTH2) {
+    stats.truncated = true;
+    return schema;
+  }
+  let atDepth = memo2.get(depth);
+  if (atDepth === undefined) {
+    atDepth = new WeakMap;
+    memo2.set(depth, atDepth);
+  }
+  const done = atDepth.get(schema);
+  if (done !== undefined)
+    return done;
+  const out = {};
+  atDepth.set(schema, out);
+  for (const [key, value] of Object.entries(schema)) {
+    if (SUBSCHEMA_MAP.includes(key) && isRecord(value)) {
+      const members2 = {};
+      for (const [name, member] of Object.entries(value)) {
+        Object.defineProperty(members2, name, {
+          value: isRecord(member) ? closeNode(member, depth + 1, stats, memo2) : member,
+          writable: true,
+          enumerable: true,
+          configurable: true
+        });
+      }
+      out[key] = members2;
+      continue;
+    }
+    if (SUBSCHEMA.includes(key) && isRecord(value)) {
+      out[key] = closeNode(value, depth + 1, stats, memo2);
+      continue;
+    }
+    if (SUBSCHEMA_LIST.includes(key) && Array.isArray(value)) {
+      out[key] = value.map((arm) => isRecord(arm) ? closeNode(arm, depth + 1, stats, memo2) : arm);
+      continue;
+    }
+    out[key] = value;
+  }
+  if (out.type === "object" && out.additionalProperties !== false) {
+    out.additionalProperties = false;
+    stats.changed = true;
+  }
+  return out;
+}
+
 // packages/providers/src/system.ts
 function systemTextBlocks(system, provider, note2) {
   if (system === undefined)
@@ -26891,12 +27150,12 @@ function encodeToolChoice(c, cloak) {
       return { type: "tool", name: cloakName(cloak, c.name) };
   }
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function withoutEffort(vendor, note2) {
   const config2 = vendor.output_config;
-  if (!isRecord(config2))
+  if (!isRecord2(config2))
     return vendor;
   const entries = Object.entries(config2);
   const kept = entries.filter(([key]) => key !== "effort");
@@ -26910,7 +27169,7 @@ function withoutEffort(vendor, note2) {
 }
 var THINKING_ONLY_EDITS = new Set(["clear_thinking_20251015"]);
 function thinkingIsOff(thinking) {
-  if (!isRecord(thinking))
+  if (!isRecord2(thinking))
     return thinking !== undefined;
   return thinking.type !== "adaptive" && thinking.type !== "enabled";
 }
@@ -26918,9 +27177,9 @@ function stripUnsupportedEdits(body, note2) {
   if (!thinkingIsOff(body.thinking))
     return;
   const config2 = body.context_management;
-  if (!isRecord(config2) || !Array.isArray(config2.edits))
+  if (!isRecord2(config2) || !Array.isArray(config2.edits))
     return;
-  const kept = config2.edits.filter((e) => !(isRecord(e) && THINKING_ONLY_EDITS.has(String(e.type))));
+  const kept = config2.edits.filter((e) => !(isRecord2(e) && THINKING_ONLY_EDITS.has(String(e.type))));
   if (kept.length === config2.edits.length)
     return;
   note2("anthropic:clear-thinking-unsupported");
@@ -26939,11 +27198,11 @@ var CACHEABLE_WIRE_BLOCKS = new Set(["text", "image", "tool_use", "tool_result",
 function lastCacheableHistoryBlock(messages) {
   for (let m = messages.length - 1;m >= 0; m--) {
     const message = messages[m];
-    if (!isRecord(message) || !Array.isArray(message.content))
+    if (!isRecord2(message) || !Array.isArray(message.content))
       continue;
     for (let b = message.content.length - 1;b >= 0; b--) {
       const block = message.content[b];
-      if (!isRecord(block))
+      if (!isRecord2(block))
         continue;
       if (typeof block.type === "string" && CACHEABLE_WIRE_BLOCKS.has(block.type))
         return block;
@@ -27022,9 +27281,9 @@ function toWire(req, model, opts) {
   };
   if (systemCache.retarget !== undefined) {
     const trailing = body.messages.at(-1);
-    if (isRecord(trailing) && Array.isArray(trailing.content)) {
+    if (isRecord2(trailing) && Array.isArray(trailing.content)) {
       for (const block of trailing.content) {
-        if (isRecord(block))
+        if (isRecord2(block))
           delete block.cache_control;
       }
     }
@@ -27064,7 +27323,7 @@ function toWire(req, model, opts) {
         };
         if (req.reasoning.effort !== undefined) {
           body.output_config = {
-            ...isRecord(body.output_config) ? body.output_config : {},
+            ...isRecord2(body.output_config) ? body.output_config : {},
             effort: req.reasoning.effort
           };
         }
@@ -27077,11 +27336,64 @@ function toWire(req, model, opts) {
         break;
     }
   }
-  const vendor = req.vendor?.anthropic ?? {};
+  const native = req.vendor?.anthropic?.output_config;
+  const nativeFormat = isRecord2(native) && readableFormat(native.format);
+  const read = readResponseFormatResult(req);
+  const format = !nativeFormat && read.kind === "readable" ? read.format : undefined;
+  if (format !== undefined) {
+    body.output_config = {
+      ...isRecord2(body.output_config) ? body.output_config : {},
+      format: { type: "json_schema", schema: format.schema }
+    };
+    note2("anthropic:response-format-translated");
+  } else if (!nativeFormat && read.kind === "tooDeep") {
+    note2("anthropic:response-schema-too-deep");
+  }
+  const vendorRaw = req.vendor?.anthropic ?? {};
+  const vendorConfig = vendorRaw.output_config;
+  const encoderConfig = isRecord2(body.output_config) ? body.output_config : undefined;
+  let unreadableFormat = false;
+  let vendor = vendorRaw;
+  if (encoderConfig !== undefined && vendorConfig !== undefined) {
+    if (!isRecord2(vendorConfig)) {
+      const { output_config: _unreadable, ...rest } = vendorRaw;
+      vendor = rest;
+      unreadableFormat = true;
+    } else {
+      const readable = readableFormat(vendorConfig.format);
+      const { format: _unreadable, ...withoutFormat } = vendorConfig;
+      const rest = readable ? vendorConfig : withoutFormat;
+      vendor = { ...vendorRaw, output_config: { ...encoderConfig, ...rest } };
+      unreadableFormat = !readable && vendorConfig.format !== undefined;
+    }
+  }
   Object.assign(body, anthropicReasoningForm(model) === "budget" ? withoutEffort(vendor, note2) : vendor);
+  if (unreadableFormat)
+    note2("anthropic:response-format-dropped");
+  closeOutputConfigSchema(body, note2);
   stripUnsupportedEdits(body, note2);
   return { body, degradations };
 }
+function closeOutputConfigSchema(body, note2) {
+  const config2 = body.output_config;
+  if (!isRecord2(config2))
+    return;
+  const format = config2.format;
+  if (!isRecord2(format) || !isRecord2(format.schema))
+    return;
+  const stats = { changed: false, truncated: false };
+  const closed = closeObjects(format.schema, stats);
+  if (stats.truncated || !canSerialize(closed)) {
+    const { format: _tooDeep, ...rest } = config2;
+    body.output_config = rest;
+    note2("anthropic:response-schema-too-deep");
+    return;
+  }
+  if (!stats.changed)
+    return;
+  body.output_config = { ...config2, format: { ...format, schema: closed } };
+  note2("anthropic:response-schema-closed");
+}
 
 // packages/providers/src/anthropic/codec.ts
 var BASE_URL = "https://api.anthropic.com/v1/messages";
@@ -28109,6 +28421,14 @@ function toAntigravityWire(req, model, identity) {
         break;
     }
   }
+  const read = readResponseFormatResult(req);
+  if (read.kind === "readable") {
+    const format = read.format;
+    generationConfig.responseSchema = pruneSchema(format.schema, note2);
+    note2("antigravity:response-format-translated");
+  } else if (read.kind === "tooDeep") {
+    note2("antigravity:response-schema-too-deep");
+  }
   const max = generationConfig.maxOutputTokens;
   if (max !== undefined && max > MAX_OUTPUT_TOKENS) {
     generationConfig.maxOutputTokens = MAX_OUTPUT_TOKENS;
@@ -28608,7 +28928,7 @@ var SCOPES3 = [
   "workspaces:write"
 ].join(" ");
 var TRUSTED_HOST = "x.ai";
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null;
 }
 function trustedEndpoint(value, field, fail) {
@@ -28633,7 +28953,7 @@ async function* discover(fail) {
     throw fail("UPSTREAM", `discovery endpoint returned http_${res.status}`);
   }
   const parsed2 = parsed(res.body);
-  if (!isRecord2(parsed2)) {
+  if (!isRecord3(parsed2)) {
     throw fail("UPSTREAM", "discovery endpoint returned an unusable response");
   }
   return {
@@ -28642,7 +28962,7 @@ async function* discover(fail) {
   };
 }
 function parseTokenResponse2(value) {
-  if (!isRecord2(value) || typeof value.access_token !== "string")
+  if (!isRecord3(value) || typeof value.access_token !== "string")
     return null;
   return {
     accessToken: value.access_token,
@@ -28658,7 +28978,7 @@ function emailFromIdToken(idToken) {
     return null;
   try {
     const json4 = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
-    if (!isRecord2(json4))
+    if (!isRecord3(json4))
       return null;
     return typeof json4.email === "string" && json4.email.trim().length > 0 ? json4.email : null;
   } catch {
@@ -28744,11 +29064,11 @@ var PROFILE_URL = "https://api.kilo.ai/api/profile";
 var FALLBACK_VERIFICATION_URL = "https://kilo.ai";
 var DEFAULT_EXPIRES_SECONDS = 300;
 var POLL_INTERVAL_SECONDS = 3;
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null;
 }
 function recordFrom(value) {
-  return isRecord3(value) ? value : null;
+  return isRecord4(value) ? value : null;
 }
 function stringFrom(value, field) {
   const candidate = value[field];
@@ -28900,11 +29220,11 @@ var TOKEN_URL3 = "https://auth.kimi.com/api/oauth/token";
 var USAGE_URL2 = "https://api.kimi.com/coding/v1/usages";
 var DEFAULT_INTERVAL_SECONDS = 5;
 var PENDING_ERRORS = new Set(["authorization_pending", "slow_down"]);
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null;
 }
 function recordFrom2(value) {
-  return isRecord4(value) ? value : null;
+  return isRecord5(value) ? value : null;
 }
 function stringFrom2(value, field) {
   const candidate = value[field];
@@ -29095,11 +29415,11 @@ var DEVICE_CODE_GRANT = "urn:ietf:params:oauth:grant-type:device_code";
 var FALLBACK_VERIFICATION_URL2 = "https://auth.meta.com/oauth/device/";
 var DEFAULT_INTERVAL_SECONDS2 = 5;
 var PENDING_ERRORS2 = new Set(["authorization_pending", "slow_down"]);
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null;
 }
 function recordFrom3(value) {
-  return isRecord5(value) ? value : null;
+  return isRecord6(value) ? value : null;
 }
 function stringFrom3(value, field) {
   const candidate = value[field];
@@ -29280,7 +29600,7 @@ var AUTHORIZE_URL3 = "https://auth.openai.com/oauth/authorize";
 var TOKEN_URL5 = "https://auth.openai.com/oauth/token";
 var SCOPES4 = "openid profile email offline_access";
 var USAGE_URL3 = "https://chatgpt.com/backend-api/wham/usage";
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null;
 }
 function nonBlankStringOrNull(value) {
@@ -29297,19 +29617,19 @@ function decodeClaims(idToken) {
   }
   try {
     const json4 = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
-    if (!isRecord6(json4))
+    if (!isRecord7(json4))
       return { email: null, accountId: null };
     const auth = json4["https://api.openai.com/auth"];
     return {
       email: typeof json4.email === "string" ? json4.email : null,
-      accountId: isRecord6(auth) ? nonBlankStringOrNull(auth.chatgpt_account_id) : null
+      accountId: isRecord7(auth) ? nonBlankStringOrNull(auth.chatgpt_account_id) : null
     };
   } catch {
     return { email: null, accountId: null };
   }
 }
 function parseTokenResponse3(value) {
-  if (!isRecord6(value) || typeof value.access_token !== "string")
+  if (!isRecord7(value) || typeof value.access_token !== "string")
     return null;
   return {
     accessToken: value.access_token,
@@ -29894,6 +30214,24 @@ function toCustomChatWire(req, model) {
   else if (req.reasoning?.mode === "budget")
     note2("custom:reasoning-budget-dropped");
   Object.assign(body, req.vendor?.openai ?? {});
+  const droppedText = body.text;
+  delete body.text;
+  const read = readResponseFormatResult(req);
+  const format = read.kind === "readable" ? read.format : undefined;
+  if (format !== undefined) {
+    if (body.response_format === undefined) {
+      body.response_format = {
+        type: "json_schema",
+        json_schema: { name: format.name, schema: format.schema, strict: true }
+      };
+      note2("custom:response-format-translated");
+    }
+  } else if (isRecord(droppedText) && droppedText.format !== undefined) {
+    note2("custom:response-format-dropped");
+  } else if (read.kind === "tooDeep") {
+    delete body.response_format;
+    note2("custom:response-schema-too-deep");
+  }
   return { body, degradations };
 }
 function toCustomResponsesWire(req, model) {
@@ -29985,6 +30323,9 @@ function toCustomResponsesWire(req, model) {
   else if (req.reasoning?.mode === "budget")
     note2("custom:reasoning-budget-dropped");
   Object.assign(body, req.vendor?.openai ?? {});
+  const moved = moveToResponsesText(req, body, "custom");
+  if (moved !== undefined)
+    note2(moved);
   return { body, degradations };
 }
 
@@ -30359,6 +30700,9 @@ function toGrokWire(req, model) {
     }
   }
   Object.assign(body, req.vendor?.grok ?? {});
+  const moved = moveToResponsesText(req, body, "grok");
+  if (moved !== undefined)
+    note2(moved);
   return { body, degradations };
 }
 
@@ -30792,6 +31136,18 @@ function toKiloWire(req, model) {
     }
   }
   Object.assign(body, req.vendor?.kilo ?? {});
+  const read = readResponseFormatResult(req);
+  const format = read.kind === "readable" ? read.format : undefined;
+  if (format !== undefined && body.response_format === undefined) {
+    body.response_format = {
+      type: "json_schema",
+      json_schema: { name: format.name, schema: format.schema, strict: true }
+    };
+    note2("kilo:response-format-translated");
+  } else if (read.kind === "tooDeep") {
+    delete body.response_format;
+    note2("kilo:response-schema-too-deep");
+  }
   return { body, degradations };
 }
 
@@ -31043,6 +31399,18 @@ function toChatWire(req, model, vendor = "kimi") {
   if (req.reasoning !== undefined)
     note2("kimi:reasoning-dropped");
   Object.assign(body, req.vendor?.[vendor] ?? {});
+  const read = readResponseFormatResult(req);
+  const format = read.kind === "readable" ? read.format : undefined;
+  if (format !== undefined && body.response_format === undefined) {
+    body.response_format = {
+      type: "json_schema",
+      json_schema: { name: format.name, schema: format.schema, strict: true }
+    };
+    note2("kimi:response-format-translated");
+  } else if (read.kind === "tooDeep") {
+    delete body.response_format;
+    note2("kimi:response-schema-too-deep");
+  }
   return { body, degradations };
 }
 
@@ -31439,6 +31807,9 @@ function toMuseWire(req, model) {
   }
   const key = suppliedKey(req) ?? cacheKey(req, instructions ?? "", input2[0]);
   Object.assign(body, req.vendor?.openai ?? {});
+  const moved = moveToResponsesText(req, body, "muse");
+  if (moved !== undefined)
+    note2(moved);
   body.prompt_cache_key = key;
   return { body, degradations, cacheKey: key };
 }
@@ -31849,6 +32220,9 @@ function toResponsesWire(req, model, opts = { oauth: false }) {
   }
   const key = suppliedKey2(req) ?? cacheKey2(req, instructions ?? "", input2[0]);
   Object.assign(body, req.vendor?.openai ?? {});
+  const moved = moveToResponsesText(req, body, "openai");
+  if (moved !== undefined)
+    note2(moved);
   body.prompt_cache_key = key;
   return { body, degradations, cacheKey: key };
 }
@@ -34741,7 +35115,7 @@ function createRefresher(deps) {
 }
 // packages/control/src/pluginProviders.ts
 import { join as join5 } from "path";
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isNumber(value) {
@@ -34752,7 +35126,7 @@ function checkAt(ok, id, path, expected) {
     throw new Error(`provider ${id} descriptor: ${path} must be ${expected}`);
 }
 function checkLimits(id, path, value) {
-  checkAt(isRecord7(value), id, path, "an object");
+  checkAt(isRecord8(value), id, path, "an object");
   const limits = value;
   checkAt(isNumber(limits.contextWindow), id, `${path}.contextWindow`, "a finite number");
   checkAt(isNumber(limits.maxOutputTokens), id, `${path}.maxOutputTokens`, "a finite number");
@@ -34770,19 +35144,19 @@ function checkDescriptor(id, record2) {
     }
   }
   const capabilities2 = record2.capabilities;
-  checkAt(isRecord7(capabilities2), id, "capabilities", "an object");
+  checkAt(isRecord8(capabilities2), id, "capabilities", "an object");
   for (const flag of ["tools", "images", "reasoning"]) {
     const value = capabilities2[flag];
     checkAt(typeof value === "boolean", id, `capabilities.${flag}`, "a boolean");
   }
   const write = record2.writeOverInput;
-  checkAt(isRecord7(write), id, "writeOverInput", "an object");
+  checkAt(isRecord8(write), id, "writeOverInput", "an object");
   for (const ttl of ["fiveMinute", "oneHour"]) {
     const value = write[ttl];
     checkAt(isNumber(value), id, `writeOverInput.${ttl}`, "a finite number");
   }
   const catalog2 = record2.catalog;
-  checkAt(isRecord7(catalog2), id, "catalog", "an object");
+  checkAt(isRecord8(catalog2), id, "catalog", "an object");
   const entry = catalog2;
   checkAt(typeof entry.defaultModel === "string", id, "catalog.defaultModel", "a string");
   checkAt(Array.isArray(entry.authTypes), id, "catalog.authTypes", "an array");
@@ -34793,11 +35167,11 @@ function checkDescriptor(id, record2) {
   checkAt(Array.isArray(entry.models), id, "catalog.models", "an array");
   for (const [index, model] of entry.models.entries()) {
     const at = `catalog.models[${index}]`;
-    checkAt(isRecord7(model), id, at, "an object");
+    checkAt(isRecord8(model), id, at, "an object");
     const choice = model;
     checkAt(typeof choice.id === "string", id, `${at}.id`, "a string");
     checkAt(typeof choice.label === "string", id, `${at}.label`, "a string");
-    checkAt(isRecord7(choice.pricing), id, `${at}.pricing`, "an object");
+    checkAt(isRecord8(choice.pricing), id, `${at}.pricing`, "an object");
     const pricing = choice.pricing;
     for (const field of ["input", "output", "cacheRead", "cacheWrite5m", "cacheWrite1h"]) {
       checkAt(isNumber(pricing[field]), id, `${at}.pricing.${field}`, "a finite number");
@@ -34813,13 +35187,13 @@ function checkDescriptor(id, record2) {
     checkAt(typeof prefix === "string", id, `modelPrefixes[${index}]`, "a string");
   }
   const presentation = record2.presentation;
-  checkAt(isRecord7(presentation), id, "presentation", "an object");
+  checkAt(isRecord8(presentation), id, "presentation", "an object");
   const shown = presentation;
   for (const field of ["label", "tone"]) {
     checkAt(typeof shown[field] === "string", id, `presentation.${field}`, "a string");
   }
   checkAt(isNumber(shown.order), id, "presentation.order", "a finite number");
-  checkAt(isRecord7(shown.colour), id, "presentation.colour", "an object");
+  checkAt(isRecord8(shown.colour), id, "presentation.colour", "an object");
   for (const scheme of ["light", "dark"]) {
     const value = shown.colour[scheme];
     checkAt(typeof value === "string", id, `presentation.colour.${scheme}`, "a string");
@@ -34831,7 +35205,7 @@ function checkDescriptor(id, record2) {
 function validateOAuthFlow(id, value) {
   if (value === undefined)
     return;
-  if (!isRecord7(value))
+  if (!isRecord8(value))
     throw new Error(`provider ${id} oauth must be an object`);
   const kind = value.kind;
   if (kind !== "pkce" && kind !== "device") {
@@ -37525,7 +37899,7 @@ function createServiceDeps(input2) {
 }
 
 // apps/cli/src/version.ts
-var VERSION = "0.12.5";
+var VERSION = "0.12.7";
 
 // apps/cli/src/commands/service.ts
 function gatewayArgv(root) {