@sixb/core 0.1.21 → 0.1.22

package/dist/{chunk-29yx306f.js → chunk-tdxfsg1c.js}

@@ -1,9 +1,9 @@
 // @bun
 import {
-  MODEL_REASONING_EFFORTS2,
   MODEL_REASONING_LEVELS2,
-  modelReasoningSupportIssue2
-} from "./chunk-pqajwytd.js";
+  modelReasoningSupportIssue2,
+  defineLanguageModel2
+} from "./chunk-pdt5cw8z.js";
 import {
   RuntimeError2
 } from "./chunk-m4ehq95f.js";
@@ -28,8 +28,20 @@ class TranscriptionModelResponseError2 extends ModelProviderError2 {
     this.metadata = metadata;
   }
 }
+
+class SpeechModelResponseError2 extends ModelProviderError2 {
+  metadata;
+  constructor(message, providerId, modelId, metadata, options) {
+    super(message, providerId, modelId, {
+      ...options,
+      code: "invalid_speech_response",
+      retryable: false
+    });
+    this.metadata = metadata;
+  }
+}
 // src/models/catalog-index.ts
-function indexModelBindings(models, kind, validate) {
+function indexModelBindings(models, kind, validate, fields) {
   const byRef = new Map;
   for (const [index, model] of models.entries()) {
     validate(model, index);
@@ -37,7 +49,8 @@ function indexModelBindings(models, kind, validate) {
     if (byRef.has(key)) {
       throw new RuntimeError2(`[Sixb] Duplicate ${kind} model '${model.providerId}/${model.modelId}' in 'models.${kind}'. Each provider and model id pair may be configured once.`);
     }
-    byRef.set(key, Object.freeze({ provider: model.providerId, modelId: model.modelId, model }));
+    const entry = { provider: model.providerId, modelId: model.modelId, model };
+    byRef.set(key, Object.freeze(fields ? { ...entry, ...fields(index) } : entry));
   }
   const entries = Object.freeze([...byRef.values()]);
   return Object.freeze({
@@ -50,15 +63,28 @@ function indexModelBindings(models, kind, validate) {
 function createAudioCatalog(input) {
   if (input === undefined)
     return;
-  if (!input || typeof input !== "object" || Array.isArray(input) || !Array.isArray(input.transcription)) {
-    throw new TypeError("[Sixb] models.audio.transcription must be a nonempty array of transcription models.");
+  if (!input || typeof input !== "object" || Array.isArray(input) || input.transcription === undefined && input.speech === undefined) {
+    throw new TypeError("[Sixb] models.audio must configure transcription or speech models.");
+  }
+  const transcription = familyCatalog(input.transcription, "transcription", assertTranscriptionModel);
+  const speech = familyCatalog(input.speech, "speech", assertSpeechModel);
+  return Object.freeze({
+    ...transcription === undefined ? {} : { transcription },
+    ...speech === undefined ? {} : { speech }
+  });
+}
+function familyCatalog(models, family, validate) {
+  if (models === undefined)
+    return;
+  if (!Array.isArray(models)) {
+    throw new TypeError(`[Sixb] models.audio.${family} must be a nonempty array of ${family} models.`);
   }
-  const index = indexModelBindings(input.transcription, "audio.transcription", assertTranscriptionModel);
+  const index = indexModelBindings(models, `audio.${family}`, validate);
   const [defaultEntry] = index.list();
   if (!defaultEntry) {
-    throw new TypeError("[Sixb] models.audio.transcription must contain at least one model.");
+    throw new TypeError(`[Sixb] models.audio.${family} must contain at least one model.`);
   }
-  return Object.freeze({ transcription: Object.freeze({ ...index, default: defaultEntry }) });
+  return Object.freeze({ ...index, default: defaultEntry });
 }
 function assertTranscriptionModel(model) {
   const candidate = model;
@@ -80,6 +106,34 @@ function isValidId(value) {
 function invalidModel() {
   return new TypeError("[SixbModels] Invalid transcription model identity, definition or input limits.");
 }
+function assertSpeechModel(model) {
+  const candidate = model;
+  const definition = candidate?.definition;
+  if (!candidate || !isValidId(candidate.providerId) || !isValidId(candidate.modelId) || typeof candidate.speak !== "function" || definition?.kind !== "speech" || definition.providerId !== candidate.providerId || definition.modelId !== candidate.modelId) {
+    throw invalidSpeechModel("identity");
+  }
+  const limit = definition.maxInputCharacters;
+  if (limit !== undefined && (!Number.isSafeInteger(limit) || limit <= 0)) {
+    throw invalidSpeechModel("maxInputCharacters");
+  }
+  if (!isOptionalList(definition.voices))
+    throw invalidSpeechModel("voices");
+  if (!isOptionalList(definition.outputMediaTypes) || definition.outputMediaTypes?.some((type) => !/^audio\/[a-z0-9.+-]+$/.test(type))) {
+    throw invalidSpeechModel("outputMediaTypes");
+  }
+  if (definition.instructions !== undefined && typeof definition.instructions !== "boolean") {
+    throw invalidSpeechModel("instructions");
+  }
+  if (candidate.defaultVoice !== undefined && (!isValidId(candidate.defaultVoice) || definition.voices !== undefined && !definition.voices.includes(candidate.defaultVoice))) {
+    throw invalidSpeechModel("defaultVoice");
+  }
+}
+function isOptionalList(value) {
+  return value === undefined || Array.isArray(value) && value.length > 0 && value.every((entry) => isValidId(entry));
+}
+function invalidSpeechModel(field) {
+  return new TypeError(`[SixbModels] Invalid speech model ${field}.`);
+}
 
 // src/models/decision/validation.ts
 var DISTRIBUTION_TOLERANCE = 0.0001;
@@ -309,158 +363,49 @@ function createDecisionCatalog(models) {
   return Object.freeze({ ...index, default: defaultEntry });
 }
 
-// src/models/definitions.ts
-function defineLanguageModel2(definition) {
-  if (definition.kind !== "language") {
-    throw new TypeError("[Sixb] Language model definitions must use kind 'language'.");
-  }
-  assertModelId(definition.providerId, "providerId");
-  assertModelId(definition.modelId, "modelId");
-  assertOptionalString(definition.name, "name");
-  assertOptionalString(definition.description, "description");
-  assertOptionalString(definition.via, "via");
-  if (definition.via !== undefined && !definition.via.trim())
-    throw new TypeError("[Sixb] Model via must not be empty.");
-  const publisher = definition.publisher;
-  if (publisher !== undefined) {
-    assertRecord(publisher, "publisher");
-    for (const [field, value] of Object.entries({ id: publisher.id, name: publisher.name })) {
-      if (typeof value !== "string" || !value.trim() || value !== value.trim())
-        throw new TypeError(`[Sixb] Model publisher.${field} must be a nonempty trimmed string.`);
-    }
-  }
-  assertOptionalString(definition.family, "family");
-  assertOptionalString(definition.releaseDate, "releaseDate");
-  assertOptionalString(definition.knowledgeCutoff, "knowledgeCutoff");
-  const tags = freezeStrings(definition.tags, "tags");
-  const capabilities = defineModelCapabilities(definition.capabilities);
-  assertOptionalPositiveInteger(definition.contextWindow, "contextWindow");
-  assertOptionalPositiveInteger(definition.maxInputTokens, "maxInputTokens");
-  assertOptionalPositiveInteger(definition.maxOutputTokens, "maxOutputTokens");
-  return Object.freeze({
-    kind: "language",
-    providerId: definition.providerId,
-    modelId: definition.modelId,
-    ...definition.name === undefined ? {} : { name: definition.name },
-    ...definition.description === undefined ? {} : { description: definition.description },
-    ...publisher === undefined ? {} : { publisher: Object.freeze({ id: publisher.id, name: publisher.name }) },
-    ...definition.via === undefined ? {} : { via: definition.via },
-    ...definition.family === undefined ? {} : { family: definition.family },
-    ...tags === undefined ? {} : { tags },
-    ...definition.releaseDate === undefined ? {} : { releaseDate: definition.releaseDate },
-    ...definition.knowledgeCutoff === undefined ? {} : { knowledgeCutoff: definition.knowledgeCutoff },
-    ...definition.contextWindow === undefined ? {} : { contextWindow: definition.contextWindow },
-    ...definition.maxInputTokens === undefined ? {} : { maxInputTokens: definition.maxInputTokens },
-    ...definition.maxOutputTokens === undefined ? {} : { maxOutputTokens: definition.maxOutputTokens },
-    capabilities
-  });
-}
-function defineModelCapabilities(capabilities) {
-  assertRecord(capabilities, "capabilities");
-  const inputMediaTypes = capabilities.inputMediaTypes === "any" ? "any" : freezeStrings(capabilities.inputMediaTypes, "capabilities.inputMediaTypes");
-  for (const [field, value] of Object.entries(capabilities)) {
-    if (field === "inputMediaTypes" || field === "reasoning")
-      continue;
-    if (value !== undefined && typeof value !== "boolean") {
-      throw new TypeError(`[Sixb] Model capability '${field}' must be boolean.`);
-    }
+// src/models/image/catalog.ts
+function createImageCatalog(models) {
+  if (models === undefined)
+    return;
+  if (!Array.isArray(models)) {
+    throw new TypeError("[Sixb] models.image must be a nonempty array of image models.");
   }
-  const reasoning = freezeReasoningCapabilities(capabilities.reasoning);
-  const flags = {};
-  for (const key of [
-    "localTools",
-    "parallelToolCalls",
-    "nativeStructuredOutput",
-    "providerExecutedTools"
-  ]) {
-    const value = capabilities[key];
-    if (typeof value === "boolean")
-      flags[key] = value;
+  const index = indexModelBindings(models, "image", assertImageModel);
+  const [defaultEntry] = index.list();
+  if (!defaultEntry) {
+    throw new TypeError("[Sixb] models.image must contain at least one model.");
   }
-  return Object.freeze({
-    ...inputMediaTypes === undefined ? {} : { inputMediaTypes },
-    ...reasoning === undefined ? {} : { reasoning },
-    ...flags
-  });
+  return Object.freeze({ ...index, default: defaultEntry });
 }
-function freezeReasoningCapabilities(reasoning) {
-  if (reasoning === undefined || reasoning === false)
-    return reasoning;
-  assertRecord(reasoning, "reasoning");
-  if (reasoning.canDisable !== undefined && typeof reasoning.canDisable !== "boolean") {
-    throw new TypeError("[Sixb] Model reasoning capability 'canDisable' must be boolean.");
+function assertImageModel(model) {
+  const candidate = model;
+  const definition = candidate?.definition;
+  if (!candidate || !isValidId3(candidate.providerId) || !isValidId3(candidate.modelId) || typeof candidate.generate !== "function" || definition?.kind !== "image" || definition.providerId !== candidate.providerId || definition.modelId !== candidate.modelId) {
+    throw invalidModel2("identity");
   }
-  const efforts = freezeReasoningEfforts(reasoning.efforts);
-  const budgetTokens = freezeReasoningBudgetCapabilities(reasoning.budgetTokens);
-  return Object.freeze({
-    ...reasoning.canDisable === undefined ? {} : { canDisable: reasoning.canDisable },
-    ...efforts === undefined ? {} : { efforts },
-    ...budgetTokens === undefined ? {} : { budgetTokens }
-  });
-}
-function freezeReasoningEfforts(efforts) {
-  if (efforts === undefined)
-    return;
-  if (!Array.isArray(efforts)) {
-    throw new TypeError("[Sixb] Model reasoning capability 'efforts' must be an array.");
+  if (definition.maxImagesPerCall !== undefined && !isPositiveInteger(definition.maxImagesPerCall)) {
+    throw invalidModel2("maxImagesPerCall");
   }
-  const seen = new Set;
-  return Object.freeze(efforts.map((value) => {
-    const effort = MODEL_REASONING_EFFORTS2.find((allowed) => allowed === value);
-    if (effort === undefined) {
-      throw new TypeError(`[Sixb] Model reasoning effort '${String(value)}' is invalid.`);
-    }
-    if (seen.has(effort)) {
-      throw new TypeError(`[Sixb] Model reasoning effort '${effort}' is duplicated.`);
-    }
-    seen.add(effort);
-    return effort;
-  }));
-}
-function freezeReasoningBudgetCapabilities(budget) {
-  if (budget === undefined)
-    return;
-  assertRecord(budget, "reasoning budgetTokens");
-  assertOptionalNonnegativeInteger(budget.min, "capabilities.reasoning.budgetTokens.min");
-  assertOptionalNonnegativeInteger(budget.max, "capabilities.reasoning.budgetTokens.max");
-  if (budget.min !== undefined && budget.max !== undefined && budget.max < budget.min) {
-    throw new TypeError("[Sixb] Model reasoning token budget maximum must not be below its minimum.");
+  for (const field of ["sizes", "aspectRatios", "qualities", "styles"]) {
+    if (!isOptionalList2(definition[field]))
+      throw invalidModel2(field);
   }
-  return Object.freeze({
-    ...budget.min === undefined ? {} : { min: budget.min },
-    ...budget.max === undefined ? {} : { max: budget.max }
-  });
-}
-function assertModelId(value, field) {
-  if (!value.trim())
-    throw new TypeError(`[Sixb] Model ${field} must not be empty.`);
-}
-function assertOptionalPositiveInteger(value, field) {
-  if (value !== undefined && (!Number.isSafeInteger(value) || value <= 0)) {
-    throw new TypeError(`[Sixb] Model ${field} must be a positive safe integer.`);
+  const inputImages = definition.inputImages;
+  if (inputImages !== undefined && (!inputImages || !isPositiveInteger(inputImages.maxCount) || !isPositiveInteger(inputImages.maxBytes) || !isOptionalList2(inputImages.mediaTypes) || inputImages.mediaTypes?.some((type) => !/^image\/[a-z0-9.+-]+$/.test(type)))) {
+    throw invalidModel2("inputImages");
   }
 }
-function assertOptionalNonnegativeInteger(value, field) {
-  if (value !== undefined && (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0)) {
-    throw new TypeError(`[Sixb] Model ${field} must be a nonnegative safe integer.`);
-  }
+function isOptionalList2(value) {
+  return value === undefined || Array.isArray(value) && value.length > 0 && value.every((entry) => typeof entry === "string" && entry.trim() === entry && entry);
 }
-function assertOptionalString(value, field) {
-  if (value !== undefined && typeof value !== "string") {
-    throw new TypeError(`[Sixb] Model ${field} must be a string.`);
-  }
+function isPositiveInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
 }
-function freezeStrings(value, field) {
-  if (value === undefined)
-    return;
-  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string" || !entry.trim())) {
-    throw new TypeError(`[Sixb] Model ${field} must contain nonempty strings.`);
-  }
-  return Object.freeze([...value]);
+function isValidId3(value) {
+  return typeof value === "string" && value.length > 0 && value.trim() === value;
 }
-function assertRecord(value, field) {
-  if (value === null || typeof value !== "object" || Array.isArray(value))
-    throw new TypeError(`[Sixb] Model ${field} must be an object.`);
+function invalidModel2(field) {
+  return new TypeError(`[SixbModels] Invalid image model ${field}.`);
 }
 
 // src/models/reranking-model.ts
@@ -505,6 +450,14 @@ class RerankingModelResponseError2 extends ModelProviderError2 {
 }
 
 // src/models/catalog.ts
+var LANGUAGE_MODEL_TIERS2 = ["light", "standard", "heavy"];
+function isLanguageModelTier2(value) {
+  return LANGUAGE_MODEL_TIERS2.includes(value);
+}
+function formatLanguageModelTiers2() {
+  const last = LANGUAGE_MODEL_TIERS2.at(-1);
+  return `${LANGUAGE_MODEL_TIERS2.slice(0, -1).join(", ")} or ${last}`;
+}
 function createModelCatalog2(input) {
   if (!input || typeof input !== "object" || Array.isArray(input)) {
     throw new RuntimeError2("[Sixb] 'models' must be a model catalog configuration.");
@@ -513,11 +466,12 @@ function createModelCatalog2(input) {
   const embedding = createEmbeddingCatalog(input.embedding);
   const decision = createDecisionCatalog(input.decision);
   const audio = createAudioCatalog(input.audio);
+  const image = createImageCatalog(input.image);
   const reranking = createRerankingCatalog(input.reranking);
-  if (!language && !decision && !audio && embedding.list().length === 0 && !reranking?.list().length) {
-    throw new RuntimeError2("[Sixb] Configure at least one language, embedding, decision, audio or reranking model.");
+  if (!language && !decision && !audio && !image && embedding.list().length === 0 && !reranking?.list().length) {
+    throw new RuntimeError2("[Sixb] Configure at least one language, embedding, decision, audio, image or reranking model.");
   }
-  return Object.freeze({ language, embedding, decision, audio, reranking });
+  return Object.freeze({ language, embedding, decision, audio, image, reranking });
 }
 function createRerankingCatalog(models) {
   if (models === undefined)
@@ -527,21 +481,71 @@ function createRerankingCatalog(models) {
   }
   return indexModelBindings(models, "reranking", assertRerankingModel);
 }
-function createLanguageCatalog(models) {
-  if (models === undefined)
+function createLanguageCatalog(input) {
+  if (input === undefined)
     return;
-  if (!Array.isArray(models)) {
-    throw new RuntimeError2("[Sixb] 'models.language' must be an array of Sixb language models.");
-  }
-  const index = indexModelBindings(models, "language", (model, position) => {
-    assertLanguageModel(model, position);
-    assertDefaultReasoning(model, position);
+  const configured = configuredLanguageModels(input);
+  const index = indexModelBindings(configured.map(({ model }) => model), "language", (model, position) => {
+    const { path } = configured[position];
+    assertValidLanguageModel(model, (detail) => invalidLanguageModel(path, detail));
+  }, (position) => {
+    const { tier } = configured[position];
+    return tier === undefined ? {} : { tier };
   });
-  const [defaultEntry] = index.list();
+  const entries = index.list();
+  const defaultEntry = entries.find((entry) => entry.tier === "standard") ?? entries[0];
   if (!defaultEntry) {
     throw new RuntimeError2("[Sixb] 'models.language' needs at least one model. Configure one or omit 'models.language'.");
   }
-  return Object.freeze({ ...index, default: defaultEntry });
+  const tiers = LANGUAGE_MODEL_TIERS2.filter((tier) => entries.some((entry) => entry.tier === tier));
+  return Object.freeze({
+    ...index,
+    default: defaultEntry,
+    tiers: Object.freeze(tiers),
+    getByTier: (tier) => entries.find((entry) => entry.tier === tier) ?? defaultEntry
+  });
+}
+function selectLanguageModel2(catalog, model) {
+  if (model === undefined)
+    return catalog?.default.model;
+  if (typeof model !== "string")
+    return model;
+  if (!isLanguageModelTier2(model)) {
+    throw new TypeError(`[Sixb] Unknown model tier '${model}'. Use ${formatLanguageModelTiers2()}, or pass a model.`);
+  }
+  return catalog?.getByTier(model).model;
+}
+function configuredLanguageModels(input) {
+  if (Array.isArray(input)) {
+    return input.map((model, index) => ({ model, path: `models.language[${index}]` }));
+  }
+  if (typeof input !== "object" || input === null) {
+    throw new RuntimeError2("[Sixb] 'models.language' must be an array of Sixb language models, or tiers: { light, standard, heavy }.");
+  }
+  const unknown = Object.keys(input).find((key) => !isLanguageModelTier2(key));
+  if (unknown !== undefined) {
+    throw new RuntimeError2(`[Sixb] Unknown model tier '${unknown}' in 'models.language'. Use ${formatLanguageModelTiers2()}, or pass an array of models.`);
+  }
+  const tiers = input;
+  if (tiers.standard === undefined) {
+    throw new RuntimeError2("[Sixb] 'models.language' tiers need 'standard': its first model is the project default.");
+  }
+  return LANGUAGE_MODEL_TIERS2.flatMap((tier) => {
+    const models = tiers[tier];
+    if (models === undefined)
+      return [];
+    if (!Array.isArray(models)) {
+      return [{ model: models, tier, path: `models.language.${tier}` }];
+    }
+    if (models.length === 0) {
+      throw new RuntimeError2(`[Sixb] 'models.language.${tier}' needs at least one model.`);
+    }
+    return models.map((model, index) => ({
+      model,
+      tier,
+      path: `models.language.${tier}[${index}]`
+    }));
+  });
 }
 function createEmbeddingCatalog(models) {
   if (models !== undefined && !Array.isArray(models)) {
@@ -549,27 +553,44 @@ function createEmbeddingCatalog(models) {
   }
   return indexModelBindings(models ?? [], "embedding", assertEmbeddingModel);
 }
-function assertDefaultReasoning(model, index) {
+function assertValidLanguageModel(model, fail) {
+  assertLanguageModel(model, fail);
+  assertDefaultReasoning(model, fail);
+  assertMaxOutputTokens(model, fail);
+}
+function assertDefaultReasoning(model, fail) {
   const reasoning = model.defaultReasoning;
   if (reasoning === undefined)
     return;
   if (!MODEL_REASONING_LEVELS2.includes(reasoning)) {
-    throw invalidLanguageModel(index, `expected 'defaultReasoning' to be one of: ${MODEL_REASONING_LEVELS2.join(", ")}`);
+    throw fail(`expected 'defaultReasoning' to be one of: ${MODEL_REASONING_LEVELS2.join(", ")}`);
   }
   const issue = modelReasoningSupportIssue2(model.definition.capabilities.reasoning, reasoning);
   if (issue !== undefined) {
-    throw invalidLanguageModel(index, `default reasoning '${reasoning}' cannot be used: ${issue}`);
+    throw fail(`default reasoning '${reasoning}' cannot be used: ${issue}`);
   }
 }
-function assertLanguageModel(model, index) {
+function assertMaxOutputTokens(model, fail) {
+  const maxOutputTokens = model.maxOutputTokens;
+  if (maxOutputTokens === undefined)
+    return;
+  if (typeof maxOutputTokens !== "number" || !Number.isSafeInteger(maxOutputTokens) || maxOutputTokens <= 0) {
+    throw fail("expected 'maxOutputTokens' to be a positive safe integer");
+  }
+  const modelMaximum = model.definition.maxOutputTokens;
+  if (modelMaximum !== undefined && maxOutputTokens > modelMaximum) {
+    throw fail(`'maxOutputTokens' (${maxOutputTokens}) exceeds the model maximum (${modelMaximum})`);
+  }
+}
+function assertLanguageModel(model, fail) {
   if (typeof model !== "object" && typeof model !== "function" || model === null) {
-    throw invalidLanguageModel(index, "expected a Sixb LanguageModel instance");
+    throw fail("expected a Sixb LanguageModel instance");
   }
   const candidate = model;
-  assertModelIdentifier(candidate.providerId, "provider", index);
-  assertModelIdentifier(candidate.modelId, "modelId", index);
+  assertModelIdentifier(candidate.providerId, "provider", fail);
+  assertModelIdentifier(candidate.modelId, "modelId", fail);
   if (typeof candidate.stream !== "function") {
-    throw invalidLanguageModel(index, "expected 'stream' to be a function");
+    throw fail("expected 'stream' to be a function");
   }
   try {
     const definition = defineLanguageModel2(candidate.definition);
@@ -577,19 +598,19 @@ function assertLanguageModel(model, index) {
       throw new Error("definition identity does not match the binding");
     }
   } catch (error) {
-    throw invalidLanguageModel(index, error instanceof Error ? error.message : "invalid definition");
+    throw fail(error instanceof Error ? error.message : "invalid definition");
   }
 }
-function assertModelIdentifier(value, field, index) {
+function assertModelIdentifier(value, field, fail) {
   if (typeof value !== "string" || value.length === 0) {
-    throw invalidLanguageModel(index, `expected '${field}' to be a non-empty string`);
+    throw fail(`expected '${field}' to be a non-empty string`);
   }
   if (value.trim() !== value) {
-    throw invalidLanguageModel(index, `expected '${field}' not to have surrounding whitespace`);
+    throw fail(`expected '${field}' not to have surrounding whitespace`);
   }
 }
-function invalidLanguageModel(index, detail) {
-  return new RuntimeError2(`[Sixb] Invalid language model at 'models.language[${index}]': ${detail}.`);
+function invalidLanguageModel(path, detail) {
+  return new RuntimeError2(`[Sixb] Invalid language model at '${path}': ${detail}.`);
 }
 // src/models/decision/errors.ts
 class DecisionModelResponseError2 extends ModelProviderError2 {
@@ -672,6 +693,157 @@ var question2 = {
     return result;
   }
 };
+// src/models/image/errors.ts
+class ImageModelResponseError2 extends ModelProviderError2 {
+  metadata;
+  constructor(message, providerId, modelId, metadata, options) {
+    super(message, providerId, modelId, {
+      ...options,
+      code: "invalid_image_response",
+      retryable: false
+    });
+    this.metadata = metadata;
+  }
+}
+// src/models/rate-card.ts
+var PRICING_DIMENSIONS = ["size", "quality", "style", "voiceTier"];
+var TOKEN_DETAIL_FIELDS = [
+  "cacheReadInput",
+  "cacheWriteInput",
+  "cacheWriteInput5m",
+  "cacheWriteInput1h",
+  "imageOutput",
+  "audioOutput"
+];
+function defineModelRateCard2(rateCard) {
+  assertRecord(rateCard, "rate card");
+  if (rateCard.currency !== "USD") {
+    throw new TypeError("[Sixb] Model rate cards must use USD.");
+  }
+  const tokens = rateCard.input !== undefined || rateCard.output !== undefined;
+  if (tokens && (rateCard.input === undefined || rateCard.output === undefined)) {
+    throw new TypeError("[Sixb] Model rate cards must price input and output tokens together.");
+  }
+  if (!tokens && TOKEN_DETAIL_FIELDS.some((field) => rateCard[field] !== undefined)) {
+    throw new TypeError("[Sixb] Model rate card token details require input and output prices.");
+  }
+  if (!tokens && rateCard.images === undefined && rateCard.characters === undefined && rateCard.audioInputSeconds === undefined) {
+    throw new TypeError("[Sixb] Model rate cards must price tokens, images, characters or audio.");
+  }
+  if (rateCard.images !== undefined && rateCard.imageOutput !== undefined) {
+    throw new TypeError("[Sixb] Model rate cards bill image output per image or per token, not both.");
+  }
+  return Object.freeze({
+    currency: "USD",
+    ...tokens ? { input: tokenPrice(rateCard.input), output: tokenPrice(rateCard.output) } : {},
+    ...rateCard.cacheReadInput === undefined ? {} : { cacheReadInput: tokenPrice(rateCard.cacheReadInput) },
+    ...rateCard.cacheWriteInput === undefined ? {} : { cacheWriteInput: tokenPrice(rateCard.cacheWriteInput) },
+    ...rateCard.cacheWriteInput5m === undefined ? {} : { cacheWriteInput5m: tokenPrice(rateCard.cacheWriteInput5m) },
+    ...rateCard.cacheWriteInput1h === undefined ? {} : { cacheWriteInput1h: tokenPrice(rateCard.cacheWriteInput1h) },
+    ...rateCard.imageOutput === undefined ? {} : { imageOutput: tokenPrice(rateCard.imageOutput) },
+    ...rateCard.audioOutput === undefined ? {} : { audioOutput: tokenPrice(rateCard.audioOutput) },
+    ...rateCard.images === undefined ? {} : { images: variantPrice(rateCard.images, "images") },
+    ...rateCard.characters === undefined ? {} : { characters: variantPrice(rateCard.characters, "characters") },
+    ...rateCard.audioInputSeconds === undefined ? {} : { audioInputSeconds: variantPrice(rateCard.audioInputSeconds, "audioInputSeconds") }
+  });
+}
+function resolveModelVariantPrice(price, dimensions) {
+  if (typeof price === "string")
+    return { price };
+  const variant = price.variants.find((candidate) => PRICING_DIMENSIONS.every((dimension) => candidate[dimension] === undefined || candidate[dimension] === dimensions?.[dimension]));
+  if (variant) {
+    const label = PRICING_DIMENSIONS.flatMap((dimension) => variant[dimension] ?? []).join(" \xB7 ");
+    return { price: variant.price, variant: label };
+  }
+  return price.default === undefined ? undefined : { price: price.default };
+}
+function modelVariantPrices(price) {
+  if (typeof price === "string")
+    return [price];
+  return [
+    ...price.default === undefined ? [] : [price.default],
+    ...price.variants.map((variant) => variant.price)
+  ];
+}
+function variantPrice(value, field) {
+  if (typeof value === "string")
+    return price(value);
+  assertRecord(value, `${field} price`);
+  if (!Array.isArray(value.variants) || value.variants.length === 0) {
+    throw new TypeError(`[Sixb] Model ${field} price variants must be a nonempty array.`);
+  }
+  let shape;
+  const seen = new Set;
+  const variants = value.variants.map((variant) => {
+    assertRecord(variant, `${field} price variant`);
+    const dimensions = {};
+    for (const dimension of PRICING_DIMENSIONS) {
+      const named = variant[dimension];
+      if (named === undefined)
+        continue;
+      if (typeof named !== "string" || !named.trim()) {
+        throw new TypeError(`[Sixb] Model ${field} price variant ${dimension} must be nonblank.`);
+      }
+      dimensions[dimension] = named;
+    }
+    const key = Object.keys(dimensions).join(",");
+    if (!key || shape !== undefined && key !== shape) {
+      throw new TypeError(`[Sixb] Model ${field} price variants must all name the same pricing dimensions.`);
+    }
+    shape = key;
+    const identity = JSON.stringify(Object.values(dimensions));
+    if (seen.has(identity)) {
+      throw new TypeError(`[Sixb] Model ${field} price variants must be distinct.`);
+    }
+    seen.add(identity);
+    return Object.freeze({ ...dimensions, price: price(variant.price) });
+  });
+  return Object.freeze({
+    ...value.default === undefined ? {} : { default: price(value.default) },
+    variants: Object.freeze(variants)
+  });
+}
+function tokenPrice(value) {
+  if (typeof value === "string")
+    return price(value);
+  assertRecord(value, "token price");
+  if (!Array.isArray(value.tiers))
+    throw new TypeError("[Sixb] Model price tiers must be an array.");
+  let previousMax = 0;
+  return Object.freeze({
+    default: price(value.default),
+    tiers: Object.freeze(value.tiers.map((tier, index) => {
+      assertRecord(tier, "price tier");
+      if (typeof tier.minTokens !== "number" || !Number.isSafeInteger(tier.minTokens) || tier.minTokens < 0) {
+        throw new TypeError("[Sixb] Model price tier has an invalid minimum.");
+      }
+      if (index > 0 && tier.minTokens < previousMax) {
+        throw new TypeError("[Sixb] Model price tiers must be ordered and nonoverlapping.");
+      }
+      if (tier.maxTokens !== undefined && (typeof tier.maxTokens !== "number" || !Number.isSafeInteger(tier.maxTokens) || tier.maxTokens <= tier.minTokens)) {
+        throw new TypeError("[Sixb] Model price tier has an invalid maximum.");
+      }
+      previousMax = tier.maxTokens ?? Number.POSITIVE_INFINITY;
+      return Object.freeze({
+        minTokens: tier.minTokens,
+        ...tier.maxTokens === undefined ? {} : { maxTokens: tier.maxTokens },
+        price: price(tier.price)
+      });
+    }))
+  });
+}
+function price(value) {
+  if (typeof value !== "string" || !/^(?:0|[1-9]\d*)(?:\.\d+)?$/.test(value)) {
+    throw new TypeError("[Sixb] Model price must be a nonnegative decimal string.");
+  }
+  return value;
+}
+function assertRecord(value, field) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new TypeError(`[Sixb] Model ${field} must be an object.`);
+  }
+}
+
 // src/models/pricing.ts
 function estimateModelCall(model, input) {
   try {
@@ -681,33 +853,59 @@ function estimateModelCall(model, input) {
     return { status: "unpriceable", reason: "missing-rate-card" };
   }
 }
+function pricesTokens(card) {
+  return card.input !== undefined && card.output !== undefined;
+}
 function estimateModelReservation2(input) {
   if (!input.rateCard)
     return;
-  if (![input.inputTokens, input.outputTokens].every((n) => Number.isSafeInteger(n) && n >= 0)) {
-    throw new TypeError("[Sixb] Model reservation token estimates must be nonnegative safe integers.");
+  const counts = [input.inputTokens, input.outputTokens, input.outputImages, input.inputCharacters];
+  if (!counts.every((n) => n === undefined || Number.isSafeInteger(n) && n >= 0)) {
+    throw new TypeError("[Sixb] Model reservation estimates must be nonnegative safe integers.");
   }
   const maxRate = (prices) => {
     const rates = prices.flatMap((price) => price === undefined ? [] : typeof price === "string" ? [price] : [price.default, ...price.tiers.map((tier) => tier.price)]);
-    return rates.reduce((max, price) => {
-      const rate = decimalDollarsToNanos(price);
-      return rate > max ? rate : max;
-    }, 0n);
+    return highestRate(rates);
   };
   const card = input.rateCard;
-  const inputRate = maxRate([
-    card.input,
-    card.cacheReadInput,
-    card.cacheWriteInput,
-    card.cacheWriteInput5m,
-    card.cacheWriteInput1h
-  ]);
-  const outputRate = maxRate([card.output]);
-  const charge = (tokens, rate) => (BigInt(tokens) * rate + 999999n) / 1000000n;
-  return {
-    currency: "USD",
-    amountNanos: (charge(input.inputTokens, inputRate) + charge(input.outputTokens, outputRate)).toString()
-  };
+  const charge = (quantity, rate) => (BigInt(quantity) * rate + 999999n) / 1000000n;
+  let total = 0n;
+  if (pricesTokens(card)) {
+    if (input.inputTokens === undefined || input.outputTokens === undefined)
+      return;
+    const inputRate = maxRate([
+      card.input,
+      card.cacheReadInput,
+      card.cacheWriteInput,
+      card.cacheWriteInput5m,
+      card.cacheWriteInput1h
+    ]);
+    const outputRate = maxRate([card.output, card.imageOutput, card.audioOutput]);
+    total += charge(input.inputTokens, inputRate) + charge(input.outputTokens, outputRate);
+  }
+  if (card.images !== undefined) {
+    if (input.outputImages === undefined)
+      return;
+    total += BigInt(input.outputImages) * reservationPrice(card.images, input.dimensions);
+  }
+  if (card.audioInputSeconds !== undefined)
+    return;
+  if (card.characters !== undefined) {
+    if (input.inputCharacters === undefined)
+      return;
+    total += charge(input.inputCharacters, reservationPrice(card.characters, input.dimensions));
+  }
+  return { currency: "USD", amountNanos: total.toString() };
+}
+function reservationPrice(price, dimensions) {
+  const resolved = resolveModelVariantPrice(price, dimensions);
+  return resolved?.variant !== undefined || typeof price === "string" ? decimalDollarsToNanos(resolved.price) : highestRate(modelVariantPrices(price));
+}
+function highestRate(prices) {
+  return prices.reduce((max, price) => {
+    const rate = decimalDollarsToNanos(price);
+    return rate > max ? rate : max;
+  }, 0n);
 }
 function rateModelCall2(input) {
   if (input.reported) {
@@ -724,6 +922,57 @@ function rateModelCall2(input) {
   if (!validUsageCounters(usage)) {
     return { status: "unpriceable", reason: "inconsistent-usage" };
   }
+  const units = rateUnits(usage, rateCard, input.dimensions);
+  if (!Array.isArray(units))
+    return units;
+  const tokens = pricesTokens(rateCard) ? rateTokens(usage, rateCard) : [];
+  if (!Array.isArray(tokens))
+    return tokens;
+  const components = [...tokens, ...units];
+  const total = components.reduce((sum, entry) => sum + BigInt(entry.chargeAmountNanos), 0n);
+  return {
+    status: "rated",
+    money: { currency: rateCard.currency, amountNanos: total.toString() },
+    components
+  };
+}
+function rateUnits(usage, rateCard, dimensions) {
+  if (!pricesTokens(rateCard)) {
+    const unpriced = [
+      ...(usage.outputImages ?? 0) > 0 && rateCard.images === undefined ? ["images.output"] : [],
+      ...(usage.inputCharacters ?? 0) > 0 && rateCard.characters === undefined ? ["characters.input"] : []
+    ];
+    if (unpriced.length > 0) {
+      return { status: "unpriceable", reason: "missing-rate-card", missingMeters: unpriced };
+    }
+  }
+  const components = [];
+  const missing = [];
+  for (const [meter, quantity, price, exponent] of [
+    ["images.output", usage.outputImages, rateCard.images, 15],
+    ["characters.input", usage.inputCharacters, rateCard.characters, 9],
+    ["audio.input.milliseconds", usage.audioDurationMs, rateCard.audioInputSeconds, 12]
+  ]) {
+    if (price === undefined)
+      continue;
+    if (quantity === undefined) {
+      missing.push(meter);
+      continue;
+    }
+    if (quantity === 0 && pricesTokens(rateCard))
+      continue;
+    const resolved = resolveModelVariantPrice(price, dimensions) ?? (quantity === 0 ? zero : null);
+    if (!resolved)
+      return { status: "unpriceable", reason: "unsupported-pricing-dimension" };
+    components.push(componentAtRate(meter, quantity, scaledDecimal(resolved.price, exponent), resolved.variant));
+  }
+  if (missing.length > 0) {
+    return { status: "unpriceable", reason: "missing-usage", missingMeters: missing };
+  }
+  return components;
+}
+var zero = { price: "0" };
+function rateTokens(usage, rateCard) {
   if (usage.inputTokens === undefined || usage.outputTokens === undefined) {
     return {
       status: "unpriceable",
@@ -755,13 +1004,54 @@ function rateModelCall2(input) {
       components.push(component("tokens.input.cacheWrite1h", partitioned.cacheWrite1h, rateCard.cacheWriteInput1h ?? rateCard.cacheWriteInput, usage.inputTokens));
     }
   }
-  components.push(component("tokens.output.total", usage.outputTokens, rateCard.output, usage.inputTokens));
-  const total = components.reduce((sum, entry) => sum + BigInt(entry.chargeAmountNanos), 0n);
-  return {
-    status: "rated",
-    money: { currency: rateCard.currency, amountNanos: total.toString() },
-    components
-  };
+  const output = rateOutputTokens(usage, usage.outputTokens, usage.inputTokens, rateCard);
+  if (!Array.isArray(output))
+    return output;
+  return [...components, ...output];
+}
+function rateOutputTokens(usage, outputTokens, tierTokens, rateCard) {
+  const imagesCoverTokens = rateCard.images !== undefined && (usage.outputImages ?? 0) > 0;
+  const missing = [];
+  if ((imagesCoverTokens || rateCard.imageOutput !== undefined) && usage.imageOutputTokens === undefined) {
+    missing.push("tokens.output.image");
+  }
+  if (rateCard.audioOutput !== undefined && usage.audioOutputTokens === undefined) {
+    missing.push("tokens.output.audio");
+  }
+  if (missing.length > 0) {
+    return { status: "unpriceable", reason: "missing-usage", missingMeters: missing };
+  }
+  const covered = imagesCoverTokens ? usage.imageOutputTokens : 0;
+  const media = [];
+  if (!imagesCoverTokens && rateCard.imageOutput !== undefined && usage.imageOutputTokens > 0) {
+    media.push(component("tokens.output.image", usage.imageOutputTokens, rateCard.imageOutput, tierTokens));
+  }
+  if (rateCard.audioOutput !== undefined && usage.audioOutputTokens > 0) {
+    media.push(component("tokens.output.audio", usage.audioOutputTokens, rateCard.audioOutput, tierTokens));
+  }
+  if (covered === 0 && media.length === 0) {
+    return [component("tokens.output.total", outputTokens, rateCard.output, tierTokens)];
+  }
+  const remainder = outputTokens - covered - media.reduce((sum, entry) => sum + Number(entry.quantity), 0);
+  if (remainder < 0)
+    return { status: "unpriceable", reason: "inconsistent-usage" };
+  const text = usage.textOutputTokens;
+  const reasoning = usage.reasoningOutputTokens;
+  if (remainder > 0 && text === undefined) {
+    return { status: "unpriceable", reason: "missing-usage", missingMeters: ["tokens.output.text"] };
+  }
+  if (remainder > 0 && text + (reasoning ?? 0) !== remainder) {
+    return reasoning === undefined ? {
+      status: "unpriceable",
+      reason: "missing-usage",
+      missingMeters: ["tokens.output.reasoning"]
+    } : { status: "unpriceable", reason: "inconsistent-usage" };
+  }
+  return [
+    ...remainder > 0 && text > 0 ? [component("tokens.output.text", text, rateCard.output, tierTokens)] : [],
+    ...remainder > 0 && (reasoning ?? 0) > 0 ? [component("tokens.output.reasoning", reasoning, rateCard.output, tierTokens)] : [],
+    ...media
+  ];
 }
 function partitionInputUsage(usage, rateCard) {
   const hasSpecificWrites = usage.cacheWrite5mInputTokens !== undefined || usage.cacheWrite1hInputTokens !== undefined;
@@ -842,13 +1132,16 @@ function validUsageCounters(usage) {
   return Object.entries(usage).filter(([key]) => key !== "raw").every(([, value]) => value === undefined || Number.isSafeInteger(value) && value >= 0);
 }
 function component(meter, quantity, price, tierTokens) {
-  const rate = decimalDollarsToNanos(resolvePrice(price, tierTokens));
+  return componentAtRate(meter, quantity, decimalDollarsToNanos(resolvePrice(price, tierTokens)));
+}
+function componentAtRate(meter, quantity, rate, variant) {
   const charge = (BigInt(quantity) * rate + 500000n) / 1000000n;
   return {
     meter,
     quantity: quantity.toString(),
     rateAmountNanosPerMillion: rate.toString(),
-    chargeAmountNanos: charge.toString()
+    chargeAmountNanos: charge.toString(),
+    ...variant ? { variant } : {}
   };
 }
 function resolvePrice(price, tokens) {
@@ -856,6 +1149,12 @@ function resolvePrice(price, tokens) {
     return price;
   return price.tiers.find((tier) => tokens >= tier.minTokens && (tier.maxTokens === undefined || tokens < tier.maxTokens))?.price ?? price.default;
 }
+function scaledDecimal(value, exponent) {
+  const [whole = "0", fraction = ""] = value.split(".");
+  const kept = fraction.slice(0, exponent).padEnd(exponent, "0");
+  const roundUp = Number(fraction[exponent] ?? "0") >= 5;
+  return BigInt(whole) * 10n ** BigInt(exponent) + BigInt(kept) + (roundUp ? 1n : 0n);
+}
 function decimalDollarsToNanos(value) {
   const [whole = "0", fraction = ""] = value.split(".");
   const nanos = fraction.slice(0, 9).padEnd(9, "0");
@@ -867,63 +1166,6 @@ function assertAmountNanos(value) {
     throw new TypeError("[Sixb] Provider-reported model cost must use nonnegative amountNanos.");
   }
 }
-// src/models/rate-card.ts
-function defineModelRateCard2(rateCard) {
-  assertRecord2(rateCard, "rate card");
-  if (rateCard.currency !== "USD" || rateCard.unit !== "million-tokens") {
-    throw new TypeError("[Sixb] Model rate cards must use USD per million tokens.");
-  }
-  return Object.freeze({
-    currency: "USD",
-    unit: "million-tokens",
-    input: tokenPrice(rateCard.input),
-    output: tokenPrice(rateCard.output),
-    ...rateCard.cacheReadInput === undefined ? {} : { cacheReadInput: tokenPrice(rateCard.cacheReadInput) },
-    ...rateCard.cacheWriteInput === undefined ? {} : { cacheWriteInput: tokenPrice(rateCard.cacheWriteInput) },
-    ...rateCard.cacheWriteInput5m === undefined ? {} : { cacheWriteInput5m: tokenPrice(rateCard.cacheWriteInput5m) },
-    ...rateCard.cacheWriteInput1h === undefined ? {} : { cacheWriteInput1h: tokenPrice(rateCard.cacheWriteInput1h) }
-  });
-}
-function tokenPrice(value) {
-  if (typeof value === "string")
-    return price(value);
-  assertRecord2(value, "token price");
-  if (!Array.isArray(value.tiers))
-    throw new TypeError("[Sixb] Model price tiers must be an array.");
-  let previousMax = 0;
-  return Object.freeze({
-    default: price(value.default),
-    tiers: Object.freeze(value.tiers.map((tier, index) => {
-      assertRecord2(tier, "price tier");
-      if (typeof tier.minTokens !== "number" || !Number.isSafeInteger(tier.minTokens) || tier.minTokens < 0) {
-        throw new TypeError("[Sixb] Model price tier has an invalid minimum.");
-      }
-      if (index > 0 && tier.minTokens < previousMax) {
-        throw new TypeError("[Sixb] Model price tiers must be ordered and nonoverlapping.");
-      }
-      if (tier.maxTokens !== undefined && (typeof tier.maxTokens !== "number" || !Number.isSafeInteger(tier.maxTokens) || tier.maxTokens <= tier.minTokens)) {
-        throw new TypeError("[Sixb] Model price tier has an invalid maximum.");
-      }
-      previousMax = tier.maxTokens ?? Number.POSITIVE_INFINITY;
-      return Object.freeze({
-        minTokens: tier.minTokens,
-        ...tier.maxTokens === undefined ? {} : { maxTokens: tier.maxTokens },
-        price: price(tier.price)
-      });
-    }))
-  });
-}
-function price(value) {
-  if (typeof value !== "string" || !/^(?:0|[1-9]\d*)(?:\.\d+)?$/.test(value)) {
-    throw new TypeError("[Sixb] Model price must be a nonnegative decimal string.");
-  }
-  return value;
-}
-function assertRecord2(value, field) {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    throw new TypeError(`[Sixb] Model ${field} must be an object.`);
-  }
-}
-export { TranscriptionModelResponseError2, indexModelBindings, assertTranscriptionModel, assertDecisionContent, assertDecisionQuestions, assertDecisionModel, assertDecisionSupport, validateDecisionAnswers, defineLanguageModel2, assertRerankingModel, validateRerankingResults, RerankingModelResponseError2, createModelCatalog2, DecisionModelResponseError2, decisionOutput2, question2, estimateModelCall, estimateModelReservation2, rateModelCall2, defineModelRateCard2 };
+export { TranscriptionModelResponseError2, SpeechModelResponseError2, indexModelBindings, assertTranscriptionModel, assertSpeechModel, assertDecisionContent, assertDecisionQuestions, assertDecisionModel, assertDecisionSupport, supportsQuestion, validateDecisionAnswers, assertImageModel, assertRerankingModel, validateRerankingResults, RerankingModelResponseError2, LANGUAGE_MODEL_TIERS2, isLanguageModelTier2, formatLanguageModelTiers2, createModelCatalog2, selectLanguageModel2, assertValidLanguageModel, DecisionModelResponseError2, decisionOutput2, question2, ImageModelResponseError2, defineModelRateCard2, estimateModelCall, estimateModelReservation2, rateModelCall2 };
 
-//# debugId=728EDA0657BA3E0264756E2164756E21
+//# debugId=E4BBE679612780A264756E2164756E21