@sixb/core 0.1.11 → 0.1.12

package/dist/{chunk-jsy70480.js → chunk-2h63nrde.js}

@@ -2,11 +2,266 @@
 import {
   MODEL_REASONING_EFFORTS2
 } from "./chunk-pqajwytd.js";
+import {
+  ModelProviderError2,
+  UnsupportedModelFeatureError2,
+  assertEmbeddingModel
+} from "./chunk-p1683c0v.js";
+import {
+  assertJsonValue2,
+  cloneJsonValue2
+} from "./chunk-wy0qdqfm.js";
 // src/runtime/errors.ts
 class RuntimeError2 extends Error {
   name = "RuntimeError";
 }
 
+// src/models/catalog-index.ts
+function indexModelBindings(models, kind, validate) {
+  const byRef = new Map;
+  for (const [index, model] of models.entries()) {
+    validate(model, index);
+    const key = JSON.stringify([model.providerId, model.modelId]);
+    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 entries = Object.freeze([...byRef.values()]);
+  return Object.freeze({
+    list: () => entries,
+    getByRef: (ref) => byRef.get(JSON.stringify([ref.provider, ref.modelId])) ?? null
+  });
+}
+
+// src/models/decision/validation.ts
+var DISTRIBUTION_TOLERANCE = 0.0001;
+var CHOICE_TOLERANCE = 0.000001;
+function assertDecisionContent(value, path) {
+  assertJsonValue2(value, path);
+  if (value === null || typeof value !== "string" && typeof value !== "object") {
+    throw new TypeError(`[SixbModels] ${path} must be text, a JSON object or an array.`);
+  }
+}
+function assertDecisionQuestions(value) {
+  assertJsonValue2(value, "questions");
+  const questions = readRecord(value, "questions");
+  if (!Object.keys(questions).length) {
+    fail("questions must not be empty");
+  }
+  for (const [key, question] of Object.entries(questions)) {
+    if (!key.trim()) {
+      fail("question names must not be empty");
+    }
+    assertQuestion(question, `questions.${key}`);
+  }
+}
+function assertQuestion(value, path) {
+  const question = readRecord(value, path);
+  assertDecisionContent(question.instructions, `${path}.instructions`);
+  if (typeof question.instructions === "string" && !question.instructions.trim()) {
+    fail(`${path}.instructions must not be empty`);
+  }
+  switch (question.type) {
+    case "choice":
+      assertOnlyKeys(question, ["type", "instructions", "options"], path);
+      assertChoiceOptions(question.options, `${path}.options`);
+      break;
+    case "score":
+      assertOnlyKeys(question, ["type", "instructions", "levels"], path);
+      assertScoreLevels(question.levels, `${path}.levels`);
+      break;
+    case "probability":
+      assertOnlyKeys(question, ["type", "instructions"], path);
+      break;
+    default:
+      fail(`${path}.type is not a supported decision primitive`);
+  }
+}
+function assertChoiceOptions(value, path) {
+  const options = readRecord(value, path);
+  if (!Object.keys(options).length) {
+    fail(`${path} must not be empty`);
+  }
+  for (const [option, description] of Object.entries(options)) {
+    if (!option.trim()) {
+      fail(`${path} contains an empty label`);
+    }
+    if (description !== null) {
+      assertDecisionContent(description, `${path}.${option}`);
+    }
+  }
+}
+function assertScoreLevels(value, path) {
+  if (!Array.isArray(value) || value.length < 2) {
+    fail(`${path} needs at least two levels`);
+  }
+  for (const level of value) {
+    assertDecisionContent(level, path);
+  }
+}
+function assertDecisionModel(model) {
+  const definition = model?.definition;
+  if (!model || typeof model.evaluate !== "function" || !isValidId(model.providerId) || !isValidId(model.modelId) || definition?.kind !== "decision" || definition.providerId !== model.providerId || definition.modelId !== model.modelId) {
+    fail("Expected a DecisionModel with matching provider/model identity");
+  }
+  const capabilities = definition.capabilities;
+  if (!capabilities || !Array.isArray(capabilities.questions) || !capabilities.questions.length || capabilities.questions.some((kind) => !["choice", "score", "probability"].includes(kind)) || new Set(capabilities.questions).size !== capabilities.questions.length) {
+    fail("Decision model capabilities must list distinct supported question types");
+  }
+  assertCapabilityLimit(capabilities.maxChoices, "maxChoices", 1);
+  assertCapabilityLimit(capabilities.maxScoreLevels, "maxScoreLevels", 2);
+  const decimals = capabilities.answerDecimalPlaces;
+  if (decimals !== undefined && (!Number.isSafeInteger(decimals) || decimals < 1 || decimals > 15)) {
+    fail("Invalid decision answerDecimalPlaces (expected 1\u201315)");
+  }
+}
+function assertCapabilityLimit(value, name, minimum) {
+  if (value !== undefined && (!Number.isSafeInteger(value) || value < minimum)) {
+    fail(`Invalid decision capability '${name}'`);
+  }
+}
+function assertDecisionSupport(model, questions) {
+  for (const [key, question] of Object.entries(questions)) {
+    if (!supportsQuestion(model.definition.capabilities, question)) {
+      throw new UnsupportedModelFeatureError2(`[SixbModels] Model '${model.providerId}/${model.modelId}' does not support questions.${key}.`);
+    }
+  }
+}
+function supportsQuestion(capabilities, question) {
+  if (!capabilities.questions.includes(question.type))
+    return false;
+  switch (question.type) {
+    case "choice":
+      return Object.keys(question.options).length <= (capabilities.maxChoices ?? Infinity);
+    case "score":
+      return question.levels.length <= (capabilities.maxScoreLevels ?? Infinity);
+    case "probability":
+      return true;
+  }
+}
+function validateDecisionAnswers(questions, value, answerDecimalPlaces) {
+  assertJsonValue2(value, "decision output");
+  const answers = readRecord(value, "decision output");
+  assertExactKeys(answers, Object.keys(questions), "decision output");
+  const roundingError = answerDecimalPlaces === undefined ? 0 : 0.5 * 10 ** -answerDecimalPlaces;
+  for (const [key, question] of Object.entries(questions)) {
+    assertAnswer(question, answers[key], `output.${key}`, roundingError);
+  }
+  return cloneJsonValue2(value);
+}
+function assertAnswer(question, value, path, roundingError) {
+  const answer = readRecord(value, path);
+  if (question.type === "probability") {
+    assertExactKeys(answer, ["probability"], path);
+    readProbability(answer.probability, path);
+    return;
+  }
+  assertOnlyKeys(answer, [question.type, "probabilities", "confidence"], path);
+  if (answer.confidence !== undefined) {
+    readProbability(answer.confidence, `${path}.confidence`);
+  }
+  const distribution = question.type === "choice" ? validateChoiceAnswer(question, answer, path) : validateScoreAnswer(question, answer, path, roundingError);
+  const total = distribution.reduce((sum, probability) => sum + probability, 0);
+  const tolerance = Math.max(DISTRIBUTION_TOLERANCE, distribution.length * roundingError);
+  if (Math.abs(total - 1) > tolerance + Number.EPSILON * distribution.length) {
+    fail(`${path}.probabilities must sum to one`);
+  }
+}
+function validateChoiceAnswer(question, answer, path) {
+  const probabilities = readRecord(answer.probabilities, `${path}.probabilities`);
+  assertExactKeys(probabilities, Object.keys(question.options), `${path}.probabilities`);
+  const distribution = Object.values(probabilities).map((value) => readProbability(value, path));
+  if (typeof answer.choice !== "string" || !Object.hasOwn(question.options, answer.choice)) {
+    fail(`${path}.choice is not a declared option`);
+  }
+  const winner = readProbability(probabilities[answer.choice], path);
+  if (winner + CHOICE_TOLERANCE < Math.max(...distribution)) {
+    fail(`${path}.choice is not a highest-probability option`);
+  }
+  return distribution;
+}
+function validateScoreAnswer(question, answer, path, roundingError) {
+  if (!Array.isArray(answer.probabilities) || answer.probabilities.length !== question.levels.length) {
+    fail(`${path}.probabilities must match the score levels`);
+  }
+  const distribution = answer.probabilities.map((value) => readProbability(value, path));
+  const expected = distribution.reduce((sum, probability, index) => sum + probability * index, 0);
+  const levels = question.levels.length;
+  const [minimum, maximum] = roundingError ? roundedScoreBounds(distribution, roundingError, path) : [expected, expected];
+  const tolerance = roundingError || DISTRIBUTION_TOLERANCE * levels;
+  if (typeof answer.score !== "number" || !Number.isFinite(answer.score) || answer.score < 0 || answer.score > question.levels.length - 1 || answer.score < minimum - tolerance - Number.EPSILON * levels ** 2 || answer.score > maximum + tolerance + Number.EPSILON * levels ** 2) {
+    fail(`${path}.score is inconsistent with its distribution`);
+  }
+  return distribution;
+}
+function roundedScoreBounds(distribution, roundingError, path) {
+  const lower = distribution.map((value) => Math.max(0, value - roundingError));
+  const upper = distribution.map((value) => Math.min(1, value + roundingError));
+  const remaining = 1 - lower.reduce((sum, value) => sum + value, 0);
+  const epsilon = Number.EPSILON * distribution.length;
+  if (remaining < -epsilon || upper.reduce((sum, value) => sum + value, 0) < 1 - epsilon) {
+    fail(`${path}.probabilities must sum to one`);
+  }
+  const base = lower.reduce((sum, value, index) => sum + value * index, 0);
+  function extreme(highestFirst) {
+    let mass = Math.max(0, remaining);
+    let mean = base;
+    for (let offset = 0;offset < distribution.length && mass > 0; offset++) {
+      const index = highestFirst ? distribution.length - 1 - offset : offset;
+      const added = Math.min(mass, upper[index] - lower[index]);
+      mean += added * index;
+      mass -= added;
+    }
+    return mean;
+  }
+  return [extreme(false), extreme(true)];
+}
+function readProbability(value, path) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) {
+    fail(`${path} must contain probabilities between zero and one`);
+  }
+  return value;
+}
+function readRecord(value, path) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    fail(`${path} must be an object`);
+  }
+  return value;
+}
+function assertOnlyKeys(value, keys, path) {
+  if (Object.keys(value).some((key) => !keys.includes(key))) {
+    fail(`${path} contains an unknown field`);
+  }
+}
+function assertExactKeys(value, keys, path) {
+  assertOnlyKeys(value, keys, path);
+  if (keys.some((key) => !Object.hasOwn(value, key))) {
+    fail(`${path} is missing an expected field`);
+  }
+}
+function isValidId(value) {
+  return typeof value === "string" && !!value.trim() && value.trim() === value;
+}
+function fail(detail) {
+  throw new TypeError(`[SixbModels] ${detail}.`);
+}
+
+// src/models/decision/catalog.ts
+function createDecisionCatalog(models) {
+  if (models === undefined)
+    return;
+  if (!Array.isArray(models)) {
+    throw new RuntimeError2("[Sixb] models.decision must be a nonempty array of decision models.");
+  }
+  const index = indexModelBindings(models, "decision", assertDecisionModel);
+  const [defaultEntry] = index.list();
+  if (!defaultEntry) {
+    throw new RuntimeError2("[Sixb] models.decision must be a nonempty array of decision models.");
+  }
+  return Object.freeze({ ...index, default: defaultEntry });
+}
+
 // src/models/definitions.ts
 function defineLanguageModel2(definition) {
   if (definition.kind !== "language") {
@@ -163,40 +418,35 @@ function assertRecord(value, field) {
 
 // src/models/catalog.ts
 function createModelCatalog2(input) {
-  if (!Array.isArray(input?.language)) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    throw new RuntimeError2("[Sixb] 'models' must be a model catalog configuration.");
+  }
+  const language = createLanguageCatalog(input.language);
+  const embedding = createEmbeddingCatalog(input.embedding);
+  const decision = createDecisionCatalog(input.decision);
+  if (!language && !decision && embedding.list().length === 0) {
+    throw new RuntimeError2("[Sixb] Configure at least one language, embedding or decision model.");
+  }
+  return Object.freeze({ language, embedding, decision });
+}
+function createLanguageCatalog(models) {
+  if (models === undefined)
+    return;
+  if (!Array.isArray(models)) {
     throw new RuntimeError2("[Sixb] 'models.language' must be an array of Sixb language models.");
   }
-  const entries = [];
-  const byProvider = new Map;
-  for (const [index, model] of input.language.entries()) {
-    assertLanguageModel(model, index);
-    let byModelId = byProvider.get(model.providerId);
-    if (byModelId === undefined) {
-      byModelId = new Map;
-      byProvider.set(model.providerId, byModelId);
-    }
-    if (byModelId.has(model.modelId)) {
-      throw new RuntimeError2(`[Sixb] Duplicate language model '${model.providerId}/${model.modelId}' in 'models'. Each provider and model id pair may be configured once.`);
-    }
-    const entry = Object.freeze({
-      provider: model.providerId,
-      modelId: model.modelId,
-      model
-    });
-    byModelId.set(model.modelId, entry);
-    entries.push(entry);
-  }
-  const [defaultEntry] = entries;
-  if (defaultEntry === undefined) {
-    throw new RuntimeError2("[Sixb] 'models.language' needs at least one model. Configure one or omit 'models' from createSixb().");
-  }
-  const listed = Object.freeze(entries.slice());
-  const language = Object.freeze({
-    default: defaultEntry,
-    list: () => listed,
-    getByRef: (ref) => byProvider.get(ref.provider)?.get(ref.modelId) ?? null
-  });
-  return Object.freeze({ language });
+  const index = indexModelBindings(models, "language", assertLanguageModel);
+  const [defaultEntry] = index.list();
+  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 });
+}
+function createEmbeddingCatalog(models) {
+  if (models !== undefined && !Array.isArray(models)) {
+    throw new RuntimeError2("[Sixb] models.embedding must be an array of embedding models.");
+  }
+  return indexModelBindings(models ?? [], "embedding", assertEmbeddingModel);
 }
 function assertLanguageModel(model, index) {
   if (typeof model !== "object" && typeof model !== "function" || model === null) {
@@ -228,67 +478,87 @@ function assertModelIdentifier(value, field, index) {
 function invalidLanguageModel(index, detail) {
   return new RuntimeError2(`[Sixb] Invalid language model at 'models.language[${index}]': ${detail}.`);
 }
-// src/models/errors.ts
-class ModelCatalogUnavailableError2 extends Error {
-  name = "ModelCatalogUnavailableError";
-}
-
-class ModelProviderError2 extends Error {
-  providerId;
-  modelId;
-  name = "ModelProviderError";
-  constructor(message, providerId, modelId, options) {
-    super(message, options);
-    this.providerId = providerId;
-    this.modelId = modelId;
-    this.status = options?.status;
-    this.code = options?.code;
-    this.requestId = options?.requestId;
-    this.retryAfterMs = options?.retryAfterMs;
-    this.retryable = options?.retryable ?? false;
-  }
-  status;
-  code;
-  requestId;
-  retryAfterMs;
-  retryable;
-}
-
-class ModelStreamError2 extends Error {
-  name = "ModelStreamError";
-}
-
-class UnsupportedModelFeatureError2 extends Error {
-  name = "UnsupportedModelFeatureError";
-  constructor(message, options) {
-    super(message, options);
-    this.reason = options?.reason;
-  }
-  reason;
-}
-
-class StructuredOutputError2 extends Error {
-  name = "StructuredOutputError";
-  constructor(message, options) {
-    super(message, options);
-    this.text = options?.text;
-    this.providerId = options?.providerId;
-    this.modelId = options?.modelId;
-    this.responseId = options?.responseId;
-    this.responseModelId = options?.responseModelId;
-    this.finishReason = options?.finishReason;
-    this.usage = options?.usage;
-    this.cost = options?.cost;
-  }
-  text;
-  providerId;
-  modelId;
-  responseId;
-  responseModelId;
-  finishReason;
-  usage;
-  cost;
-}
+// src/models/decision/errors.ts
+class DecisionModelResponseError2 extends ModelProviderError2 {
+  metadata;
+  constructor(message, providerId, modelId, metadata, options) {
+    super(message, providerId, modelId, {
+      ...options,
+      code: "invalid_decision_response",
+      retryable: false
+    });
+    this.metadata = metadata;
+  }
+}
+// src/models/decision/output.ts
+function decisionOutput2(questions) {
+  assertDecisionQuestions(questions);
+  const result = Object.fromEntries(Object.entries(questions).map(([key, q]) => {
+    if (q.type === "probability")
+      return [
+        key,
+        {
+          type: "object",
+          properties: { probability: { required: true, schema: "double" } }
+        }
+      ];
+    const confidence = { schema: "double" };
+    if (q.type === "score")
+      return [
+        key,
+        {
+          type: "object",
+          properties: {
+            score: { required: true, schema: "double" },
+            probabilities: { required: true, schema: { type: "array", items: "double" } },
+            confidence
+          }
+        }
+      ];
+    return [
+      key,
+      {
+        type: "object",
+        properties: {
+          choice: {
+            required: true,
+            schema: { type: "enum", valueType: "string", values: Object.keys(q.options) }
+          },
+          probabilities: {
+            required: true,
+            schema: {
+              type: "object",
+              properties: Object.fromEntries(Object.keys(q.options).map((option) => [
+                option,
+                { required: true, schema: "double" }
+              ]))
+            }
+          },
+          confidence
+        }
+      }
+    ];
+  }));
+  return result;
+}
+// src/models/decision/questions.ts
+var question2 = {
+  choice(input) {
+    const result = { ...input, type: "choice" };
+    assertDecisionQuestions({ question: result });
+    return result;
+  },
+  score(input) {
+    const result = { ...input, type: "score" };
+    assertDecisionQuestions({ question: result });
+    return result;
+  },
+  probability(instructions) {
+    const result = { type: "probability", instructions };
+    assertDecisionQuestions({ question: result });
+    return result;
+  }
+};
 // src/models/pricing.ts
 function estimateModelCall(model, input) {
   try {
@@ -541,6 +811,6 @@ function assertRecord2(value, field) {
     throw new TypeError(`[Sixb] Model ${field} must be an object.`);
   }
 }
-export { RuntimeError2, defineLanguageModel2, createModelCatalog2, ModelCatalogUnavailableError2, ModelProviderError2, ModelStreamError2, UnsupportedModelFeatureError2, StructuredOutputError2, estimateModelCall, estimateModelReservation2, rateModelCall2, defineModelRateCard2 };
+export { RuntimeError2, assertDecisionContent, assertDecisionQuestions, assertDecisionModel, assertDecisionSupport, validateDecisionAnswers, defineLanguageModel2, createModelCatalog2, DecisionModelResponseError2, decisionOutput2, question2, estimateModelCall, estimateModelReservation2, rateModelCall2, defineModelRateCard2 };
 
-//# debugId=2E4C0EA051E48B7564756E2164756E21
+//# debugId=BB10E479DCC4E90B64756E2164756E21