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

package/dist/DecisionSchema.mjs

@@ -0,0 +1,177 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import * as Schema from "effect/Schema";
+//#region src/DecisionSchema.ts
+/**
+* Request and response schemas for provider-neutral decision evaluations.
+*
+* @since 0.1.0
+*/
+var DecisionSchema_exports = /* @__PURE__ */ __exportAll({
+	Answer: () => Answer,
+	ChoiceAnswer: () => ChoiceAnswer,
+	ChoiceQuestion: () => ChoiceQuestion,
+	Content: () => Content,
+	EvaluateRequest: () => EvaluateRequest,
+	EvaluateResponse: () => EvaluateResponse,
+	Probability: () => Probability,
+	ProbabilityAnswer: () => ProbabilityAnswer,
+	ProbabilityQuestion: () => ProbabilityQuestion,
+	ProviderMetadata: () => ProviderMetadata,
+	Question: () => Question,
+	Questions: () => Questions,
+	ScoreAnswer: () => ScoreAnswer,
+	ScoreQuestion: () => ScoreQuestion,
+	Usage: () => Usage
+});
+/**
+* Text or JSON objects and arrays used as state and question instructions.
+*
+* @category schemas
+* @since 0.1.0
+*/
+const Content = Schema.Union([
+	Schema.String,
+	Schema.JsonObject,
+	Schema.Array(Schema.Json)
+]);
+/**
+* A choice between named options. A null rubric uses the option name alone.
+*
+* @category schemas
+* @since 0.1.0
+*/
+const ChoiceQuestion = Schema.Struct({
+	type: Schema.Literal("choice"),
+	instructions: Content,
+	criteria: Schema.Record(Schema.String, Schema.NullOr(Schema.String)).check(Schema.isMinProperties(1))
+});
+/**
+* A rating along at least two ordered, zero-indexed level descriptions.
+*
+* @category schemas
+* @since 0.1.0
+*/
+const ScoreQuestion = Schema.Struct({
+	type: Schema.Literal("score"),
+	instructions: Content,
+	criteria: Schema.Array(Schema.String).check(Schema.isMinLength(2))
+});
+/**
+* A yes/no judgment, with optional descriptions of either outcome.
+*
+* @category schemas
+* @since 0.1.0
+*/
+const ProbabilityQuestion = Schema.Struct({
+	type: Schema.Literal("probability"),
+	instructions: Content,
+	criteria: Schema.optionalKey(Schema.Struct({
+		true: Schema.optionalKey(Schema.String),
+		false: Schema.optionalKey(Schema.String)
+	}))
+});
+/** @category schemas
+* @since 0.1.0
+*/
+const Question = Schema.Union([
+	ChoiceQuestion,
+	ScoreQuestion,
+	ProbabilityQuestion
+]);
+/** @category schemas
+* @since 0.1.0
+*/
+const Questions = Schema.Record(Schema.String, Question);
+/** @category schemas
+* @since 0.1.0
+*/
+const EvaluateRequest = Schema.Struct({
+	state: Content,
+	questions: Questions
+});
+/**
+* A finite probability or confidence in the inclusive range [0, 1].
+*
+* @category schemas
+* @since 0.1.0
+*/
+const Probability = Schema.Finite.check(Schema.isBetween({
+	minimum: 0,
+	maximum: 1
+}));
+/**
+* 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
+*/
+const ChoiceAnswer = Schema.Struct({
+	type: Schema.Literal("choice"),
+	choice: Schema.String,
+	probabilities: Schema.Record(Schema.String, Probability)
+});
+/**
+* A fractional, probability-weighted level, with the supplied rubric as legend.
+*
+* @category schemas
+* @since 0.1.0
+*/
+const ScoreAnswer = Schema.Struct({
+	type: Schema.Literal("score"),
+	score: Schema.Finite.check(Schema.isGreaterThanOrEqualTo(0)),
+	legend: Schema.Record(Schema.String, Schema.String),
+	probabilities: Schema.Record(Schema.String, Probability)
+});
+/**
+* The probability of yes. A probability answer has no separate confidence field.
+*
+* @category schemas
+* @since 0.1.0
+*/
+const ProbabilityAnswer = Schema.Struct({
+	type: Schema.Literal("probability"),
+	probability: Probability
+});
+/** @category schemas
+* @since 0.1.0
+*/
+const Answer = Schema.Union([
+	ChoiceAnswer,
+	ScoreAnswer,
+	ProbabilityAnswer
+]);
+/** @category schemas
+* @since 0.1.0
+*/
+const Usage = Schema.Struct({
+	inputTokens: Schema.NullOr(Schema.Natural),
+	outputTokens: Schema.NullOr(Schema.Natural)
+});
+/**
+* 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
+*/
+const ProviderMetadata = Schema.Record(Schema.String, Schema.JsonObject);
+/**
+* The wire response shape. `DecisionModel.evaluate` additionally validates
+* answer IDs, question kinds, criteria, distributions, and score correlations.
+*
+* @category schemas
+* @since 0.1.0
+*/
+const EvaluateResponse = Schema.Struct({
+	provider: Schema.NonEmptyString,
+	model: Schema.String,
+	answers: Schema.Record(Schema.String, Answer),
+	usage: Usage,
+	providerMetadata: Schema.optionalKey(ProviderMetadata)
+});
+//#endregion
+export { Answer, ChoiceAnswer, ChoiceQuestion, Content, EvaluateRequest, EvaluateResponse, Probability, ProbabilityAnswer, ProbabilityQuestion, ProviderMetadata, Question, Questions, ScoreAnswer, ScoreQuestion, Usage, DecisionSchema_exports as t };
+
+//# sourceMappingURL=DecisionSchema.mjs.map

package/dist/DecisionSchema.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DecisionSchema.mjs","names":[],"sources":["../src/DecisionSchema.ts"],"sourcesContent":["/**\n * Request and response schemas for provider-neutral decision evaluations.\n *\n * @since 0.1.0\n */\nimport * as Schema from \"effect/Schema\";\n\n/**\n * Text or JSON objects and arrays used as state and question instructions.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const Content = Schema.Union([Schema.String, Schema.JsonObject, Schema.Array(Schema.Json)]);\n\n/** @category models\n * @since 0.1.0\n */\nexport type Content = typeof Content.Type;\n\n/**\n * A choice between named options. A null rubric uses the option name alone.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const ChoiceQuestion = Schema.Struct({\n  type: Schema.Literal(\"choice\"),\n  instructions: Content,\n  criteria: Schema.Record(Schema.String, Schema.NullOr(Schema.String)).check(\n    Schema.isMinProperties(1),\n  ),\n});\n\n/** @category models\n * @since 0.1.0\n */\nexport type ChoiceQuestion = typeof ChoiceQuestion.Type;\n\n/**\n * A rating along at least two ordered, zero-indexed level descriptions.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const ScoreQuestion = Schema.Struct({\n  type: Schema.Literal(\"score\"),\n  instructions: Content,\n  criteria: Schema.Array(Schema.String).check(Schema.isMinLength(2)),\n});\n\n/** @category models\n * @since 0.1.0\n */\nexport type ScoreQuestion = typeof ScoreQuestion.Type;\n\n/**\n * A yes/no judgment, with optional descriptions of either outcome.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const ProbabilityQuestion = Schema.Struct({\n  type: Schema.Literal(\"probability\"),\n  instructions: Content,\n  criteria: Schema.optionalKey(\n    Schema.Struct({\n      true: Schema.optionalKey(Schema.String),\n      false: Schema.optionalKey(Schema.String),\n    }),\n  ),\n});\n\n/** @category models\n * @since 0.1.0\n */\nexport type ProbabilityQuestion = typeof ProbabilityQuestion.Type;\n\n/** @category schemas\n * @since 0.1.0\n */\nexport const Question = Schema.Union([ChoiceQuestion, ScoreQuestion, ProbabilityQuestion]);\n\n/** @category models\n * @since 0.1.0\n */\nexport type Question = typeof Question.Type;\n\n/** @category schemas\n * @since 0.1.0\n */\nexport const Questions = Schema.Record(Schema.String, Question);\n\n/** @category models\n * @since 0.1.0\n */\nexport type Questions = typeof Questions.Type;\n\n/** @category schemas\n * @since 0.1.0\n */\nexport const EvaluateRequest = Schema.Struct({\n  state: Content,\n  questions: Questions,\n});\n\n/**\n * Evaluation input. Keep question literals with `satisfies Questions` when\n * storing questions separately from the call to `evaluate`.\n *\n * @category models\n * @since 0.1.0\n */\nexport type EvaluateRequest<Q extends Questions = Questions> = Omit<\n  typeof EvaluateRequest.Type,\n  \"questions\"\n> & { readonly questions: Q };\n\n/**\n * A finite probability or confidence in the inclusive range [0, 1].\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const Probability = Schema.Finite.check(Schema.isBetween({ minimum: 0, maximum: 1 }));\n\n/**\n * A selected option and its full distribution. Provider-specific confidence\n * statistics belong to evaluation metadata, not the shared answer contract.\n * Probabilities retain the provider's reported precision and are not normalized.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const ChoiceAnswer = Schema.Struct({\n  type: Schema.Literal(\"choice\"),\n  choice: Schema.String,\n  probabilities: Schema.Record(Schema.String, Probability),\n});\n\n/**\n * Known option unions infer literal choices and required probability keys.\n * Open string or template-pattern option types allow absent dictionary entries.\n *\n * @category models\n * @since 0.1.0\n */\nexport type ChoiceAnswer<Choice extends string = string> = Omit<\n  typeof ChoiceAnswer.Type,\n  \"choice\" | \"probabilities\"\n> & {\n  readonly choice: Choice;\n  readonly probabilities: {\n    readonly [K in Choice]: {} extends Pick<Record<Choice, unknown>, K>\n      ? number | undefined\n      : number;\n  };\n};\n\n/**\n * A fractional, probability-weighted level, with the supplied rubric as legend.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const ScoreAnswer = Schema.Struct({\n  type: Schema.Literal(\"score\"),\n  score: Schema.Finite.check(Schema.isGreaterThanOrEqualTo(0)),\n  legend: Schema.Record(Schema.String, Schema.String),\n  probabilities: Schema.Record(Schema.String, Probability),\n});\n\n/**\n * Score levels are keyed at runtime; an arbitrary legend or probability lookup\n * may be absent.\n *\n * @category models\n * @since 0.1.0\n */\nexport type ScoreAnswer = Omit<typeof ScoreAnswer.Type, \"legend\" | \"probabilities\"> & {\n  readonly legend: { readonly [level: string]: string | undefined };\n  readonly probabilities: { readonly [level: string]: number | undefined };\n};\n\n/**\n * The probability of yes. A probability answer has no separate confidence field.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const ProbabilityAnswer = Schema.Struct({\n  type: Schema.Literal(\"probability\"),\n  probability: Probability,\n});\n\n/** @category models\n * @since 0.1.0\n */\nexport type ProbabilityAnswer = typeof ProbabilityAnswer.Type;\n\n/** @category schemas\n * @since 0.1.0\n */\nexport const Answer = Schema.Union([ChoiceAnswer, ScoreAnswer, ProbabilityAnswer]);\n\n/** @category models\n * @since 0.1.0\n */\nexport type Answer = ChoiceAnswer | ScoreAnswer | ProbabilityAnswer;\n\n/** @category schemas\n * @since 0.1.0\n */\nexport const Usage = Schema.Struct({\n  inputTokens: Schema.NullOr(Schema.Natural),\n  outputTokens: Schema.NullOr(Schema.Natural),\n});\n\n/** @category models\n * @since 0.1.0\n */\nexport type Usage = typeof Usage.Type;\n\n/**\n * Provider-namespaced evidence that has no shared interpretation. Consumers\n * decode a namespace with its provider's schema before using its contents.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const ProviderMetadata = Schema.Record(Schema.String, Schema.JsonObject);\n\n/** @category models\n * @since 0.1.0\n */\nexport type ProviderMetadata = typeof ProviderMetadata.Type;\n\n/**\n * The wire response shape. `DecisionModel.evaluate` additionally validates\n * answer IDs, question kinds, criteria, distributions, and score correlations.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const EvaluateResponse = Schema.Struct({\n  provider: Schema.NonEmptyString,\n  model: Schema.String,\n  answers: Schema.Record(Schema.String, Answer),\n  usage: Usage,\n  providerMetadata: Schema.optionalKey(ProviderMetadata),\n});\n\ntype ChoiceAnswerFor<Criteria> = Criteria extends unknown\n  ? Omit<typeof ChoiceAnswer.Type, \"choice\" | \"probabilities\"> & {\n      readonly choice: `${Extract<keyof Criteria, string | number>}`;\n      readonly probabilities: {\n        readonly [\n          K in keyof Criteria as K extends string | number ? `${K}` : never\n        ]: {} extends Pick<Criteria, K> ? number | undefined : number;\n      };\n    }\n  : never;\n\n/**\n * Infer a question's answer, preserving optional choice criteria in its probabilities.\n *\n * @category models\n * @since 0.1.0\n */\nexport type AnswerFor<Q extends Question> = Q extends ChoiceQuestion\n  ? ChoiceAnswerFor<Q[\"criteria\"]>\n  : Q extends ScoreQuestion\n    ? ScoreAnswer\n    : ProbabilityAnswer;\n\n/**\n * One answer for each required question. Optional properties and open string,\n * numeric, or template-pattern indexes require checking an entry for absence.\n *\n * @category models\n * @since 0.1.0\n */\nexport type Answers<Q extends Questions> = {\n  readonly [K in keyof Q as K extends string | number ? `${K}` : never]: {} extends Pick<Q, K>\n    ? AnswerFor<NonNullable<Q[K]>> | undefined\n    : AnswerFor<Q[K]>;\n};\n\n/** @category models\n * @since 0.1.0\n */\nexport type EvaluateResponse<Q extends Questions = Questions> = Omit<\n  typeof EvaluateResponse.Type,\n  \"answers\"\n> & { readonly answers: Answers<Q> };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAaA,MAAa,UAAU,OAAO,MAAM;CAAC,OAAO;CAAQ,OAAO;CAAY,OAAO,MAAM,OAAO,IAAI;AAAC,CAAC;;;;;;;AAajG,MAAa,iBAAiB,OAAO,OAAO;CAC1C,MAAM,OAAO,QAAQ,QAAQ;CAC7B,cAAc;CACd,UAAU,OAAO,OAAO,OAAO,QAAQ,OAAO,OAAO,OAAO,MAAM,CAAC,CAAC,CAAC,MACnE,OAAO,gBAAgB,CAAC,CAC1B;AACF,CAAC;;;;;;;AAaD,MAAa,gBAAgB,OAAO,OAAO;CACzC,MAAM,OAAO,QAAQ,OAAO;CAC5B,cAAc;CACd,UAAU,OAAO,MAAM,OAAO,MAAM,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AACnE,CAAC;;;;;;;AAaD,MAAa,sBAAsB,OAAO,OAAO;CAC/C,MAAM,OAAO,QAAQ,aAAa;CAClC,cAAc;CACd,UAAU,OAAO,YACf,OAAO,OAAO;EACZ,MAAM,OAAO,YAAY,OAAO,MAAM;EACtC,OAAO,OAAO,YAAY,OAAO,MAAM;CACzC,CAAC,CACH;AACF,CAAC;;;;AAUD,MAAa,WAAW,OAAO,MAAM;CAAC;CAAgB;CAAe;AAAmB,CAAC;;;;AAUzF,MAAa,YAAY,OAAO,OAAO,OAAO,QAAQ,QAAQ;;;;AAU9D,MAAa,kBAAkB,OAAO,OAAO;CAC3C,OAAO;CACP,WAAW;AACb,CAAC;;;;;;;AAoBD,MAAa,cAAc,OAAO,OAAO,MAAM,OAAO,UAAU;CAAE,SAAS;CAAG,SAAS;AAAE,CAAC,CAAC;;;;;;;;;AAU3F,MAAa,eAAe,OAAO,OAAO;CACxC,MAAM,OAAO,QAAQ,QAAQ;CAC7B,QAAQ,OAAO;CACf,eAAe,OAAO,OAAO,OAAO,QAAQ,WAAW;AACzD,CAAC;;;;;;;AA2BD,MAAa,cAAc,OAAO,OAAO;CACvC,MAAM,OAAO,QAAQ,OAAO;CAC5B,OAAO,OAAO,OAAO,MAAM,OAAO,uBAAuB,CAAC,CAAC;CAC3D,QAAQ,OAAO,OAAO,OAAO,QAAQ,OAAO,MAAM;CAClD,eAAe,OAAO,OAAO,OAAO,QAAQ,WAAW;AACzD,CAAC;;;;;;;AAoBD,MAAa,oBAAoB,OAAO,OAAO;CAC7C,MAAM,OAAO,QAAQ,aAAa;CAClC,aAAa;AACf,CAAC;;;;AAUD,MAAa,SAAS,OAAO,MAAM;CAAC;CAAc;CAAa;AAAiB,CAAC;;;;AAUjF,MAAa,QAAQ,OAAO,OAAO;CACjC,aAAa,OAAO,OAAO,OAAO,OAAO;CACzC,cAAc,OAAO,OAAO,OAAO,OAAO;AAC5C,CAAC;;;;;;;;AAcD,MAAa,mBAAmB,OAAO,OAAO,OAAO,QAAQ,OAAO,UAAU;;;;;;;;AAc9E,MAAa,mBAAmB,OAAO,OAAO;CAC5C,UAAU,OAAO;CACjB,OAAO,OAAO;CACd,SAAS,OAAO,OAAO,OAAO,QAAQ,MAAM;CAC5C,OAAO;CACP,kBAAkB,OAAO,YAAY,gBAAgB;AACvD,CAAC"}

package/dist/DecisionSet.d.mts

@@ -0,0 +1,27 @@
+import { Questions, t as DecisionSchema_d_exports } from "./DecisionSchema.mjs";
+import * as Schema from "effect/Schema";
+declare namespace DecisionSet_d_exports {
+  export { DecisionSet, make };
+}
+/** @category models
+ * @since 0.1.0
+ */
+export interface DecisionSet<Input extends Schema.Top, Questions$1 extends Questions> {
+  /** The encoded input becomes model-visible state: a string, JSON object, or JSON array. */
+  readonly input: Input;
+  /** Independent questions evaluated together against that state. */
+  readonly questions: Questions$1;
+}
+/**
+ * Describe a reusable assessment. Construction performs no encoding or model
+ * I/O. Input encoding and question validation occur inside model.evaluate.
+ * Treat nested instruction content as readonly; evaluation snapshots it before
+ * calling the provider. Dynamic question records are supported.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const make: <Input extends Schema.Top, const Questions$2 extends Questions>(options: DecisionSet<Input, Questions$2>) => DecisionSet<Input, Questions$2>;
+//#endregion
+export { DecisionSet_d_exports as t };
+//# sourceMappingURL=DecisionSet.d.mts.map

package/dist/DecisionSet.mjs

@@ -0,0 +1,20 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+//#region src/DecisionSet.ts
+var DecisionSet_exports = /* @__PURE__ */ __exportAll({ make: () => make });
+/**
+* Describe a reusable assessment. Construction performs no encoding or model
+* I/O. Input encoding and question validation occur inside model.evaluate.
+* Treat nested instruction content as readonly; evaluation snapshots it before
+* calling the provider. Dynamic question records are supported.
+*
+* @category constructors
+* @since 0.1.0
+*/
+const make = (options) => Object.freeze({
+	input: options.input,
+	questions: Object.freeze({ ...options.questions })
+});
+//#endregion
+export { make, DecisionSet_exports as t };
+
+//# sourceMappingURL=DecisionSet.mjs.map

package/dist/DecisionSet.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"DecisionSet.mjs","names":[],"sources":["../src/DecisionSet.ts"],"sourcesContent":["/**\n * Reusable question collections with a schema-defined input. The set owns no\n * provider, live resources, routing policy, or execution state.\n *\n * @since 0.1.0\n */\nimport type * as Schema from \"effect/Schema\";\n\nimport type * as DecisionSchema from \"./DecisionSchema.ts\";\n\n/** @category models\n * @since 0.1.0\n */\nexport interface DecisionSet<Input extends Schema.Top, Questions extends DecisionSchema.Questions> {\n  /** The encoded input becomes model-visible state: a string, JSON object, or JSON array. */\n  readonly input: Input;\n  /** Independent questions evaluated together against that state. */\n  readonly questions: Questions;\n}\n\n/**\n * Describe a reusable assessment. Construction performs no encoding or model\n * I/O. Input encoding and question validation occur inside model.evaluate.\n * Treat nested instruction content as readonly; evaluation snapshots it before\n * calling the provider. Dynamic question records are supported.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const make = <Input extends Schema.Top, const Questions extends DecisionSchema.Questions>(\n  options: DecisionSet<Input, Questions>,\n): DecisionSet<Input, Questions> =>\n  Object.freeze({\n    input: options.input,\n    questions: Object.freeze({ ...options.questions }),\n  });\n"],"mappings":";;;;;;;;;;;;AA6BA,MAAa,QACX,YAEA,OAAO,OAAO;CACZ,OAAO,QAAQ;CACf,WAAW,OAAO,OAAO,EAAE,GAAG,QAAQ,UAAU,CAAC;AACnD,CAAC"}

package/dist/index.d.mts

@@ -0,0 +1,5 @@
+import { t as DecisionSchema_d_exports } from "./DecisionSchema.mjs";
+import { t as DecisionSet_d_exports } from "./DecisionSet.mjs";
+import { t as DecisionModel_d_exports } from "./DecisionModel.mjs";
+import { t as DecisionQuery_d_exports } from "./DecisionQuery.mjs";
+export { DecisionModel_d_exports as DecisionModel, DecisionQuery_d_exports as DecisionQuery, DecisionSchema_d_exports as DecisionSchema, DecisionSet_d_exports as DecisionSet };

package/dist/index.mjs

@@ -0,0 +1,5 @@
+import { t as DecisionSchema_exports } from "./DecisionSchema.mjs";
+import { n as DecisionModel_exports } from "./DecisionModel-BQpmPcHb.mjs";
+import { t as DecisionQuery_exports } from "./DecisionQuery.mjs";
+import { t as DecisionSet_exports } from "./DecisionSet.mjs";
+export { DecisionModel_exports as DecisionModel, DecisionQuery_exports as DecisionQuery, DecisionSchema_exports as DecisionSchema, DecisionSet_exports as DecisionSet };

package/dist/rolldown-runtime-D7D4PA-g.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/package.json

@@ -0,0 +1 @@
+{"name":"@effect-agent/ai-decision","version":"0.1.0-beta.102","devDependencies":{"@effect/vitest":"4.0.0-rc.115","effect":"4.0.0-rc.115","typescript":"7.0.2","vite-plus":"0.3.2"},"peerDependencies":{"effect":"^4.0.0-rc.115"},"exports":{".":{"types":"./dist/index.d.mts","default":"./dist/index.mjs"},"./decision-model":{"types":"./dist/DecisionModel.d.mts","default":"./dist/DecisionModel.mjs"},"./decision-query":{"types":"./dist/DecisionQuery.d.mts","default":"./dist/DecisionQuery.mjs"},"./decision-schema":{"types":"./dist/DecisionSchema.d.mts","default":"./dist/DecisionSchema.mjs"},"./decision-set":{"types":"./dist/DecisionSet.d.mts","default":"./dist/DecisionSet.mjs"}},"description":"Provider-neutral choice, score, and probability evaluations with Effect.","license":"MIT","repository":{"type":"git","url":"git+https://github.com/danieljvdm/effect-agent.git","directory":"packages/ai-decision"},"files":["dist","src"],"type":"module","sideEffects":[],"publishConfig":{"access":"public"},"scripts":{"build":"vp pack","check":"tsc --noEmit -p tsconfig.json","test":"vp test"}}

package/src/DecisionModel.ts

@@ -0,0 +1,144 @@
+import { Context, Effect, Schema, type SchemaAST, type Scope } from "effect";
+import { AiError } from "effect/unstable/ai";
+
+import * as DecisionSchema from "./DecisionSchema.ts";
+import type * as DecisionSet from "./DecisionSet.ts";
+import { responseFor } from "./internal/schema.ts";
+
+/** Typed semantic evaluations; the caller owns thresholds, transitions, and side effects. */
+export interface Service {
+  readonly evaluate: {
+    <const Q extends DecisionSchema.Questions>(
+      request: DecisionSchema.EvaluateRequest<Q>,
+    ): Effect.Effect<DecisionSchema.EvaluateResponse<Q>, AiError.AiError>;
+    /** Encode typed input as state, preserving the schema's encoding requirements. */
+    <Input extends Schema.Top, const Q extends DecisionSchema.Questions>(
+      set: DecisionSet.DecisionSet<Input, Q>,
+      input: NoInfer<Input["Type"]>,
+    ): Effect.Effect<
+      DecisionSchema.EvaluateResponse<Q>,
+      AiError.AiError,
+      Input["EncodingServices"]
+    >;
+  };
+}
+
+/** A decision provider, independent of the agent's generative LanguageModel. */
+export class DecisionModel extends Context.Service<DecisionModel, 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.
+ */
+export const make = Effect.fnUntraced(function* <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: DecisionSchema.EvaluateRequest,
+  ) => Effect.Effect<unknown, AiError.AiError, R>;
+}): Effect.fn.Return<Service, never, Exclude<R, Scope.Scope>> {
+  const services = yield* Effect.context<Exclude<R, Scope.Scope>>();
+
+  const evaluateRequest = Effect.fn("DecisionModel.evaluate")(function* <
+    const Q extends DecisionSchema.Questions,
+  >(
+    request: DecisionSchema.EvaluateRequest<Q>,
+  ): Effect.fn.Return<DecisionSchema.EvaluateResponse<Q>, AiError.AiError> {
+    // Encode and decode once to snapshot caller-owned state and criteria before provider I/O.
+    const encoded = yield* Schema.encodeEffect(
+      Schema.fromJsonString(DecisionSchema.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(DecisionSchema.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* <
+    Input extends Schema.Top,
+    const Q extends DecisionSchema.Questions,
+  >(set: DecisionSet.DecisionSet<Input, Q>, input: Input["Type"]) {
+    const state = yield* Schema.encodeEffect(set.input)(input).pipe(
+      Effect.flatMap(Schema.decodeUnknownEffect(DecisionSchema.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<const Q extends DecisionSchema.Questions>(
+    request: DecisionSchema.EvaluateRequest<Q>,
+  ): Effect.Effect<DecisionSchema.EvaluateResponse<Q>, AiError.AiError>;
+  function evaluate<Input extends Schema.Top, const Q extends DecisionSchema.Questions>(
+    set: DecisionSet.DecisionSet<Input, Q>,
+    input: NoInfer<Input["Type"]>,
+  ): Effect.Effect<DecisionSchema.EvaluateResponse<Q>, AiError.AiError, Input["EncodingServices"]>;
+  function evaluate<Input extends Schema.Top, const Q extends DecisionSchema.Questions>(
+    ...args:
+      | [DecisionSchema.EvaluateRequest<Q>]
+      | [DecisionSet.DecisionSet<Input, Q>, Input["Type"]]
+  ): Effect.Effect<DecisionSchema.EvaluateResponse<Q>, AiError.AiError, Input["EncodingServices"]> {
+    return args.length === 1 ? evaluateRequest(args[0]) : evaluateSet(args[0], args[1]);
+  }
+
+  return DecisionModel.of({ evaluate });
+});

package/src/DecisionQuery.ts

@@ -0,0 +1,56 @@
+/**
+ * Pure constructors for questions evaluated by a DecisionModel. Definitions
+ * are validated when evaluated; constructing a query performs no model I/O.
+ *
+ * @since 0.1.0
+ */
+import type * as DecisionSchema from "./DecisionSchema.ts";
+
+/**
+ * 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 const choice = <const Options extends DecisionSchema.ChoiceQuestion["criteria"]>(options: {
+  readonly instructions: DecisionSchema.Content;
+  readonly options: Options;
+}) =>
+  Object.freeze({
+    type: "choice" as const,
+    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
+ */
+export const score = (options: {
+  readonly instructions: DecisionSchema.Content;
+  readonly levels: ReadonlyArray<string>;
+}) =>
+  Object.freeze({
+    type: "score" as const,
+    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
+ */
+export const probability = (options: Omit<DecisionSchema.ProbabilityQuestion, "type">) =>
+  Object.freeze({
+    type: "probability" as const,
+    instructions: options.instructions,
+    ...(options.criteria === undefined ? {} : { criteria: Object.freeze({ ...options.criteria }) }),
+  });