@effect-agent/ai-typesafe 0.1.0-beta.101 → 0.1.0-beta.103

package/dist/TypeSafeSchema-Dn4_Tptf.d.mts

@@ -0,0 +1,305 @@
+import * as Schema from "effect/Schema";
+declare namespace TypeSafeSchema_d_exports {
+  export { Answer, AnswerFor, Answers, ChoiceAnswer, ChoiceQuestion, Content, EvaluateRequest, EvaluateResponse, NoulAnswer, NoulQuestion, Probability, Question, Questions, ScoreAnswer, ScoreQuestion, Usage };
+}
+/**
+ * Text or JSON objects and arrays used as state and question instructions.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+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
+ */
+type Content = typeof Content.Type;
+/**
+ * A choice between named options. A null rubric uses the option name alone.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+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
+ */
+type ChoiceQuestion = typeof ChoiceQuestion.Type;
+/**
+ * A rating along at least two ordered, zero-indexed level descriptions.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+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
+ */
+type ScoreQuestion = typeof ScoreQuestion.Type;
+/**
+ * A yes/no judgment, with optional descriptions of either outcome.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+declare const NoulQuestion: Schema.Struct<{
+  readonly type: Schema.Literal<"noul">;
+  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
+ */
+type NoulQuestion = typeof NoulQuestion.Type;
+/** @category schemas
+ * @since 0.1.0
+ */
+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<"noul">;
+  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
+ */
+type Question = typeof Question.Type;
+/** @category schemas
+ * @since 0.1.0
+ */
+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<"noul">;
+  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
+ */
+type Questions = typeof Questions.Type;
+/** @category schemas
+ * @since 0.1.0
+ */
+declare const EvaluateRequest: Schema.Struct<{
+  readonly model: Schema.String;
+  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<"noul">;
+    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
+ */
+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
+ */
+declare const Probability: Schema.Finite;
+/**
+ * A selected option and its full distribution. Confidence summarizes the
+ * distribution; it does not guarantee correctness.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+declare const ChoiceAnswer: Schema.Struct<{
+  readonly type: Schema.Literal<"choice">;
+  readonly choice: Schema.String;
+  readonly probabilities: Schema.$Record<Schema.String, Schema.Finite>;
+  readonly confidence: 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
+ */
+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
+ */
+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>;
+  readonly confidence: Schema.Finite;
+}>;
+/**
+ * Score levels are keyed at runtime; an arbitrary legend or probability lookup
+ * may be absent.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+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. Noul has no separate confidence field.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+declare const NoulAnswer: Schema.Struct<{
+  readonly type: Schema.Literal<"noul">;
+  readonly noul: Schema.Finite;
+}>;
+/** @category models
+ * @since 0.1.0
+ */
+type NoulAnswer = typeof NoulAnswer.Type;
+/** @category schemas
+ * @since 0.1.0
+ */
+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>;
+  readonly confidence: 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>;
+  readonly confidence: Schema.Finite;
+}>, Schema.Struct<{
+  readonly type: Schema.Literal<"noul">;
+  readonly noul: Schema.Finite;
+}>]>;
+/** @category models
+ * @since 0.1.0
+ */
+type Answer = ChoiceAnswer | ScoreAnswer | NoulAnswer;
+/** @category schemas
+ * @since 0.1.0
+ */
+declare const Usage: Schema.Struct<{
+  readonly input_tokens: Schema.Natural;
+  readonly output_tokens: Schema.Natural;
+}>;
+/** @category models
+ * @since 0.1.0
+ */
+type Usage = typeof Usage.Type;
+/**
+ * The wire response shape. `TypeSafeClient.evaluate` additionally validates
+ * answer IDs, question kinds, criteria, distributions, and score correlations.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+declare const EvaluateResponse: Schema.Struct<{
+  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>;
+    readonly confidence: 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>;
+    readonly confidence: Schema.Finite;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"noul">;
+    readonly noul: Schema.Finite;
+  }>]>>;
+  readonly usage: Schema.Struct<{
+    readonly input_tokens: Schema.Natural;
+    readonly output_tokens: Schema.Natural;
+  }>;
+}>;
+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
+ */
+type AnswerFor<Q extends Question> = Q extends ChoiceQuestion ? ChoiceAnswerFor<Q["criteria"]> : Q extends ScoreQuestion ? ScoreAnswer : NoulAnswer;
+/**
+ * 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
+ */
+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
+ */
+type EvaluateResponse<Q extends Questions = Questions> = Omit<typeof EvaluateResponse.Type, "answers"> & {
+  readonly answers: Answers<Q>;
+};
+//#endregion
+export { Usage as _, ChoiceQuestion as a, EvaluateResponse as c, Probability as d, Question as f, TypeSafeSchema_d_exports as g, ScoreQuestion as h, ChoiceAnswer as i, NoulAnswer as l, ScoreAnswer as m, AnswerFor as n, Content as o, Questions as p, Answers as r, EvaluateRequest as s, Answer as t, NoulQuestion as u };
+//# sourceMappingURL=TypeSafeSchema-Dn4_Tptf.d.mts.map

package/dist/TypeSafeSchema.d.mts

@@ -1,305 +1,2 @@
-import * as Schema from "effect/Schema";
-declare namespace TypeSafeSchema_d_exports {
-  export { Answer, AnswerFor, Answers, ChoiceAnswer, ChoiceQuestion, Content, EvaluateRequest, EvaluateResponse, NoulAnswer, NoulQuestion, Probability, 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 NoulQuestion: Schema.Struct<{
-  readonly type: Schema.Literal<"noul">;
-  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 NoulQuestion = typeof NoulQuestion.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<"noul">;
-  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<"noul">;
-  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 model: Schema.String;
-  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<"noul">;
-    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. Confidence summarizes the
- * distribution; it does not guarantee correctness.
- *
- * @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>;
-  readonly confidence: 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>;
-  readonly confidence: 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. Noul has no separate confidence field.
- *
- * @category schemas
- * @since 0.1.0
- */
-export declare const NoulAnswer: Schema.Struct<{
-  readonly type: Schema.Literal<"noul">;
-  readonly noul: Schema.Finite;
-}>;
-/** @category models
- * @since 0.1.0
- */
-export type NoulAnswer = typeof NoulAnswer.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>;
-  readonly confidence: 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>;
-  readonly confidence: Schema.Finite;
-}>, Schema.Struct<{
-  readonly type: Schema.Literal<"noul">;
-  readonly noul: Schema.Finite;
-}>]>;
-/** @category models
- * @since 0.1.0
- */
-export type Answer = ChoiceAnswer | ScoreAnswer | NoulAnswer;
-/** @category schemas
- * @since 0.1.0
- */
-export declare const Usage: Schema.Struct<{
-  readonly input_tokens: Schema.Natural;
-  readonly output_tokens: Schema.Natural;
-}>;
-/** @category models
- * @since 0.1.0
- */
-export type Usage = typeof Usage.Type;
-/**
- * The wire response shape. `TypeSafeClient.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 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>;
-    readonly confidence: 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>;
-    readonly confidence: Schema.Finite;
-  }>, Schema.Struct<{
-    readonly type: Schema.Literal<"noul">;
-    readonly noul: Schema.Finite;
-  }>]>>;
-  readonly usage: Schema.Struct<{
-    readonly input_tokens: Schema.Natural;
-    readonly output_tokens: Schema.Natural;
-  }>;
-}>;
-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 : NoulAnswer;
-/**
- * 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 { TypeSafeSchema_d_exports as t };
-//# sourceMappingURL=TypeSafeSchema.d.mts.map
+import { _ as Usage, a as ChoiceQuestion, c as EvaluateResponse, d as Probability, f as Question, h as ScoreQuestion, i as ChoiceAnswer, l as NoulAnswer, m as ScoreAnswer, n as AnswerFor, o as Content, p as Questions, r as Answers, s as EvaluateRequest, t as Answer, u as NoulQuestion } from "./TypeSafeSchema-Dn4_Tptf.mjs";
+export { Answer, AnswerFor, Answers, ChoiceAnswer, ChoiceQuestion, Content, EvaluateRequest, EvaluateResponse, NoulAnswer, NoulQuestion, Probability, Question, Questions, ScoreAnswer, ScoreQuestion, Usage };

package/dist/TypeSafeSchema.mjs

@@ -1,5 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import * as Schema from "effect/Schema";
+import { DecisionSchema } from "@effect-agent/ai-decision";
 //#region src/TypeSafeSchema.ts
 /**
 * Request and response schemas for TypeSafe's System One HTTP API.
@@ -28,33 +29,21 @@ var TypeSafeSchema_exports = /* @__PURE__ */ __exportAll({
 * @category schemas
 * @since 0.1.0
 */
-const Content = Schema.Union([
-	Schema.String,
-	Schema.JsonObject,
-	Schema.Array(Schema.Json)
-]);
+const Content = DecisionSchema.Content;
 /**
 * 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))
-});
+const ChoiceQuestion = DecisionSchema.ChoiceQuestion;
 /**
 * 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))
-});
+const ScoreQuestion = DecisionSchema.ScoreQuestion;
 /**
 * A yes/no judgment, with optional descriptions of either outcome.
 *
@@ -95,10 +84,7 @@ const EvaluateRequest = Schema.Struct({
 * @category schemas
 * @since 0.1.0
 */
-const Probability = Schema.Finite.check(Schema.isBetween({
-	minimum: 0,
-	maximum: 1
-}));
+const Probability = DecisionSchema.Probability;
 /**
 * A selected option and its full distribution. Confidence summarizes the
 * distribution; it does not guarantee correctness.
@@ -107,9 +93,7 @@ const Probability = Schema.Finite.check(Schema.isBetween({
 * @since 0.1.0
 */
 const ChoiceAnswer = Schema.Struct({
-	type: Schema.Literal("choice"),
-	choice: Schema.String,
-	probabilities: Schema.Record(Schema.String, Probability),
+	...DecisionSchema.ChoiceAnswer.fields,
 	confidence: Probability
 });
 /**
@@ -119,10 +103,7 @@ const ChoiceAnswer = Schema.Struct({
 * @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),
+	...DecisionSchema.ScoreAnswer.fields,
 	confidence: Probability
 });
 /**