@effect-agent/ai-decision 0.1.0-beta.102

package/README.md

@@ -0,0 +1,47 @@
+# @effect-agent/ai-decision
+
+Ask typed questions about application state. A `DecisionSet` defines the input and questions;
+a `DecisionModel` evaluates them through a provider. Your application owns thresholds,
+routing, and side effects.
+
+```text
+input + DecisionSet → DecisionModel → typed answers → application action
+                           ↑
+                     provider Layer
+```
+
+```ts
+import { DecisionModel, DecisionQuery, DecisionSet } from "@effect-agent/ai-decision";
+import { Effect, Schema } from "effect";
+
+const TicketAssessment = DecisionSet.make({
+  input: Schema.Struct({ message: Schema.String }),
+  questions: {
+    department: DecisionQuery.choice({
+      instructions: "Which team should handle this ticket?",
+      options: { billing: "Payments and refunds", technical: "Bugs and outages" },
+    }),
+  },
+});
+
+const assess = Effect.gen(function* () {
+  const model = yield* DecisionModel.DecisionModel;
+  const { answers } = yield* model.evaluate(TicketAssessment, {
+    message: "Please refund my duplicate charge.",
+  });
+  return answers.department.choice; // "billing" | "technical"
+});
+```
+
+Supply a provider Layer such as `TypeSafeDecisionModel.model("jev-latest")` from
+[`@effect-agent/ai-typesafe`](../ai-typesafe). The [complete example](../ai-typesafe/examples/decision.ts)
+includes provider setup and an application state transition.
+
+Use `choice` for named alternatives, `score` for ordered levels, and `probability` for a yes/no
+estimate. Questions in a set evaluate independently against the same schema-encoded input.
+Only include input the provider should receive. Returned probabilities are evidence for your
+application's policy, not authorization to act.
+
+Read the [guide](https://effect-agent.com/guide/tools#decision-transitions) for the mental model
+and the [reference](https://effect-agent.com/reference/decision-models) for query options,
+results, errors, and provider behavior.

package/dist/DecisionModel-BQpmPcHb.mjs

@@ -0,0 +1,96 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { ChoiceAnswer, Content, EvaluateRequest, EvaluateResponse, Probability, ProbabilityAnswer, ScoreAnswer } from "./DecisionSchema.mjs";
+import { Context, Effect, Schema } from "effect";
+import { AiError } from "effect/unstable/ai";
+import * as Schema$1 from "effect/Schema";
+//#region src/internal/schema.ts
+const tolerance = 1e-6;
+const probabilitySum = Schema$1.makeFilter((probabilities) => Math.abs(Object.values(probabilities).reduce((sum, value) => sum + value, 0) - 1) <= tolerance, { expected: "probabilities summing to 1 (within 1e-6)" });
+const distribution = (keys, sumCheck = probabilitySum) => Schema$1.Record(Schema$1.Literals(keys), Probability).check(sumCheck);
+const answerFor = (question, choiceProbabilitySum) => {
+	switch (question.type) {
+		case "choice": {
+			const keys = Object.keys(question.criteria);
+			return Schema$1.Struct({
+				...ChoiceAnswer.fields,
+				choice: Schema$1.Literals(keys),
+				probabilities: distribution(keys, choiceProbabilitySum)
+			}).check(Schema$1.makeFilter(({ choice, probabilities }) => Object.values(probabilities).every((value) => value <= probabilities[choice]), { expected: "a highest-probability choice" }));
+		}
+		case "score": {
+			const maxLevel = question.criteria.length - 1;
+			const levels = question.criteria.map((description, index) => [String(index), description]);
+			return Schema$1.Struct({
+				...ScoreAnswer.fields,
+				score: Schema$1.Finite.check(Schema$1.isBetween({
+					minimum: 0,
+					maximum: maxLevel
+				})),
+				legend: Schema$1.Struct(Object.fromEntries(levels.map(([key, description]) => [key, Schema$1.Literal(description)]))),
+				probabilities: distribution(levels.map(([key]) => key))
+			}).check(Schema$1.makeFilter(({ score, probabilities }) => Math.abs(score - Object.entries(probabilities).reduce((sum, [level, probability]) => sum + Number(level) * probability, 0)) <= tolerance * Math.max(1, maxLevel), { expected: "the probability-weighted score (within 1e-6 per level)" }));
+		}
+		case "probability": return ProbabilityAnswer;
+	}
+};
+function responseFor(questions, choiceProbabilitySum) {
+	return Schema$1.Struct({
+		...EvaluateResponse.fields,
+		answers: Schema$1.Struct(Object.fromEntries(Object.entries(questions).map(([id, question]) => [id, answerFor(question, choiceProbabilitySum)])))
+	});
+}
+//#endregion
+//#region src/DecisionModel.ts
+var DecisionModel_exports = /* @__PURE__ */ __exportAll({
+	DecisionModel: () => DecisionModel,
+	make: () => make
+});
+/** A decision provider, independent of the agent's generative LanguageModel. */
+var DecisionModel = class extends Context.Service()("@effect-agent/ai-decision/DecisionModel") {};
+/**
+* Construct a provider with request-derived response validation. Capture dependencies once;
+* resources acquired by evaluate close per call. Invalid data fails with native AiError.
+* Defects and interruption propagate. There are no implicit retries, deadlines, confidence
+* thresholds, or transitions. Usage is returned to the caller, not charged to an agent Run.
+*/
+const make = Effect.fnUntraced(function* (options) {
+	const services = yield* Effect.context();
+	const evaluateRequest = Effect.fn("DecisionModel.evaluate")(function* (request) {
+		const encoded = yield* Schema.encodeEffect(Schema.fromJsonString(EvaluateRequest))(request).pipe(Effect.mapError(() => new AiError.AiError({
+			module: "DecisionModel",
+			method: "evaluate",
+			reason: new AiError.InvalidRequestError({ description: "Invalid decision evaluation request" })
+		})));
+		const snapshot = yield* Schema.decodeEffect(Schema.fromJsonString(EvaluateRequest))(encoded).pipe(Effect.mapError(() => new AiError.AiError({
+			module: "DecisionModel",
+			method: "evaluate",
+			reason: new AiError.InvalidRequestError({ description: "Invalid decision evaluation request" })
+		})));
+		const schema = responseFor(request.questions, options.choiceProbabilitySum);
+		const result = yield* Effect.scoped(options.evaluate(snapshot)).pipe(Effect.provideContext(services));
+		return yield* Schema.decodeUnknownEffect(schema)(result, { onExcessProperty: "error" }).pipe(Effect.mapError(() => new AiError.AiError({
+			module: "DecisionModel",
+			method: "evaluate",
+			reason: new AiError.InvalidOutputError({ description: "Decision response disagrees with the submitted questions" })
+		})));
+	});
+	const evaluateSet = Effect.fnUntraced(function* (set, input) {
+		const state = yield* Schema.encodeEffect(set.input)(input).pipe(Effect.flatMap(Schema.decodeUnknownEffect(Content)), Effect.mapError(() => new AiError.AiError({
+			module: "DecisionModel",
+			method: "evaluate",
+			reason: new AiError.InvalidRequestError({ description: "Decision set input must encode to valid decision state" })
+		})));
+		return yield* evaluateRequest({
+			state,
+			questions: set.questions
+		});
+	});
+	function evaluate(...args) {
+		return args.length === 1 ? evaluateRequest(args[0]) : evaluateSet(args[0], args[1]);
+	}
+	return DecisionModel.of({ evaluate });
+});
+//#endregion
+export { DecisionModel_exports as n, make as r, DecisionModel as t };
+
+//# sourceMappingURL=DecisionModel-BQpmPcHb.mjs.map

package/dist/DecisionModel-BQpmPcHb.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DecisionModel-BQpmPcHb.mjs","names":["Schema","DecisionSchema.Probability","DecisionSchema.ProbabilityAnswer","DecisionSchema.EvaluateRequest","DecisionSchema.Content"],"sources":["../src/internal/schema.ts","../src/DecisionModel.ts"],"sourcesContent":["import * as Schema from \"effect/Schema\";\nimport type * as SchemaAST from \"effect/SchemaAST\";\n\nimport * as DecisionSchema from \"../DecisionSchema.ts\";\n\n// Permit floating-point serialization error without changing provider values.\nconst tolerance = 1e-6;\n\nconst probabilitySum = Schema.makeFilter(\n  (probabilities: Readonly<Record<string, number>>) =>\n    Math.abs(Object.values(probabilities).reduce((sum, value) => sum + value, 0) - 1) <= tolerance,\n  { expected: \"probabilities summing to 1 (within 1e-6)\" },\n);\n\nconst distribution = (\n  keys: ReadonlyArray<string>,\n  sumCheck: SchemaAST.Check<Readonly<Record<string, number>>> = probabilitySum,\n) => Schema.Record(Schema.Literals(keys), DecisionSchema.Probability).check(sumCheck);\n\nconst answerFor = (\n  question: DecisionSchema.Question,\n  choiceProbabilitySum: SchemaAST.Check<Readonly<Record<string, number>>> | undefined,\n) => {\n  switch (question.type) {\n    case \"choice\": {\n      const keys = Object.keys(question.criteria);\n\n      return Schema.Struct({\n        ...DecisionSchema.ChoiceAnswer.fields,\n        choice: Schema.Literals(keys),\n        probabilities: distribution(keys, choiceProbabilitySum),\n      }).check(\n        Schema.makeFilter(\n          ({ choice, probabilities }) =>\n            Object.values(probabilities).every((value) => value <= probabilities[choice]),\n          { expected: \"a highest-probability choice\" },\n        ),\n      );\n    }\n    case \"score\": {\n      const maxLevel = question.criteria.length - 1;\n\n      const levels = question.criteria.map(\n        (description, index) => [String(index), description] as const,\n      );\n\n      return Schema.Struct({\n        ...DecisionSchema.ScoreAnswer.fields,\n        score: Schema.Finite.check(Schema.isBetween({ minimum: 0, maximum: maxLevel })),\n        legend: Schema.Struct(\n          Object.fromEntries(\n            levels.map(([key, description]) => [key, Schema.Literal(description)]),\n          ),\n        ),\n        probabilities: distribution(levels.map(([key]) => key)),\n      }).check(\n        Schema.makeFilter(\n          ({ score, probabilities }) =>\n            Math.abs(\n              score -\n                Object.entries(probabilities).reduce(\n                  (sum, [level, probability]) => sum + Number(level) * probability,\n                  0,\n                ),\n            ) <=\n            tolerance * Math.max(1, maxLevel),\n          { expected: \"the probability-weighted score (within 1e-6 per level)\" },\n        ),\n      );\n    }\n    case \"probability\":\n      return DecisionSchema.ProbabilityAnswer;\n  }\n};\n\n// The overload describes the dependent type enforced by the literal keys and\n// per-question schemas below. No JSON value is asserted to have that type.\nexport function responseFor<const Q extends DecisionSchema.Questions>(\n  questions: Q,\n  choiceProbabilitySum?: SchemaAST.Check<Readonly<Record<string, number>>>,\n): Schema.Codec<DecisionSchema.EvaluateResponse<Q>>;\n\nexport function responseFor(\n  questions: DecisionSchema.Questions,\n  choiceProbabilitySum?: SchemaAST.Check<Readonly<Record<string, number>>>,\n): Schema.Top {\n  return Schema.Struct({\n    ...DecisionSchema.EvaluateResponse.fields,\n    answers: Schema.Struct(\n      Object.fromEntries(\n        Object.entries(questions).map(([id, question]) => [\n          id,\n          answerFor(question, choiceProbabilitySum),\n        ]),\n      ),\n    ),\n  });\n}\n","import { Context, Effect, Schema, type SchemaAST, type Scope } from \"effect\";\nimport { AiError } from \"effect/unstable/ai\";\n\nimport * as DecisionSchema from \"./DecisionSchema.ts\";\nimport type * as DecisionSet from \"./DecisionSet.ts\";\nimport { responseFor } from \"./internal/schema.ts\";\n\n/** Typed semantic evaluations; the caller owns thresholds, transitions, and side effects. */\nexport interface Service {\n  readonly evaluate: {\n    <const Q extends DecisionSchema.Questions>(\n      request: DecisionSchema.EvaluateRequest<Q>,\n    ): Effect.Effect<DecisionSchema.EvaluateResponse<Q>, AiError.AiError>;\n    /** Encode typed input as state, preserving the schema's encoding requirements. */\n    <Input extends Schema.Top, const Q extends DecisionSchema.Questions>(\n      set: DecisionSet.DecisionSet<Input, Q>,\n      input: NoInfer<Input[\"Type\"]>,\n    ): Effect.Effect<\n      DecisionSchema.EvaluateResponse<Q>,\n      AiError.AiError,\n      Input[\"EncodingServices\"]\n    >;\n  };\n}\n\n/** A decision provider, independent of the agent's generative LanguageModel. */\nexport class DecisionModel extends Context.Service<DecisionModel, Service>()(\n  \"@effect-agent/ai-decision/DecisionModel\",\n) {}\n\n/**\n * Construct a provider with request-derived response validation. Capture dependencies once;\n * resources acquired by evaluate close per call. Invalid data fails with native AiError.\n * Defects and interruption propagate. There are no implicit retries, deadlines, confidence\n * thresholds, or transitions. Usage is returned to the caller, not charged to an agent Run.\n */\nexport const make = Effect.fnUntraced(function* <R>(options: {\n  /**\n   * Provider-owned rounding check replacing only the Choice probability-sum check.\n   * Defaults to a sum of 1 within 1e-6. Exact keys, ranges, winning choices, and\n   * all Score checks remain enforced. This trusted construction option never\n   * comes from response metadata and must not normalize the supplied values.\n   */\n  readonly choiceProbabilitySum?: SchemaAST.Check<Readonly<Record<string, number>>>;\n  readonly evaluate: (\n    request: DecisionSchema.EvaluateRequest,\n  ) => Effect.Effect<unknown, AiError.AiError, R>;\n}): Effect.fn.Return<Service, never, Exclude<R, Scope.Scope>> {\n  const services = yield* Effect.context<Exclude<R, Scope.Scope>>();\n\n  const evaluateRequest = Effect.fn(\"DecisionModel.evaluate\")(function* <\n    const Q extends DecisionSchema.Questions,\n  >(\n    request: DecisionSchema.EvaluateRequest<Q>,\n  ): Effect.fn.Return<DecisionSchema.EvaluateResponse<Q>, AiError.AiError> {\n    // Encode and decode once to snapshot caller-owned state and criteria before provider I/O.\n    const encoded = yield* Schema.encodeEffect(\n      Schema.fromJsonString(DecisionSchema.EvaluateRequest),\n    )(request).pipe(\n      Effect.mapError(\n        () =>\n          new AiError.AiError({\n            module: \"DecisionModel\",\n            method: \"evaluate\",\n            reason: new AiError.InvalidRequestError({\n              description: \"Invalid decision evaluation request\",\n            }),\n          }),\n      ),\n    );\n\n    const snapshot = yield* Schema.decodeEffect(\n      Schema.fromJsonString(DecisionSchema.EvaluateRequest),\n    )(encoded).pipe(\n      Effect.mapError(\n        () =>\n          new AiError.AiError({\n            module: \"DecisionModel\",\n            method: \"evaluate\",\n            reason: new AiError.InvalidRequestError({\n              description: \"Invalid decision evaluation request\",\n            }),\n          }),\n      ),\n    );\n\n    const schema = responseFor(request.questions, options.choiceProbabilitySum);\n\n    const result = yield* Effect.scoped(options.evaluate(snapshot)).pipe(\n      Effect.provideContext(services),\n    );\n\n    return yield* Schema.decodeUnknownEffect(schema)(result, { onExcessProperty: \"error\" }).pipe(\n      Effect.mapError(\n        () =>\n          new AiError.AiError({\n            module: \"DecisionModel\",\n            method: \"evaluate\",\n            reason: new AiError.InvalidOutputError({\n              description: \"Decision response disagrees with the submitted questions\",\n            }),\n          }),\n      ),\n    );\n  });\n\n  const evaluateSet = Effect.fnUntraced(function* <\n    Input extends Schema.Top,\n    const Q extends DecisionSchema.Questions,\n  >(set: DecisionSet.DecisionSet<Input, Q>, input: Input[\"Type\"]) {\n    const state = yield* Schema.encodeEffect(set.input)(input).pipe(\n      Effect.flatMap(Schema.decodeUnknownEffect(DecisionSchema.Content)),\n      Effect.mapError(\n        () =>\n          new AiError.AiError({\n            module: \"DecisionModel\",\n            method: \"evaluate\",\n            reason: new AiError.InvalidRequestError({\n              description: \"Decision set input must encode to valid decision state\",\n            }),\n          }),\n      ),\n    );\n\n    return yield* evaluateRequest({ state, questions: set.questions });\n  });\n\n  function evaluate<const Q extends DecisionSchema.Questions>(\n    request: DecisionSchema.EvaluateRequest<Q>,\n  ): Effect.Effect<DecisionSchema.EvaluateResponse<Q>, AiError.AiError>;\n  function evaluate<Input extends Schema.Top, const Q extends DecisionSchema.Questions>(\n    set: DecisionSet.DecisionSet<Input, Q>,\n    input: NoInfer<Input[\"Type\"]>,\n  ): Effect.Effect<DecisionSchema.EvaluateResponse<Q>, AiError.AiError, Input[\"EncodingServices\"]>;\n  function evaluate<Input extends Schema.Top, const Q extends DecisionSchema.Questions>(\n    ...args:\n      | [DecisionSchema.EvaluateRequest<Q>]\n      | [DecisionSet.DecisionSet<Input, Q>, Input[\"Type\"]]\n  ): Effect.Effect<DecisionSchema.EvaluateResponse<Q>, AiError.AiError, Input[\"EncodingServices\"]> {\n    return args.length === 1 ? evaluateRequest(args[0]) : evaluateSet(args[0], args[1]);\n  }\n\n  return DecisionModel.of({ evaluate });\n});\n"],"mappings":";;;;;;AAMA,MAAM,YAAY;AAElB,MAAM,iBAAiBA,SAAO,YAC3B,kBACC,KAAK,IAAI,OAAO,OAAO,aAAa,CAAC,CAAC,QAAQ,KAAK,UAAU,MAAM,OAAO,CAAC,IAAI,CAAC,KAAK,WACvF,EAAE,UAAU,2CAA2C,CACzD;AAEA,MAAM,gBACJ,MACA,WAA8D,mBAC3DA,SAAO,OAAOA,SAAO,SAAS,IAAI,GAAGC,WAA0B,CAAC,CAAC,MAAM,QAAQ;AAEpF,MAAM,aACJ,UACA,yBACG;CACH,QAAQ,SAAS,MAAjB;EACE,KAAK,UAAU;GACb,MAAM,OAAO,OAAO,KAAK,SAAS,QAAQ;GAE1C,OAAOD,SAAO,OAAO;IACnB,GAAA,aAA+B;IAC/B,QAAQA,SAAO,SAAS,IAAI;IAC5B,eAAe,aAAa,MAAM,oBAAoB;GACxD,CAAC,CAAC,CAAC,MACDA,SAAO,YACJ,EAAE,QAAQ,oBACT,OAAO,OAAO,aAAa,CAAC,CAAC,OAAO,UAAU,SAAS,cAAc,OAAO,GAC9E,EAAE,UAAU,+BAA+B,CAC7C,CACF;EACF;EACA,KAAK,SAAS;GACZ,MAAM,WAAW,SAAS,SAAS,SAAS;GAE5C,MAAM,SAAS,SAAS,SAAS,KAC9B,aAAa,UAAU,CAAC,OAAO,KAAK,GAAG,WAAW,CACrD;GAEA,OAAOA,SAAO,OAAO;IACnB,GAAA,YAA8B;IAC9B,OAAOA,SAAO,OAAO,MAAMA,SAAO,UAAU;KAAE,SAAS;KAAG,SAAS;IAAS,CAAC,CAAC;IAC9E,QAAQA,SAAO,OACb,OAAO,YACL,OAAO,KAAK,CAAC,KAAK,iBAAiB,CAAC,KAAKA,SAAO,QAAQ,WAAW,CAAC,CAAC,CACvE,CACF;IACA,eAAe,aAAa,OAAO,KAAK,CAAC,SAAS,GAAG,CAAC;GACxD,CAAC,CAAC,CAAC,MACDA,SAAO,YACJ,EAAE,OAAO,oBACR,KAAK,IACH,QACE,OAAO,QAAQ,aAAa,CAAC,CAAC,QAC3B,KAAK,CAAC,OAAO,iBAAiB,MAAM,OAAO,KAAK,IAAI,aACrD,CACF,CACJ,KACA,YAAY,KAAK,IAAI,GAAG,QAAQ,GAClC,EAAE,UAAU,yDAAyD,CACvE,CACF;EACF;EACA,KAAK,eACH,OAAOE;CACX;AACF;AASA,SAAgB,YACd,WACA,sBACY;CACZ,OAAOF,SAAO,OAAO;EACnB,GAAA,iBAAmC;EACnC,SAASA,SAAO,OACd,OAAO,YACL,OAAO,QAAQ,SAAS,CAAC,CAAC,KAAK,CAAC,IAAI,cAAc,CAChD,IACA,UAAU,UAAU,oBAAoB,CAC1C,CAAC,CACH,CACF;CACF,CAAC;AACH;;;;;;;;ACvEA,IAAa,gBAAb,cAAmC,QAAQ,QAAgC,CAAC,CAC1E,yCACF,CAAC,CAAC,CAAC;;;;;;;AAQH,MAAa,OAAO,OAAO,WAAW,WAAc,SAWU;CAC5D,MAAM,WAAW,OAAO,OAAO,QAAiC;CAEhE,MAAM,kBAAkB,OAAO,GAAG,wBAAwB,CAAC,CAAC,WAG1D,SACuE;EAEvE,MAAM,UAAU,OAAO,OAAO,aAC5B,OAAO,eAAeG,eAA8B,CACtD,CAAC,CAAC,OAAO,CAAC,CAAC,KACT,OAAO,eAEH,IAAI,QAAQ,QAAQ;GAClB,QAAQ;GACR,QAAQ;GACR,QAAQ,IAAI,QAAQ,oBAAoB,EACtC,aAAa,sCACf,CAAC;EACH,CAAC,CACL,CACF;EAEA,MAAM,WAAW,OAAO,OAAO,aAC7B,OAAO,eAAeA,eAA8B,CACtD,CAAC,CAAC,OAAO,CAAC,CAAC,KACT,OAAO,eAEH,IAAI,QAAQ,QAAQ;GAClB,QAAQ;GACR,QAAQ;GACR,QAAQ,IAAI,QAAQ,oBAAoB,EACtC,aAAa,sCACf,CAAC;EACH,CAAC,CACL,CACF;EAEA,MAAM,SAAS,YAAY,QAAQ,WAAW,QAAQ,oBAAoB;EAE1E,MAAM,SAAS,OAAO,OAAO,OAAO,QAAQ,SAAS,QAAQ,CAAC,CAAC,CAAC,KAC9D,OAAO,eAAe,QAAQ,CAChC;EAEA,OAAO,OAAO,OAAO,oBAAoB,MAAM,CAAC,CAAC,QAAQ,EAAE,kBAAkB,QAAQ,CAAC,CAAC,CAAC,KACtF,OAAO,eAEH,IAAI,QAAQ,QAAQ;GAClB,QAAQ;GACR,QAAQ;GACR,QAAQ,IAAI,QAAQ,mBAAmB,EACrC,aAAa,2DACf,CAAC;EACH,CAAC,CACL,CACF;CACF,CAAC;CAED,MAAM,cAAc,OAAO,WAAW,WAGpC,KAAwC,OAAsB;EAC9D,MAAM,QAAQ,OAAO,OAAO,aAAa,IAAI,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,KACzD,OAAO,QAAQ,OAAO,oBAAoBC,OAAsB,CAAC,GACjE,OAAO,eAEH,IAAI,QAAQ,QAAQ;GAClB,QAAQ;GACR,QAAQ;GACR,QAAQ,IAAI,QAAQ,oBAAoB,EACtC,aAAa,yDACf,CAAC;EACH,CAAC,CACL,CACF;EAEA,OAAO,OAAO,gBAAgB;GAAE;GAAO,WAAW,IAAI;EAAU,CAAC;CACnE,CAAC;CASD,SAAS,SACP,GAAG,MAG4F;EAC/F,OAAO,KAAK,WAAW,IAAI,gBAAgB,KAAK,EAAE,IAAI,YAAY,KAAK,IAAI,KAAK,EAAE;CACpF;CAEA,OAAO,cAAc,GAAG,EAAE,SAAS,CAAC;AACtC,CAAC"}

package/dist/DecisionModel.d.mts

@@ -0,0 +1,37 @@
+import { EvaluateRequest, EvaluateResponse, Questions, t as DecisionSchema_d_exports } from "./DecisionSchema.mjs";
+import { DecisionSet, t as DecisionSet_d_exports } from "./DecisionSet.mjs";
+import { Context, Effect, Schema, SchemaAST, Scope } from "effect";
+import { AiError } from "effect/unstable/ai";
+declare namespace DecisionModel_d_exports {
+  export { DecisionModel, Service, make };
+}
+/** Typed semantic evaluations; the caller owns thresholds, transitions, and side effects. */
+export interface Service {
+  readonly evaluate: {
+    <const Q extends Questions>(request: EvaluateRequest<Q>): Effect.Effect<EvaluateResponse<Q>, AiError.AiError>;
+    /** Encode typed input as state, preserving the schema's encoding requirements. */
+    <Input extends Schema.Top, const Q extends Questions>(set: DecisionSet<Input, Q>, input: NoInfer<Input["Type"]>): Effect.Effect<EvaluateResponse<Q>, AiError.AiError, Input["EncodingServices"]>;
+  };
+}
+declare const DecisionModel_base: Context.ServiceClass<DecisionModel, "@effect-agent/ai-decision/DecisionModel", Service>;
+/** A decision provider, independent of the agent's generative LanguageModel. */
+export declare class DecisionModel extends DecisionModel_base {}
+/**
+ * Construct a provider with request-derived response validation. Capture dependencies once;
+ * resources acquired by evaluate close per call. Invalid data fails with native AiError.
+ * Defects and interruption propagate. There are no implicit retries, deadlines, confidence
+ * thresholds, or transitions. Usage is returned to the caller, not charged to an agent Run.
+ */
+export declare const make: <R>(options: {
+  /**
+   * Provider-owned rounding check replacing only the Choice probability-sum check.
+   * Defaults to a sum of 1 within 1e-6. Exact keys, ranges, winning choices, and
+   * all Score checks remain enforced. This trusted construction option never
+   * comes from response metadata and must not normalize the supplied values.
+   */
+  readonly choiceProbabilitySum?: SchemaAST.Check<Readonly<Record<string, number>>>;
+  readonly evaluate: (request: EvaluateRequest) => Effect.Effect<unknown, AiError.AiError, R>;
+}) => Effect.Effect<Service, never, Exclude<R, Scope.Scope>>;
+//#endregion
+export { DecisionModel_d_exports as t };
+//# sourceMappingURL=DecisionModel.d.mts.map

package/dist/DecisionModel.mjs

@@ -0,0 +1,3 @@
+import "./DecisionSchema.mjs";
+import { r as make, t as DecisionModel } from "./DecisionModel-BQpmPcHb.mjs";
+export { DecisionModel, make };

package/dist/DecisionQuery.d.mts

@@ -0,0 +1,59 @@
+import { ChoiceQuestion, Content, ProbabilityQuestion, t as DecisionSchema_d_exports } from "./DecisionSchema.mjs";
+declare namespace DecisionQuery_d_exports {
+  export { choice, probability, score };
+}
+/**
+ * Choose one named option and retain the complete categorical distribution.
+ * Option keys infer the answer's choice union. Supply at least one option;
+ * null descriptions use the option name alone.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const choice: <const Options extends ChoiceQuestion["criteria"]>(options: {
+  readonly instructions: Content;
+  readonly options: Options;
+}) => Readonly<{
+  type: "choice";
+  instructions: string | readonly import("effect/Schema").Json[] | {
+    readonly [x: string]: import("effect/Schema").Json;
+  };
+  criteria: Readonly<Options>;
+}>;
+/**
+ * Rate a state along at least two ordered descriptions. The answer is the
+ * probability-weighted, zero-indexed position and may fall between levels.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const score: (options: {
+  readonly instructions: Content;
+  readonly levels: ReadonlyArray<string>;
+}) => Readonly<{
+  type: "score";
+  instructions: string | readonly import("effect/Schema").Json[] | {
+    readonly [x: string]: import("effect/Schema").Json;
+  };
+  criteria: readonly string[];
+}>;
+/**
+ * Estimate the probability a proposition is true. Optional criteria clarify
+ * either outcome. No threshold or implicit boolean conversion is applied.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const probability: (options: Omit<ProbabilityQuestion, "type">) => Readonly<{
+  type: "probability";
+  instructions: string | readonly import("effect/Schema").Json[] | {
+    readonly [x: string]: import("effect/Schema").Json;
+  };
+  criteria?: Readonly<{
+    true?: string | undefined;
+    false?: string | undefined;
+  }> | undefined;
+}>;
+//#endregion
+export { DecisionQuery_d_exports as t };
+//# sourceMappingURL=DecisionQuery.d.mts.map

package/dist/DecisionQuery.mjs

@@ -0,0 +1,48 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+//#region src/DecisionQuery.ts
+var DecisionQuery_exports = /* @__PURE__ */ __exportAll({
+	choice: () => choice,
+	probability: () => probability,
+	score: () => score
+});
+/**
+* Choose one named option and retain the complete categorical distribution.
+* Option keys infer the answer's choice union. Supply at least one option;
+* null descriptions use the option name alone.
+*
+* @category constructors
+* @since 0.1.0
+*/
+const choice = (options) => Object.freeze({
+	type: "choice",
+	instructions: options.instructions,
+	criteria: Object.freeze({ ...options.options })
+});
+/**
+* Rate a state along at least two ordered descriptions. The answer is the
+* probability-weighted, zero-indexed position and may fall between levels.
+*
+* @category constructors
+* @since 0.1.0
+*/
+const score = (options) => Object.freeze({
+	type: "score",
+	instructions: options.instructions,
+	criteria: Object.freeze([...options.levels])
+});
+/**
+* Estimate the probability a proposition is true. Optional criteria clarify
+* either outcome. No threshold or implicit boolean conversion is applied.
+*
+* @category constructors
+* @since 0.1.0
+*/
+const probability = (options) => Object.freeze({
+	type: "probability",
+	instructions: options.instructions,
+	...options.criteria === void 0 ? {} : { criteria: Object.freeze({ ...options.criteria }) }
+});
+//#endregion
+export { choice, probability, score, DecisionQuery_exports as t };
+
+//# sourceMappingURL=DecisionQuery.mjs.map

package/dist/DecisionQuery.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DecisionQuery.mjs","names":[],"sources":["../src/DecisionQuery.ts"],"sourcesContent":["/**\n * Pure constructors for questions evaluated by a DecisionModel. Definitions\n * are validated when evaluated; constructing a query performs no model I/O.\n *\n * @since 0.1.0\n */\nimport type * as DecisionSchema from \"./DecisionSchema.ts\";\n\n/**\n * Choose one named option and retain the complete categorical distribution.\n * Option keys infer the answer's choice union. Supply at least one option;\n * null descriptions use the option name alone.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const choice = <const Options extends DecisionSchema.ChoiceQuestion[\"criteria\"]>(options: {\n  readonly instructions: DecisionSchema.Content;\n  readonly options: Options;\n}) =>\n  Object.freeze({\n    type: \"choice\" as const,\n    instructions: options.instructions,\n    criteria: Object.freeze({ ...options.options }),\n  });\n\n/**\n * Rate a state along at least two ordered descriptions. The answer is the\n * probability-weighted, zero-indexed position and may fall between levels.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const score = (options: {\n  readonly instructions: DecisionSchema.Content;\n  readonly levels: ReadonlyArray<string>;\n}) =>\n  Object.freeze({\n    type: \"score\" as const,\n    instructions: options.instructions,\n    criteria: Object.freeze([...options.levels]),\n  });\n\n/**\n * Estimate the probability a proposition is true. Optional criteria clarify\n * either outcome. No threshold or implicit boolean conversion is applied.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const probability = (options: Omit<DecisionSchema.ProbabilityQuestion, \"type\">) =>\n  Object.freeze({\n    type: \"probability\" as const,\n    instructions: options.instructions,\n    ...(options.criteria === undefined ? {} : { criteria: Object.freeze({ ...options.criteria }) }),\n  });\n"],"mappings":";;;;;;;;;;;;;;;AAgBA,MAAa,UAA2E,YAItF,OAAO,OAAO;CACZ,MAAM;CACN,cAAc,QAAQ;CACtB,UAAU,OAAO,OAAO,EAAE,GAAG,QAAQ,QAAQ,CAAC;AAChD,CAAC;;;;;;;;AASH,MAAa,SAAS,YAIpB,OAAO,OAAO;CACZ,MAAM;CACN,cAAc,QAAQ;CACtB,UAAU,OAAO,OAAO,CAAC,GAAG,QAAQ,MAAM,CAAC;AAC7C,CAAC;;;;;;;;AASH,MAAa,eAAe,YAC1B,OAAO,OAAO;CACZ,MAAM;CACN,cAAc,QAAQ;CACtB,GAAI,QAAQ,aAAa,KAAA,IAAY,CAAC,IAAI,EAAE,UAAU,OAAO,OAAO,EAAE,GAAG,QAAQ,SAAS,CAAC,EAAE;AAC/F,CAAC"}

package/dist/DecisionSchema.d.mts

@@ -0,0 +1,313 @@
+import * as Schema from "effect/Schema";
+declare namespace DecisionSchema_d_exports {
+  export { Answer, AnswerFor, Answers, ChoiceAnswer, ChoiceQuestion, Content, EvaluateRequest, EvaluateResponse, Probability, ProbabilityAnswer, ProbabilityQuestion, ProviderMetadata, Question, Questions, ScoreAnswer, ScoreQuestion, Usage };
+}
+/**
+ * Text or JSON objects and arrays used as state and question instructions.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const Content: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+/** @category models
+ * @since 0.1.0
+ */
+export type Content = typeof Content.Type;
+/**
+ * A choice between named options. A null rubric uses the option name alone.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const ChoiceQuestion: Schema.Struct<{
+  readonly type: Schema.Literal<"choice">;
+  readonly instructions: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+  readonly criteria: Schema.$Record<Schema.String, Schema.NullOr<Schema.String>>;
+}>;
+/** @category models
+ * @since 0.1.0
+ */
+export type ChoiceQuestion = typeof ChoiceQuestion.Type;
+/**
+ * A rating along at least two ordered, zero-indexed level descriptions.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const ScoreQuestion: Schema.Struct<{
+  readonly type: Schema.Literal<"score">;
+  readonly instructions: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+  readonly criteria: Schema.$Array<Schema.String>;
+}>;
+/** @category models
+ * @since 0.1.0
+ */
+export type ScoreQuestion = typeof ScoreQuestion.Type;
+/**
+ * A yes/no judgment, with optional descriptions of either outcome.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const ProbabilityQuestion: Schema.Struct<{
+  readonly type: Schema.Literal<"probability">;
+  readonly instructions: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+  readonly criteria: Schema.optionalKey<Schema.Struct<{
+    readonly true: Schema.optionalKey<Schema.String>;
+    readonly false: Schema.optionalKey<Schema.String>;
+  }>>;
+}>;
+/** @category models
+ * @since 0.1.0
+ */
+export type ProbabilityQuestion = typeof ProbabilityQuestion.Type;
+/** @category schemas
+ * @since 0.1.0
+ */
+export declare const Question: Schema.Union<readonly [Schema.Struct<{
+  readonly type: Schema.Literal<"choice">;
+  readonly instructions: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+  readonly criteria: Schema.$Record<Schema.String, Schema.NullOr<Schema.String>>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"score">;
+  readonly instructions: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+  readonly criteria: Schema.$Array<Schema.String>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"probability">;
+  readonly instructions: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+  readonly criteria: Schema.optionalKey<Schema.Struct<{
+    readonly true: Schema.optionalKey<Schema.String>;
+    readonly false: Schema.optionalKey<Schema.String>;
+  }>>;
+}>]>;
+/** @category models
+ * @since 0.1.0
+ */
+export type Question = typeof Question.Type;
+/** @category schemas
+ * @since 0.1.0
+ */
+export declare const Questions: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+  readonly type: Schema.Literal<"choice">;
+  readonly instructions: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+  readonly criteria: Schema.$Record<Schema.String, Schema.NullOr<Schema.String>>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"score">;
+  readonly instructions: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+  readonly criteria: Schema.$Array<Schema.String>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"probability">;
+  readonly instructions: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+  readonly criteria: Schema.optionalKey<Schema.Struct<{
+    readonly true: Schema.optionalKey<Schema.String>;
+    readonly false: Schema.optionalKey<Schema.String>;
+  }>>;
+}>]>>;
+/** @category models
+ * @since 0.1.0
+ */
+export type Questions = typeof Questions.Type;
+/** @category schemas
+ * @since 0.1.0
+ */
+export declare const EvaluateRequest: Schema.Struct<{
+  readonly state: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+  readonly questions: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"choice">;
+    readonly instructions: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+    readonly criteria: Schema.$Record<Schema.String, Schema.NullOr<Schema.String>>;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"score">;
+    readonly instructions: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+    readonly criteria: Schema.$Array<Schema.String>;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"probability">;
+    readonly instructions: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
+    readonly criteria: Schema.optionalKey<Schema.Struct<{
+      readonly true: Schema.optionalKey<Schema.String>;
+      readonly false: Schema.optionalKey<Schema.String>;
+    }>>;
+  }>]>>;
+}>;
+/**
+ * Evaluation input. Keep question literals with `satisfies Questions` when
+ * storing questions separately from the call to `evaluate`.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type EvaluateRequest<Q extends Questions = Questions> = Omit<typeof EvaluateRequest.Type, "questions"> & {
+  readonly questions: Q;
+};
+/**
+ * A finite probability or confidence in the inclusive range [0, 1].
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const Probability: Schema.Finite;
+/**
+ * A selected option and its full distribution. Provider-specific confidence
+ * statistics belong to evaluation metadata, not the shared answer contract.
+ * Probabilities retain the provider's reported precision and are not normalized.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const ChoiceAnswer: Schema.Struct<{
+  readonly type: Schema.Literal<"choice">;
+  readonly choice: Schema.String;
+  readonly probabilities: Schema.$Record<Schema.String, Schema.Finite>;
+}>;
+/**
+ * Known option unions infer literal choices and required probability keys.
+ * Open string or template-pattern option types allow absent dictionary entries.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type ChoiceAnswer<Choice extends string = string> = Omit<typeof ChoiceAnswer.Type, "choice" | "probabilities"> & {
+  readonly choice: Choice;
+  readonly probabilities: { readonly [K in Choice]: {} extends Pick<Record<Choice, unknown>, K> ? number | undefined : number; };
+};
+/**
+ * A fractional, probability-weighted level, with the supplied rubric as legend.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const ScoreAnswer: Schema.Struct<{
+  readonly type: Schema.Literal<"score">;
+  readonly score: Schema.Finite;
+  readonly legend: Schema.$Record<Schema.String, Schema.String>;
+  readonly probabilities: Schema.$Record<Schema.String, Schema.Finite>;
+}>;
+/**
+ * Score levels are keyed at runtime; an arbitrary legend or probability lookup
+ * may be absent.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type ScoreAnswer = Omit<typeof ScoreAnswer.Type, "legend" | "probabilities"> & {
+  readonly legend: {
+    readonly [level: string]: string | undefined;
+  };
+  readonly probabilities: {
+    readonly [level: string]: number | undefined;
+  };
+};
+/**
+ * The probability of yes. A probability answer has no separate confidence field.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const ProbabilityAnswer: Schema.Struct<{
+  readonly type: Schema.Literal<"probability">;
+  readonly probability: Schema.Finite;
+}>;
+/** @category models
+ * @since 0.1.0
+ */
+export type ProbabilityAnswer = typeof ProbabilityAnswer.Type;
+/** @category schemas
+ * @since 0.1.0
+ */
+export declare const Answer: Schema.Union<readonly [Schema.Struct<{
+  readonly type: Schema.Literal<"choice">;
+  readonly choice: Schema.String;
+  readonly probabilities: Schema.$Record<Schema.String, Schema.Finite>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"score">;
+  readonly score: Schema.Finite;
+  readonly legend: Schema.$Record<Schema.String, Schema.String>;
+  readonly probabilities: Schema.$Record<Schema.String, Schema.Finite>;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"probability">;
+  readonly probability: Schema.Finite;
+}>]>;
+/** @category models
+ * @since 0.1.0
+ */
+export type Answer = ChoiceAnswer | ScoreAnswer | ProbabilityAnswer;
+/** @category schemas
+ * @since 0.1.0
+ */
+export declare const Usage: Schema.Struct<{
+  readonly inputTokens: Schema.NullOr<Schema.Natural>;
+  readonly outputTokens: Schema.NullOr<Schema.Natural>;
+}>;
+/** @category models
+ * @since 0.1.0
+ */
+export type Usage = typeof Usage.Type;
+/**
+ * Provider-namespaced evidence that has no shared interpretation. Consumers
+ * decode a namespace with its provider's schema before using its contents.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const ProviderMetadata: Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+/** @category models
+ * @since 0.1.0
+ */
+export type ProviderMetadata = typeof ProviderMetadata.Type;
+/**
+ * The wire response shape. `DecisionModel.evaluate` additionally validates
+ * answer IDs, question kinds, criteria, distributions, and score correlations.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const EvaluateResponse: Schema.Struct<{
+  readonly provider: Schema.NonEmptyString;
+  readonly model: Schema.String;
+  readonly answers: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"choice">;
+    readonly choice: Schema.String;
+    readonly probabilities: Schema.$Record<Schema.String, Schema.Finite>;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"score">;
+    readonly score: Schema.Finite;
+    readonly legend: Schema.$Record<Schema.String, Schema.String>;
+    readonly probabilities: Schema.$Record<Schema.String, Schema.Finite>;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"probability">;
+    readonly probability: Schema.Finite;
+  }>]>>;
+  readonly usage: Schema.Struct<{
+    readonly inputTokens: Schema.NullOr<Schema.Natural>;
+    readonly outputTokens: Schema.NullOr<Schema.Natural>;
+  }>;
+  readonly providerMetadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>;
+}>;
+type ChoiceAnswerFor<Criteria> = Criteria extends unknown ? Omit<typeof ChoiceAnswer.Type, "choice" | "probabilities"> & {
+  readonly choice: `${Extract<keyof Criteria, string | number>}`;
+  readonly probabilities: { readonly [K in keyof Criteria as K extends string | number ? `${K}` : never]: {} extends Pick<Criteria, K> ? number | undefined : number; };
+} : never;
+/**
+ * Infer a question's answer, preserving optional choice criteria in its probabilities.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type AnswerFor<Q extends Question> = Q extends ChoiceQuestion ? ChoiceAnswerFor<Q["criteria"]> : Q extends ScoreQuestion ? ScoreAnswer : ProbabilityAnswer;
+/**
+ * One answer for each required question. Optional properties and open string,
+ * numeric, or template-pattern indexes require checking an entry for absence.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Answers<Q extends Questions> = { readonly [K in keyof Q as K extends string | number ? `${K}` : never]: {} extends Pick<Q, K> ? AnswerFor<NonNullable<Q[K]>> | undefined : AnswerFor<Q[K]>; };
+/** @category models
+ * @since 0.1.0
+ */
+export type EvaluateResponse<Q extends Questions = Questions> = Omit<typeof EvaluateResponse.Type, "answers"> & {
+  readonly answers: Answers<Q>;
+};
+//#endregion
+export { DecisionSchema_d_exports as t };
+//# sourceMappingURL=DecisionSchema.d.mts.map