@effect-uai/core 0.16.0 → 0.18.0

package/README.md

@@ -43,7 +43,7 @@ and [the rest](https://effect-uai.betalyra.com/providers/).
 pnpm add @effect-uai/core effect
 ```
 
-ESM-only. Requires `effect@4.x` as a peer.
+ESM-only. Requires `effect@>=4.0.1` (Effect 4.0 stable) as a peer.
 
 ## Docs
 

package/dist/decision-model/Decision.d.mts

@@ -0,0 +1,155 @@
+import { t as AiError } from "../AiError-DvhLIbmd.mjs";
+import { Effect, Option, Schema } from "effect";
+declare namespace Decision_d_exports {
+  export { Answer, AnswerFor, Answers, Boundary, ClassifyAnswer, ClassifyDecision, Decision, Decisions, Definition, Labels, Levels, ProbabilityAnswer, ProbabilityDecision, RateAnswer, RateDecision, assertKinds, classify, confidence, expectedLevel, make, margin, probabilitiesOf, probability, ranked, rate, topLevel, winner };
+}
+/** Labels mapped to what each one means. */
+type Labels = Readonly<Record<string, string>>;
+/** An ordered rubric, lowest level first. */
+type Levels = readonly [string, string, ...ReadonlyArray<string>];
+/** What a true and a false answer mean, when the boundary is subtle. */
+type Boundary = {
+  readonly true?: string;
+  readonly false?: string;
+};
+type ClassifyDecision<L extends Labels = Labels> = {
+  readonly _tag: "Classify";
+  readonly instructions: string;
+  readonly criteria: L;
+};
+type RateDecision<V extends Levels = Levels> = {
+  readonly _tag: "Rate";
+  readonly instructions: string;
+  readonly criteria: V;
+};
+type ProbabilityDecision = {
+  readonly _tag: "Probability";
+  readonly instructions: string;
+  readonly criteria?: Boundary;
+};
+type Decision = ClassifyDecision | RateDecision | ProbabilityDecision;
+/** Pick one label. Use {@link rate} when the options form a spectrum. */
+declare const classify: <const L extends Labels>(decision: {
+  readonly instructions: string;
+  readonly criteria: L;
+}) => ClassifyDecision<L>;
+/** Place the input on an ordered rubric. */
+declare const rate: <const V extends Levels>(decision: {
+  readonly instructions: string;
+  readonly criteria: V;
+}) => RateDecision<V>;
+/**
+ * How likely a statement is to hold. Named for its answer rather than for an
+ * act, unlike its siblings, so nobody reads the result as a boolean.
+ */
+declare const probability: (decision: {
+  readonly instructions: string;
+  readonly criteria?: Boundary;
+}) => ProbabilityDecision;
+/** Decisions keyed by the name their answer comes back under. */
+type Decisions = {
+  readonly [name: string]: Decision;
+};
+/**
+ * A reusable decision set bound to the shape it reads.
+ *
+ * `inputSchema` encodes the input on the way out, so a schema that omits a
+ * field keeps it from the model. That projection is the supported way to hold
+ * irrelevant or sensitive context out of a request.
+ */
+type Definition<A_, D extends Decisions = Decisions> = {
+  readonly inputSchema: Schema.Codec<A_, unknown, any, never>;
+  readonly decisions: D;
+};
+/**
+ * Build a decision set. Declare it once at module scope: the questions and
+ * their rubrics are the reviewed artifact, the input changes per call.
+ *
+ * @example
+ * ```ts
+ * const triage = Decision.make({
+ *   inputSchema: Schema.Struct({ message: Schema.String }),
+ *   decisions: {
+ *     department: Decision.classify({
+ *       instructions: "Which team should handle this?",
+ *       criteria: { billing: "Payments, invoicing", technical: "Bugs, outages" },
+ *     }),
+ *   },
+ * })
+ * ```
+ */
+declare const make: <S extends Schema.Codec<any, any, any, never>, const D extends Decisions>(definition: {
+  readonly inputSchema: S;
+  readonly decisions: D;
+}) => Definition<S["Type"], D>;
+/**
+ * Score contract for {@link ClassifyAnswer.labels} and
+ * {@link RateAnswer.levels}: probabilities sum to 1 within floating-point
+ * error and are comparable within one answer. Whether they are *calibrated*,
+ * so a stated 0.8 means right about 80% of the time, is a property of the
+ * Layer and is documented per provider. No implementor promises calibration
+ * across requests, across decision kinds, or between a statement and its
+ * negation: `P(claim) != 1 - P(not claim)`. A threshold fitted against one
+ * model does not transfer to another.
+ */
+type ClassifyAnswer<L extends Labels = Labels> = {
+  readonly _tag: "Classify";
+  readonly labels: Readonly<Record<keyof L & string, number>>;
+};
+type RateAnswer<V extends Levels = Levels> = {
+  readonly _tag: "Rate";
+  /** Index-aligned with {@link RateAnswer.legend}. */
+  readonly levels: { readonly [K in keyof V]: number; };
+  /** The rubric, echoed so an index reads back as prose. */
+  readonly legend: Readonly<V>;
+};
+type ProbabilityAnswer = {
+  readonly _tag: "Probability";
+  readonly probability: number;
+};
+type Answer = ClassifyAnswer | RateAnswer | ProbabilityAnswer;
+/** The answer a decision determines, keeping its labels or rubric. */
+type AnswerFor<D> = D extends {
+  readonly _tag: "Classify";
+  readonly criteria: infer L extends Labels;
+} ? ClassifyAnswer<L> : D extends {
+  readonly _tag: "Rate";
+  readonly criteria: infer V extends Levels;
+} ? RateAnswer<V> : ProbabilityAnswer;
+/** Answers keyed by their decision's name. */
+type Answers<D extends Decisions> = { readonly [K in keyof D]: AnswerFor<D[K]>; };
+/**
+ * Fail `AiError.Unsupported` naming every decision whose kind this provider
+ * cannot express. Bucket 1: omitting an answer would leave a hole where
+ * {@link Answers} promises a key.
+ *
+ * Reports all offenders at once, since the definition is known up front.
+ */
+declare const assertKinds: (decisions: Decisions, supported: ReadonlyArray<Decision["_tag"]>, provider: string) => Effect.Effect<void, AiError>;
+/** A `Probability` answer's implied distribution is `[p, 1 - p]`. */
+declare const probabilitiesOf: (answer: Answer) => ReadonlyArray<number>;
+/** See {@link Probability.confidence}. Defined for every kind. */
+declare const confidence: (answer: Answer) => number;
+/** See {@link Probability.margin}. Defined for every kind. */
+declare const margin: (answer: Answer) => number;
+/**
+ * Labels best first. Ties keep first-seen order. Also the bridge to rank
+ * fusion: map to `label` and pass alongside another retriever's ordering.
+ */
+declare const ranked: <L extends Labels>(answer: ClassifyAnswer<L>) => ReadonlyArray<{
+  readonly label: keyof L & string;
+  readonly probability: number;
+}>;
+/** Highest-probability label. `None` only when the label set is empty. */
+declare const winner: <L extends Labels>(answer: ClassifyAnswer<L>) => Option.Option<keyof L & string>;
+/** Index of the highest-probability level. Ties resolve to the lowest. */
+declare const topLevel: (answer: RateAnswer) => number;
+/**
+ * Probability-weighted mean of the level indices, so it can land between
+ * them. Weakly calibrated in practice: a summary, not a magnitude to
+ * interpolate. Use {@link topLevel} with `legend` to name a level instead.
+ */
+declare const expectedLevel: (answer: RateAnswer) => number;
+//#endregion
+export { Answer, AnswerFor, Answers, Boundary, ClassifyAnswer, ClassifyDecision, Decision, Decisions, Definition, Labels, Levels, ProbabilityAnswer, ProbabilityDecision, RateAnswer, RateDecision, assertKinds, classify, confidence, expectedLevel, make, margin, probabilitiesOf, probability, ranked, rate, Decision_d_exports as t, topLevel, winner };
+//# sourceMappingURL=Decision.d.mts.map

package/dist/decision-model/Decision.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Decision.d.mts","names":[],"sources":["../../src/decision-model/Decision.ts"],"mappings":";;;;;;KA4BY,SAAS,SAAS;;KAGlB,sCAAsC;;KAGtC;WAAsB;WAAwB;;KAM9C,iBAAiB,UAAU,SAAS;WACrC;WACA;WACA,UAAU;;KAGT,aAAa,UAAU,SAAS;WACjC;WACA;WACA,UAAU;;KAGT;WACD;WACA;WACA,WAAW;;KAGV,WAAW,mBAAmB,eAAe;;cAG5C,iBAAkB,UAAU,QAAM;WACpC;WACA,UAAU;MACjB,iBAAiB;;cAGR,aAAc,UAAU,QAAM;WAChC;WACA,UAAU;MACjB,aAAa;;;;;cAMJ,cAAW;WACb;WACA,WAAW;MAClB;;KAGQ;YAAwB,eAAe;;;;;;;;;KAavC,WAAW,IAAI,UAAU,YAAY;WACtC,aAAa,OAAO,MAAM;WAC1B,WAAW;;;;;;;;;;;;;;;;;;;cAoBT,OACX,UAAU,OAAO,mCACX,UAAU,WAAS;WAEhB,aAAa;WACb,WAAW;MAClB,WAAW,WAAW;;;;;;;;;;;KAgBd,eAAe,UAAU,SAAS;WACnC;WACA,QAAQ,SAAS,aAAa;;KAG7B,WAAW,UAAU,SAAS;WAC/B;;WAEA,oBAAoB,WAAW;;WAE/B,QAAQ,SAAS;;KAGhB;WACD;WACA;;KAGC,SAAS,iBAAiB,aAAa;;KAGvC,UAAU,KAAK;WAChB;WACA,gBAAgB,UAAU;IAEjC,eAAe,KACf;WAAqB;WAAuB,gBAAgB,UAAU;IACpE,WAAW,KACX;;KAGM,QAAQ,UAAU,yBAAyB,WAAW,IAAI,UAAU,EAAE;;;;;;;;cAarE,cAAW,WACX,WAAS,WACT,cAAc,mBAAiB,qBAEzC,OAAO,aAAa;;cAsBV,kBAAkB,QAAQ,WAAW;;cASrC,aAAU,QAAY;;cAItB,SAAM,QAAY;;;;;cAWlB,SAAU,UAAU,QAAM,QAC7B,eAAe,OACtB;WAAyB,aAAa;WAAqB;;;cAQjD,SAAU,UAAU,QAAM,QAC7B,eAAe,OACtB,OAAO,aAAa;;cAQV,WAAQ,QAAY;;;;;;cAcpB,gBAAa,QAAY"}

package/dist/decision-model/Decision.mjs

@@ -0,0 +1,118 @@
+import { n as __exportAll } from "../rolldown-runtime-EAsCxrDo.mjs";
+import { Unsupported } from "../domain/AiError.mjs";
+import { confidence as confidence$1, margin as margin$1 } from "../math/Probability.mjs";
+import { Array, Effect, Match, Number, Option, Order, Record, pipe } from "effect";
+//#region src/decision-model/Decision.ts
+/**
+* Typed questions about one input, answered with probabilities.
+*
+* A {@link Definition} pairs the shape being read with the questions asked of
+* it. Build one at module scope and apply it per call with
+* `DecisionModel.decide`.
+*
+* @experimental The model class this abstracts is new and the shape may change.
+*/
+var Decision_exports = /* @__PURE__ */ __exportAll({
+	assertKinds: () => assertKinds,
+	classify: () => classify,
+	confidence: () => confidence,
+	expectedLevel: () => expectedLevel,
+	make: () => make,
+	margin: () => margin,
+	probabilitiesOf: () => probabilitiesOf,
+	probability: () => probability,
+	ranked: () => ranked,
+	rate: () => rate,
+	topLevel: () => topLevel,
+	winner: () => winner
+});
+/** Pick one label. Use {@link rate} when the options form a spectrum. */
+const classify = (decision) => ({
+	_tag: "Classify",
+	...decision
+});
+/** Place the input on an ordered rubric. */
+const rate = (decision) => ({
+	_tag: "Rate",
+	...decision
+});
+/**
+* How likely a statement is to hold. Named for its answer rather than for an
+* act, unlike its siblings, so nobody reads the result as a boolean.
+*/
+const probability = (decision) => ({
+	_tag: "Probability",
+	...decision
+});
+/**
+* Build a decision set. Declare it once at module scope: the questions and
+* their rubrics are the reviewed artifact, the input changes per call.
+*
+* @example
+* ```ts
+* const triage = Decision.make({
+*   inputSchema: Schema.Struct({ message: Schema.String }),
+*   decisions: {
+*     department: Decision.classify({
+*       instructions: "Which team should handle this?",
+*       criteria: { billing: "Payments, invoicing", technical: "Bugs, outages" },
+*     }),
+*   },
+* })
+* ```
+*/
+const make = (definition) => definition;
+/**
+* Fail `AiError.Unsupported` naming every decision whose kind this provider
+* cannot express. Bucket 1: omitting an answer would leave a hole where
+* {@link Answers} promises a key.
+*
+* Reports all offenders at once, since the definition is known up front.
+*/
+const assertKinds = (decisions, supported, provider) => {
+	const offenders = pipe(Record.toEntries(decisions), Array.filter(([, decision]) => !supported.includes(decision._tag)), Array.map(([name, decision]) => `"${name}" is a ${decision._tag}`));
+	return offenders.length === 0 ? Effect.void : Effect.fail(new Unsupported({
+		provider,
+		capability: "decision",
+		reason: `${provider} answers ${supported.join(" / ")} only; ${offenders.join(", ")}.`
+	}));
+};
+/** A `Probability` answer's implied distribution is `[p, 1 - p]`. */
+const probabilitiesOf = Match.type().pipe(Match.discriminatorsExhaustive("_tag")({
+	Classify: (answer) => Record.values(answer.labels),
+	Rate: (answer) => answer.levels,
+	Probability: (answer) => [answer.probability, 1 - answer.probability]
+}));
+/** See {@link Probability.confidence}. Defined for every kind. */
+const confidence = (answer) => confidence$1(probabilitiesOf(answer));
+/** See {@link Probability.margin}. Defined for every kind. */
+const margin = (answer) => margin$1(probabilitiesOf(answer));
+const byProbability = Order.mapInput(Order.flip(Order.Number), (outcome) => outcome.probability);
+/**
+* Labels best first. Ties keep first-seen order. Also the bridge to rank
+* fusion: map to `label` and pass alongside another retriever's ordering.
+*/
+const ranked = (answer) => pipe(Record.toEntries(answer.labels), Array.map(([label, probability]) => ({
+	label,
+	probability
+})), Array.sort(byProbability));
+/** Highest-probability label. `None` only when the label set is empty. */
+const winner = (answer) => pipe(ranked(answer), Array.head, Option.map((outcome) => outcome.label));
+/** Index of the highest-probability level. Ties resolve to the lowest. */
+const topLevel = (answer) => pipe(answer.levels, Array.reduce({
+	index: 0,
+	probability: -Infinity
+}, (best, probability, index) => probability > best.probability ? {
+	index,
+	probability
+} : best), (best) => best.index);
+/**
+* Probability-weighted mean of the level indices, so it can land between
+* them. Weakly calibrated in practice: a summary, not a magnitude to
+* interpolate. Use {@link topLevel} with `legend` to name a level instead.
+*/
+const expectedLevel = (answer) => pipe(answer.levels, Array.map((probability, index) => index * probability), Number.sumAll);
+//#endregion
+export { assertKinds, classify, confidence, expectedLevel, make, margin, probabilitiesOf, probability, ranked, rate, Decision_exports as t, topLevel, winner };
+
+//# sourceMappingURL=Decision.mjs.map

package/dist/decision-model/Decision.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Decision.mjs","names":["A","AiError.Unsupported","Probability.confidence","Probability.margin","N"],"sources":["../../src/decision-model/Decision.ts"],"sourcesContent":["/**\n * Typed questions about one input, answered with probabilities.\n *\n * A {@link Definition} pairs the shape being read with the questions asked of\n * it. Build one at module scope and apply it per call with\n * `DecisionModel.decide`.\n *\n * @experimental The model class this abstracts is new and the shape may change.\n */\nimport {\n  Array as A,\n  Effect,\n  Match,\n  Number as N,\n  Option,\n  Order,\n  Record,\n  type Schema,\n  pipe,\n} from \"effect\"\nimport * as AiError from \"../domain/AiError.js\"\nimport * as Probability from \"../math/Probability.js\"\n\n// ---------------------------------------------------------------------------\n// Criteria\n// ---------------------------------------------------------------------------\n\n/** Labels mapped to what each one means. */\nexport type Labels = Readonly<Record<string, string>>\n\n/** An ordered rubric, lowest level first. */\nexport type Levels = readonly [string, string, ...ReadonlyArray<string>]\n\n/** What a true and a false answer mean, when the boundary is subtle. */\nexport type Boundary = { readonly true?: string; readonly false?: string }\n\n// ---------------------------------------------------------------------------\n// Decisions\n// ---------------------------------------------------------------------------\n\nexport type ClassifyDecision<L extends Labels = Labels> = {\n  readonly _tag: \"Classify\"\n  readonly instructions: string\n  readonly criteria: L\n}\n\nexport type RateDecision<V extends Levels = Levels> = {\n  readonly _tag: \"Rate\"\n  readonly instructions: string\n  readonly criteria: V\n}\n\nexport type ProbabilityDecision = {\n  readonly _tag: \"Probability\"\n  readonly instructions: string\n  readonly criteria?: Boundary\n}\n\nexport type Decision = ClassifyDecision | RateDecision | ProbabilityDecision\n\n/** Pick one label. Use {@link rate} when the options form a spectrum. */\nexport const classify = <const L extends Labels>(decision: {\n  readonly instructions: string\n  readonly criteria: L\n}): ClassifyDecision<L> => ({ _tag: \"Classify\", ...decision })\n\n/** Place the input on an ordered rubric. */\nexport const rate = <const V extends Levels>(decision: {\n  readonly instructions: string\n  readonly criteria: V\n}): RateDecision<V> => ({ _tag: \"Rate\", ...decision })\n\n/**\n * How likely a statement is to hold. Named for its answer rather than for an\n * act, unlike its siblings, so nobody reads the result as a boolean.\n */\nexport const probability = (decision: {\n  readonly instructions: string\n  readonly criteria?: Boundary\n}): ProbabilityDecision => ({ _tag: \"Probability\", ...decision })\n\n/** Decisions keyed by the name their answer comes back under. */\nexport type Decisions = { readonly [name: string]: Decision }\n\n// ---------------------------------------------------------------------------\n// Definition\n// ---------------------------------------------------------------------------\n\n/**\n * A reusable decision set bound to the shape it reads.\n *\n * `inputSchema` encodes the input on the way out, so a schema that omits a\n * field keeps it from the model. That projection is the supported way to hold\n * irrelevant or sensitive context out of a request.\n */\nexport type Definition<A_, D extends Decisions = Decisions> = {\n  readonly inputSchema: Schema.Codec<A_, unknown, any, never>\n  readonly decisions: D\n}\n\n/**\n * Build a decision set. Declare it once at module scope: the questions and\n * their rubrics are the reviewed artifact, the input changes per call.\n *\n * @example\n * ```ts\n * const triage = Decision.make({\n *   inputSchema: Schema.Struct({ message: Schema.String }),\n *   decisions: {\n *     department: Decision.classify({\n *       instructions: \"Which team should handle this?\",\n *       criteria: { billing: \"Payments, invoicing\", technical: \"Bugs, outages\" },\n *     }),\n *   },\n * })\n * ```\n */\nexport const make = <\n  S extends Schema.Codec<any, any, any, never>,\n  const D extends Decisions,\n>(definition: {\n  readonly inputSchema: S\n  readonly decisions: D\n}): Definition<S[\"Type\"], D> => definition\n\n// ---------------------------------------------------------------------------\n// Answers\n// ---------------------------------------------------------------------------\n\n/**\n * Score contract for {@link ClassifyAnswer.labels} and\n * {@link RateAnswer.levels}: probabilities sum to 1 within floating-point\n * error and are comparable within one answer. Whether they are *calibrated*,\n * so a stated 0.8 means right about 80% of the time, is a property of the\n * Layer and is documented per provider. No implementor promises calibration\n * across requests, across decision kinds, or between a statement and its\n * negation: `P(claim) != 1 - P(not claim)`. A threshold fitted against one\n * model does not transfer to another.\n */\nexport type ClassifyAnswer<L extends Labels = Labels> = {\n  readonly _tag: \"Classify\"\n  readonly labels: Readonly<Record<keyof L & string, number>>\n}\n\nexport type RateAnswer<V extends Levels = Levels> = {\n  readonly _tag: \"Rate\"\n  /** Index-aligned with {@link RateAnswer.legend}. */\n  readonly levels: { readonly [K in keyof V]: number }\n  /** The rubric, echoed so an index reads back as prose. */\n  readonly legend: Readonly<V>\n}\n\nexport type ProbabilityAnswer = {\n  readonly _tag: \"Probability\"\n  readonly probability: number\n}\n\nexport type Answer = ClassifyAnswer | RateAnswer | ProbabilityAnswer\n\n/** The answer a decision determines, keeping its labels or rubric. */\nexport type AnswerFor<D> = D extends {\n  readonly _tag: \"Classify\"\n  readonly criteria: infer L extends Labels\n}\n  ? ClassifyAnswer<L>\n  : D extends { readonly _tag: \"Rate\"; readonly criteria: infer V extends Levels }\n    ? RateAnswer<V>\n    : ProbabilityAnswer\n\n/** Answers keyed by their decision's name. */\nexport type Answers<D extends Decisions> = { readonly [K in keyof D]: AnswerFor<D[K]> }\n\n// ---------------------------------------------------------------------------\n// Guards\n// ---------------------------------------------------------------------------\n\n/**\n * Fail `AiError.Unsupported` naming every decision whose kind this provider\n * cannot express. Bucket 1: omitting an answer would leave a hole where\n * {@link Answers} promises a key.\n *\n * Reports all offenders at once, since the definition is known up front.\n */\nexport const assertKinds = (\n  decisions: Decisions,\n  supported: ReadonlyArray<Decision[\"_tag\"]>,\n  provider: string,\n): Effect.Effect<void, AiError.AiError> => {\n  const offenders = pipe(\n    Record.toEntries(decisions),\n    A.filter(([, decision]) => !supported.includes(decision._tag)),\n    A.map(([name, decision]) => `\"${name}\" is a ${decision._tag}`),\n  )\n  return offenders.length === 0\n    ? Effect.void\n    : Effect.fail(\n        new AiError.Unsupported({\n          provider,\n          capability: \"decision\",\n          reason: `${provider} answers ${supported.join(\" / \")} only; ${offenders.join(\", \")}.`,\n        }),\n      )\n}\n\n// ---------------------------------------------------------------------------\n// Reading an answer\n// ---------------------------------------------------------------------------\n\n/** A `Probability` answer's implied distribution is `[p, 1 - p]`. */\nexport const probabilitiesOf: (answer: Answer) => ReadonlyArray<number> = Match.type<Answer>().pipe(\n  Match.discriminatorsExhaustive(\"_tag\")({\n    Classify: (answer) => Record.values(answer.labels),\n    Rate: (answer) => answer.levels,\n    Probability: (answer) => [answer.probability, 1 - answer.probability],\n  }),\n)\n\n/** See {@link Probability.confidence}. Defined for every kind. */\nexport const confidence = (answer: Answer): number =>\n  Probability.confidence(probabilitiesOf(answer))\n\n/** See {@link Probability.margin}. Defined for every kind. */\nexport const margin = (answer: Answer): number => Probability.margin(probabilitiesOf(answer))\n\nconst byProbability = Order.mapInput(\n  Order.flip(Order.Number),\n  (outcome: { readonly probability: number }) => outcome.probability,\n)\n\n/**\n * Labels best first. Ties keep first-seen order. Also the bridge to rank\n * fusion: map to `label` and pass alongside another retriever's ordering.\n */\nexport const ranked = <L extends Labels>(\n  answer: ClassifyAnswer<L>,\n): ReadonlyArray<{ readonly label: keyof L & string; readonly probability: number }> =>\n  pipe(\n    Record.toEntries(answer.labels),\n    A.map(([label, probability]) => ({ label, probability })),\n    A.sort(byProbability),\n  )\n\n/** Highest-probability label. `None` only when the label set is empty. */\nexport const winner = <L extends Labels>(\n  answer: ClassifyAnswer<L>,\n): Option.Option<keyof L & string> =>\n  pipe(\n    ranked(answer),\n    A.head,\n    Option.map((outcome) => outcome.label),\n  )\n\n/** Index of the highest-probability level. Ties resolve to the lowest. */\nexport const topLevel = (answer: RateAnswer): number =>\n  pipe(\n    answer.levels as ReadonlyArray<number>,\n    A.reduce({ index: 0, probability: -Infinity }, (best, probability, index) =>\n      probability > best.probability ? { index, probability } : best,\n    ),\n    (best) => best.index,\n  )\n\n/**\n * Probability-weighted mean of the level indices, so it can land between\n * them. Weakly calibrated in practice: a summary, not a magnitude to\n * interpolate. Use {@link topLevel} with `legend` to name a level instead.\n */\nexport const expectedLevel = (answer: RateAnswer): number =>\n  pipe(\n    answer.levels as ReadonlyArray<number>,\n    A.map((probability, index) => index * probability),\n    N.sumAll,\n  )\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6DA,MAAa,YAAoC,cAGrB;CAAE,MAAM;CAAY,GAAG;AAAS;;AAG5D,MAAa,QAAgC,cAGrB;CAAE,MAAM;CAAQ,GAAG;AAAS;;;;;AAMpD,MAAa,eAAe,cAGA;CAAE,MAAM;CAAe,GAAG;AAAS;;;;;;;;;;;;;;;;;;AAsC/D,MAAa,QAGX,eAG8B;;;;;;;;AA4DhC,MAAa,eACX,WACA,WACA,aACyC;CACzC,MAAM,YAAY,KAChB,OAAO,UAAU,SAAS,GAC1BA,MAAE,QAAQ,GAAG,cAAc,CAAC,UAAU,SAAS,SAAS,IAAI,CAAC,GAC7DA,MAAE,KAAK,CAAC,MAAM,cAAc,IAAI,KAAK,SAAS,SAAS,MAAM,CAC/D;CACA,OAAO,UAAU,WAAW,IACxB,OAAO,OACP,OAAO,KACL,IAAIC,YAAoB;EACtB;EACA,YAAY;EACZ,QAAQ,GAAG,SAAS,WAAW,UAAU,KAAK,KAAK,EAAE,SAAS,UAAU,KAAK,IAAI,EAAE;CACrF,CAAC,CACH;AACN;;AAOA,MAAa,kBAA6D,MAAM,KAAa,CAAC,CAAC,KAC7F,MAAM,yBAAyB,MAAM,CAAC,CAAC;CACrC,WAAW,WAAW,OAAO,OAAO,OAAO,MAAM;CACjD,OAAO,WAAW,OAAO;CACzB,cAAc,WAAW,CAAC,OAAO,aAAa,IAAI,OAAO,WAAW;AACtE,CAAC,CACH;;AAGA,MAAa,cAAc,WACzBC,aAAuB,gBAAgB,MAAM,CAAC;;AAGhD,MAAa,UAAU,WAA2BC,SAAmB,gBAAgB,MAAM,CAAC;AAE5F,MAAM,gBAAgB,MAAM,SAC1B,MAAM,KAAK,MAAM,MAAM,IACtB,YAA8C,QAAQ,WACzD;;;;;AAMA,MAAa,UACX,WAEA,KACE,OAAO,UAAU,OAAO,MAAM,GAC9BH,MAAE,KAAK,CAAC,OAAO,kBAAkB;CAAE;CAAO;AAAY,EAAE,GACxDA,MAAE,KAAK,aAAa,CACtB;;AAGF,MAAa,UACX,WAEA,KACE,OAAO,MAAM,GACbA,MAAE,MACF,OAAO,KAAK,YAAY,QAAQ,KAAK,CACvC;;AAGF,MAAa,YAAY,WACvB,KACE,OAAO,QACPA,MAAE,OAAO;CAAE,OAAO;CAAG,aAAa;AAAU,IAAI,MAAM,aAAa,UACjE,cAAc,KAAK,cAAc;CAAE;CAAO;AAAY,IAAI,IAC5D,IACC,SAAS,KAAK,KACjB;;;;;;AAOF,MAAa,iBAAiB,WAC5B,KACE,OAAO,QACPA,MAAE,KAAK,aAAa,UAAU,QAAQ,WAAW,GACjDI,OAAE,MACJ"}

package/dist/decision-model/Decision.test.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/decision-model/Decision.test.mjs

@@ -0,0 +1,164 @@
+import { Unsupported } from "../domain/AiError.mjs";
+import { assertKinds, classify, confidence, expectedLevel, make, margin, probabilitiesOf, probability, ranked, rate, topLevel, winner } from "./Decision.mjs";
+import { DecisionModel, decide } from "./DecisionModel.mjs";
+import { m as describe } from "../dist-DzeSyeYF.mjs";
+import { n as globalExpect } from "../index.C4tKZ0yW-LuFnBtmu.mjs";
+import { t as import_dist } from "../dist-DNeuh84d.mjs";
+import { t as it } from "../dist-C8RmtoR8.mjs";
+import { Effect, Layer, Option, Ref, Schema } from "effect";
+//#region src/decision-model/Decision.test.ts
+const triage = make({
+	inputSchema: Schema.Struct({ message: Schema.String }),
+	decisions: {
+		department: classify({
+			instructions: "Which team should handle this?",
+			criteria: {
+				billing: "Payments, invoicing",
+				technical: "Bugs, outages"
+			}
+		}),
+		severity: rate({
+			instructions: "How severe is it?",
+			criteria: [
+				"Cosmetic",
+				"Degraded",
+				"Blocking"
+			]
+		}),
+		urgent: probability({ instructions: "Does this convey urgency?" })
+	}
+});
+const fixture = {
+	department: {
+		_tag: "Classify",
+		labels: {
+			billing: .62,
+			technical: .38
+		}
+	},
+	severity: {
+		_tag: "Rate",
+		levels: [
+			0,
+			.7,
+			.3
+		],
+		legend: [
+			"Cosmetic",
+			"Degraded",
+			"Blocking"
+		]
+	},
+	urgent: {
+		_tag: "Probability",
+		probability: .94
+	}
+};
+/**
+* A fixed fixture cannot prove it satisfies the caller's `Answers<D>`. This is
+* the boundary a provider casts at too, once it has decoded the wire.
+*/
+const fixed = (answers) => answers;
+/** A `DecisionModel` layer that records what reached it. */
+const recording = Effect.gen(function* () {
+	const calls = yield* Ref.make([]);
+	return {
+		calls,
+		layer: Layer.succeed(DecisionModel, { decide: (_definition, request) => Effect.as(Ref.update(calls, (seen) => [...seen, {
+			input: request.input,
+			model: request.model
+		}]), {
+			answers: fixed(fixture),
+			usage: {}
+		}) })
+	};
+});
+describe("the answer map is derived from the definition", () => {
+	it.effect("keeps each decision's label keys and rejects labels it never had", () => Effect.gen(function* () {
+		const { calls, layer } = yield* recording;
+		const result = yield* decide(triage, {
+			model: "jev-latest",
+			input: { message: "hi" }
+		}).pipe(Effect.provide(layer));
+		(0, import_dist.expectTypeOf)(result.answers.department.labels).toEqualTypeOf();
+		result.answers.department.labels.shipping;
+		result.answers.urgent.labels;
+		globalExpect(yield* Ref.get(calls)).toEqual([{
+			input: { message: "hi" },
+			model: "jev-latest"
+		}]);
+	}));
+	it("keeps the rubric as a tuple, so levels are positional rather than parsed", () => {
+		(0, import_dist.expectTypeOf)().toEqualTypeOf();
+		(0, import_dist.expectTypeOf)().toEqualTypeOf();
+	});
+});
+describe("reading an answer", () => {
+	it("derives a Probability answer's distribution as [p, 1 - p]", () => {
+		const [yes, no] = probabilitiesOf(fixture.urgent);
+		globalExpect(yes).toBeCloseTo(.94, 10);
+		globalExpect(no).toBeCloseTo(.06, 10);
+	});
+	it("ranks labels best first and names the winner", () => {
+		globalExpect(ranked(fixture.department)).toEqual([{
+			label: "billing",
+			probability: .62
+		}, {
+			label: "technical",
+			probability: .38
+		}]);
+		globalExpect(winner(fixture.department)).toStrictEqual(Option.some("billing"));
+	});
+	it("has no winner for an empty label set", () => {
+		globalExpect(winner({
+			_tag: "Classify",
+			labels: {}
+		})).toStrictEqual(Option.none());
+	});
+	it("reads a rubric by index and by expected value", () => {
+		globalExpect(topLevel(fixture.severity)).toBe(1);
+		globalExpect(expectedLevel(fixture.severity)).toBeCloseTo(1.3, 10);
+		globalExpect(fixture.severity.legend[topLevel(fixture.severity)]).toBe("Degraded");
+	});
+	it("resolves a level tie to the lowest index", () => {
+		globalExpect(topLevel({
+			_tag: "Rate",
+			levels: [.5, .5],
+			legend: ["a", "b"]
+		})).toBe(0);
+	});
+	it("computes certainty for every kind, including Probability", () => {
+		globalExpect(confidence(fixture.urgent)).toBeCloseTo(.67, 2);
+		globalExpect(margin(fixture.urgent)).toBeCloseTo(.88, 10);
+		globalExpect(margin(fixture.department)).toBeCloseTo(.24, 10);
+	});
+});
+describe("assertKinds", () => {
+	const supported = ["Classify", "Probability"];
+	it.effect("passes when every kind is supported", () => {
+		const { department, urgent } = triage.decisions;
+		return assertKinds({
+			department,
+			urgent
+		}, supported, "nli");
+	});
+	it.effect("fails Unsupported and names every offender at once", () => Effect.gen(function* () {
+		const decisions = {
+			...triage.decisions,
+			impact: rate({
+				instructions: "How bad?",
+				criteria: ["low", "high"]
+			})
+		};
+		const error = yield* Effect.flip(assertKinds(decisions, supported, "nli"));
+		globalExpect(error).toBeInstanceOf(Unsupported);
+		if (error._tag !== "Unsupported") return;
+		globalExpect(error.reason).toContain("\"severity\" is a Rate");
+		globalExpect(error.reason).toContain("\"impact\" is a Rate");
+		globalExpect(error.reason).not.toContain("department");
+	}));
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=Decision.test.mjs.map

package/dist/decision-model/Decision.test.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Decision.test.mjs","names":["Decision.make","Decision.classify","Decision.rate","Decision.probability","Decision.probabilitiesOf","Decision.ranked","Decision.winner","Decision.topLevel","Decision.expectedLevel","Decision.confidence","Decision.margin","Decision.assertKinds","AiError.Unsupported"],"sources":["../../src/decision-model/Decision.test.ts"],"sourcesContent":["import { describe, it } from \"@effect/vitest\"\nimport { Effect, Layer, Option, Ref, Schema } from \"effect\"\nimport { expect, expectTypeOf } from \"vitest\"\nimport * as AiError from \"../domain/AiError.js\"\nimport * as Decision from \"./Decision.js\"\nimport { decide, DecisionModel, type DecisionModelService } from \"./DecisionModel.js\"\n\nconst triage = Decision.make({\n  inputSchema: Schema.Struct({ message: Schema.String }),\n  decisions: {\n    department: Decision.classify({\n      instructions: \"Which team should handle this?\",\n      criteria: { billing: \"Payments, invoicing\", technical: \"Bugs, outages\" },\n    }),\n    severity: Decision.rate({\n      instructions: \"How severe is it?\",\n      criteria: [\"Cosmetic\", \"Degraded\", \"Blocking\"],\n    }),\n    urgent: Decision.probability({ instructions: \"Does this convey urgency?\" }),\n  },\n})\n\nconst fixture = {\n  department: { _tag: \"Classify\", labels: { billing: 0.62, technical: 0.38 } },\n  severity: { _tag: \"Rate\", levels: [0, 0.7, 0.3], legend: [\"Cosmetic\", \"Degraded\", \"Blocking\"] },\n  urgent: { _tag: \"Probability\", probability: 0.94 },\n} as const\n\n/**\n * A fixed fixture cannot prove it satisfies the caller's `Answers<D>`. This is\n * the boundary a provider casts at too, once it has decoded the wire.\n */\nconst fixed = <D extends Decision.Decisions>(\n  answers: Readonly<Record<string, Decision.Answer>>,\n): Decision.Answers<D> => answers as Decision.Answers<D>\n\ntype Call = { readonly input: unknown; readonly model: string }\n\n/** A `DecisionModel` layer that records what reached it. */\nconst recording = Effect.gen(function* () {\n  const calls = yield* Ref.make<ReadonlyArray<Call>>([])\n  const service: DecisionModelService = {\n    decide: (_definition, request) =>\n      Effect.as(\n        Ref.update(calls, (seen) => [...seen, { input: request.input, model: request.model }]),\n        { answers: fixed(fixture), usage: {} },\n      ),\n  }\n  return { calls, layer: Layer.succeed(DecisionModel, service) }\n})\n\ndescribe(\"the answer map is derived from the definition\", () => {\n  it.effect(\"keeps each decision's label keys and rejects labels it never had\", () =>\n    Effect.gen(function* () {\n      const { calls, layer } = yield* recording\n      const result = yield* decide(triage, {\n        model: \"jev-latest\",\n        input: { message: \"hi\" },\n      }).pipe(Effect.provide(layer))\n\n      expectTypeOf(result.answers.department.labels).toEqualTypeOf<{\n        readonly billing: number\n        readonly technical: number\n      }>()\n      // @ts-expect-error shipping is not a label of this decision\n      result.answers.department.labels.shipping\n      // @ts-expect-error a Probability answer has no labels\n      result.answers.urgent.labels\n\n      // `decide` forwards both arguments rather than dropping either.\n      expect(yield* Ref.get(calls)).toEqual([{ input: { message: \"hi\" }, model: \"jev-latest\" }])\n    }),\n  )\n\n  it(\"keeps the rubric as a tuple, so levels are positional rather than parsed\", () => {\n    type Severity = (typeof triage)[\"decisions\"][\"severity\"]\n    expectTypeOf<Decision.AnswerFor<Severity>[\"levels\"]>().toEqualTypeOf<\n      readonly [number, number, number]\n    >()\n    expectTypeOf<Decision.AnswerFor<Severity>[\"legend\"]>().toEqualTypeOf<\n      readonly [\"Cosmetic\", \"Degraded\", \"Blocking\"]\n    >()\n  })\n})\n\ndescribe(\"reading an answer\", () => {\n  it(\"derives a Probability answer's distribution as [p, 1 - p]\", () => {\n    const [yes, no] = Decision.probabilitiesOf(fixture.urgent)\n    expect(yes).toBeCloseTo(0.94, 10)\n    expect(no).toBeCloseTo(0.06, 10)\n  })\n\n  it(\"ranks labels best first and names the winner\", () => {\n    expect(Decision.ranked(fixture.department)).toEqual([\n      { label: \"billing\", probability: 0.62 },\n      { label: \"technical\", probability: 0.38 },\n    ])\n    expect(Decision.winner(fixture.department)).toStrictEqual(Option.some(\"billing\"))\n  })\n\n  it(\"has no winner for an empty label set\", () => {\n    expect(Decision.winner({ _tag: \"Classify\", labels: {} })).toStrictEqual(Option.none())\n  })\n\n  it(\"reads a rubric by index and by expected value\", () => {\n    expect(Decision.topLevel(fixture.severity)).toBe(1)\n    expect(Decision.expectedLevel(fixture.severity)).toBeCloseTo(1.3, 10)\n    expect(fixture.severity.legend[Decision.topLevel(fixture.severity)]).toBe(\"Degraded\")\n  })\n\n  it(\"resolves a level tie to the lowest index\", () => {\n    expect(Decision.topLevel({ _tag: \"Rate\", levels: [0.5, 0.5], legend: [\"a\", \"b\"] })).toBe(0)\n  })\n\n  it(\"computes certainty for every kind, including Probability\", () => {\n    expect(Decision.confidence(fixture.urgent)).toBeCloseTo(0.67, 2)\n    expect(Decision.margin(fixture.urgent)).toBeCloseTo(0.88, 10)\n    expect(Decision.margin(fixture.department)).toBeCloseTo(0.24, 10)\n  })\n})\n\ndescribe(\"assertKinds\", () => {\n  const supported = [\"Classify\", \"Probability\"] as const\n\n  it.effect(\"passes when every kind is supported\", () => {\n    const { department, urgent } = triage.decisions\n    return Decision.assertKinds({ department, urgent }, supported, \"nli\")\n  })\n\n  it.effect(\"fails Unsupported and names every offender at once\", () =>\n    Effect.gen(function* () {\n      const decisions = {\n        ...triage.decisions,\n        impact: Decision.rate({ instructions: \"How bad?\", criteria: [\"low\", \"high\"] }),\n      }\n      const error = yield* Effect.flip(Decision.assertKinds(decisions, supported, \"nli\"))\n\n      expect(error).toBeInstanceOf(AiError.Unsupported)\n      if (error._tag !== \"Unsupported\") return\n\n      expect(error.reason).toContain('\"severity\" is a Rate')\n      expect(error.reason).toContain('\"impact\" is a Rate')\n      expect(error.reason).not.toContain(\"department\")\n    }),\n  )\n})\n"],"mappings":"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"}

package/dist/decision-model/DecisionModel.d.mts

@@ -0,0 +1,45 @@
+import { t as AiError } from "../AiError-DvhLIbmd.mjs";
+import { Answers, Decisions, Definition } from "./Decision.mjs";
+import { Context, Effect } from "effect";
+declare namespace DecisionModel_d_exports {
+  export { CommonDecideRequest, DecideResponse, DecideUsage, DecisionModel, DecisionModelService, decide };
+}
+/** Optional throughout: not every backing reports token counts. */
+type DecideUsage = {
+  readonly inputTokens?: number;
+  readonly outputTokens?: number;
+};
+type DecideResponse<D extends Decisions = Decisions> = {
+  readonly answers: Answers<D>;
+  readonly usage: DecideUsage;
+};
+/**
+ * Cross-provider decide request. The input is billed once for the whole
+ * definition, so batching decisions is cheaper than repeating the input.
+ */
+type CommonDecideRequest<A> = {
+  readonly input: A;
+  /** Each provider narrows this to its typed literal union. */
+  readonly model: string;
+};
+type DecisionModelService = {
+  readonly decide: <A, D extends Decisions>(definition: Definition<A, D>, request: CommonDecideRequest<A>) => Effect.Effect<DecideResponse<D>, AiError>;
+};
+declare const DecisionModel_base: Context.ServiceClass<DecisionModel, "@betalyra/effect-uai/DecisionModel", DecisionModelService>;
+/**
+ * Answering typed questions about an input with probabilities instead of
+ * generating text. The model reports beliefs; the decision stays in the
+ * caller's code.
+ *
+ * Implementor contract: answer every decision or fail. Omitting one leaves a
+ * hole where {@link DecideResponse} promises a key, so a kind the backing
+ * cannot express is rejected up front with `Decision.assertKinds`.
+ *
+ * @experimental The model class this abstracts is new and the shape may change.
+ */
+declare class DecisionModel extends DecisionModel_base {}
+/** Answer a definition's decisions about one input in one call. */
+declare const decide: <A, D extends Decisions>(definition: Definition<A, D>, request: CommonDecideRequest<A>) => Effect.Effect<DecideResponse<D>, AiError, DecisionModel>;
+//#endregion
+export { CommonDecideRequest, DecideResponse, DecideUsage, DecisionModel, DecisionModelService, decide, DecisionModel_d_exports as t };
+//# sourceMappingURL=DecisionModel.d.mts.map

package/dist/decision-model/DecisionModel.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DecisionModel.d.mts","names":[],"sources":["../../src/decision-model/DecisionModel.ts"],"mappings":";;;;;;;KAKY;WACD;WACA;;KAGC,eAAe,UAAU,YAAqB;WAC/C,SAAS,QAAiB;WAC1B,OAAO;;;;;;KAON,oBAAoB;WACrB,OAAO;;WAEP;;KAGC;WACD,SAAS,GAAG,UAAU,WAC7B,YAAY,WAAoB,GAAG,IACnC,SAAS,oBAAoB,OAC1B,OAAO,OAAO,eAAe,IAAI;;;;;;;;;;;;;;cAc3B,sBAAsB;;cAKtB,SAAU,GAAG,UAAU,WAAkB,YACxC,WAAoB,GAAG,IAAE,SAC5B,oBAAoB,OAC5B,OAAO,OAAO,eAAe,IAAI,SAAiB"}

package/dist/decision-model/DecisionModel.mjs

@@ -0,0 +1,25 @@
+import { n as __exportAll } from "../rolldown-runtime-EAsCxrDo.mjs";
+import { Context, Effect } from "effect";
+//#region src/decision-model/DecisionModel.ts
+var DecisionModel_exports = /* @__PURE__ */ __exportAll({
+	DecisionModel: () => DecisionModel,
+	decide: () => decide
+});
+/**
+* Answering typed questions about an input with probabilities instead of
+* generating text. The model reports beliefs; the decision stays in the
+* caller's code.
+*
+* Implementor contract: answer every decision or fail. Omitting one leaves a
+* hole where {@link DecideResponse} promises a key, so a kind the backing
+* cannot express is rejected up front with `Decision.assertKinds`.
+*
+* @experimental The model class this abstracts is new and the shape may change.
+*/
+var DecisionModel = class extends Context.Service()("@betalyra/effect-uai/DecisionModel") {};
+/** Answer a definition's decisions about one input in one call. */
+const decide = (definition, request) => Effect.flatMap(DecisionModel, (m) => m.decide(definition, request));
+//#endregion
+export { DecisionModel, decide, DecisionModel_exports as t };
+
+//# sourceMappingURL=DecisionModel.mjs.map

package/dist/decision-model/DecisionModel.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DecisionModel.mjs","names":[],"sources":["../../src/decision-model/DecisionModel.ts"],"sourcesContent":["import { Context, Effect } from \"effect\"\nimport type * as AiError from \"../domain/AiError.js\"\nimport type * as Decision from \"./Decision.js\"\n\n/** Optional throughout: not every backing reports token counts. */\nexport type DecideUsage = {\n  readonly inputTokens?: number\n  readonly outputTokens?: number\n}\n\nexport type DecideResponse<D extends Decision.Decisions = Decision.Decisions> = {\n  readonly answers: Decision.Answers<D>\n  readonly usage: DecideUsage\n}\n\n/**\n * Cross-provider decide request. The input is billed once for the whole\n * definition, so batching decisions is cheaper than repeating the input.\n */\nexport type CommonDecideRequest<A> = {\n  readonly input: A\n  /** Each provider narrows this to its typed literal union. */\n  readonly model: string\n}\n\nexport type DecisionModelService = {\n  readonly decide: <A, D extends Decision.Decisions>(\n    definition: Decision.Definition<A, D>,\n    request: CommonDecideRequest<A>,\n  ) => Effect.Effect<DecideResponse<D>, AiError.AiError>\n}\n\n/**\n * Answering typed questions about an input with probabilities instead of\n * generating text. The model reports beliefs; the decision stays in the\n * caller's code.\n *\n * Implementor contract: answer every decision or fail. Omitting one leaves a\n * hole where {@link DecideResponse} promises a key, so a kind the backing\n * cannot express is rejected up front with `Decision.assertKinds`.\n *\n * @experimental The model class this abstracts is new and the shape may change.\n */\nexport class DecisionModel extends Context.Service<DecisionModel, DecisionModelService>()(\n  \"@betalyra/effect-uai/DecisionModel\",\n) {}\n\n/** Answer a definition's decisions about one input in one call. */\nexport const decide = <A, D extends Decision.Decisions>(\n  definition: Decision.Definition<A, D>,\n  request: CommonDecideRequest<A>,\n): Effect.Effect<DecideResponse<D>, AiError.AiError, DecisionModel> =>\n  Effect.flatMap(DecisionModel, (m) => m.decide(definition, request))\n"],"mappings":";;;;;;;;;;;;;;;;;;AA2CA,IAAa,gBAAb,cAAmC,QAAQ,QAA6C,CAAC,CACvF,oCACF,CAAC,CAAC,CAAC;;AAGH,MAAa,UACX,YACA,YAEA,OAAO,QAAQ,gBAAgB,MAAM,EAAE,OAAO,YAAY,OAAO,CAAC"}