@effect-agent/ai-typesafe 0.1.0-beta.100

package/dist/TypeSafeSchema.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
+ */
+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

package/dist/TypeSafeSchema.mjs

@@ -0,0 +1,168 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import * as Schema from "effect/Schema";
+//#region src/TypeSafeSchema.ts
+/**
+* Request and response schemas for TypeSafe's System One HTTP API.
+*
+* @since 0.1.0
+*/
+var TypeSafeSchema_exports = /* @__PURE__ */ __exportAll({
+	Answer: () => Answer,
+	ChoiceAnswer: () => ChoiceAnswer,
+	ChoiceQuestion: () => ChoiceQuestion,
+	Content: () => Content,
+	EvaluateRequest: () => EvaluateRequest,
+	EvaluateResponse: () => EvaluateResponse,
+	NoulAnswer: () => NoulAnswer,
+	NoulQuestion: () => NoulQuestion,
+	Probability: () => Probability,
+	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 NoulQuestion = Schema.Struct({
+	type: Schema.Literal("noul"),
+	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,
+	NoulQuestion
+]);
+/** @category schemas
+* @since 0.1.0
+*/
+const Questions = Schema.Record(Schema.String, Question);
+/** @category schemas
+* @since 0.1.0
+*/
+const EvaluateRequest = Schema.Struct({
+	model: Schema.String,
+	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. Confidence summarizes the
+* distribution; it does not guarantee correctness.
+*
+* @category schemas
+* @since 0.1.0
+*/
+const ChoiceAnswer = Schema.Struct({
+	type: Schema.Literal("choice"),
+	choice: Schema.String,
+	probabilities: Schema.Record(Schema.String, Probability),
+	confidence: 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),
+	confidence: Probability
+});
+/**
+* The probability of yes. Noul has no separate confidence field.
+*
+* @category schemas
+* @since 0.1.0
+*/
+const NoulAnswer = Schema.Struct({
+	type: Schema.Literal("noul"),
+	noul: Probability
+});
+/** @category schemas
+* @since 0.1.0
+*/
+const Answer = Schema.Union([
+	ChoiceAnswer,
+	ScoreAnswer,
+	NoulAnswer
+]);
+/** @category schemas
+* @since 0.1.0
+*/
+const Usage = Schema.Struct({
+	input_tokens: Schema.Natural,
+	output_tokens: Schema.Natural
+});
+/**
+* The wire response shape. `TypeSafeClient.evaluate` additionally validates
+* answer IDs, question kinds, criteria, distributions, and score correlations.
+*
+* @category schemas
+* @since 0.1.0
+*/
+const EvaluateResponse = Schema.Struct({
+	model: Schema.String,
+	answers: Schema.Record(Schema.String, Answer),
+	usage: Usage
+});
+//#endregion
+export { Answer, ChoiceAnswer, ChoiceQuestion, Content, EvaluateRequest, EvaluateResponse, NoulAnswer, NoulQuestion, Probability, Question, Questions, ScoreAnswer, ScoreQuestion, Usage, TypeSafeSchema_exports as t };
+
+//# sourceMappingURL=TypeSafeSchema.mjs.map

package/dist/TypeSafeSchema.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeSafeSchema.mjs","names":[],"sources":["../src/TypeSafeSchema.ts"],"sourcesContent":["/**\n * Request and response schemas for TypeSafe's System One HTTP API.\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 NoulQuestion = Schema.Struct({\n  type: Schema.Literal(\"noul\"),\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 NoulQuestion = typeof NoulQuestion.Type;\n\n/** @category schemas\n * @since 0.1.0\n */\nexport const Question = Schema.Union([ChoiceQuestion, ScoreQuestion, NoulQuestion]);\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  model: Schema.String,\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. Confidence summarizes the\n * distribution; it does not guarantee correctness.\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  confidence: 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  confidence: 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. Noul has no separate confidence field.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const NoulAnswer = Schema.Struct({ type: Schema.Literal(\"noul\"), noul: Probability });\n\n/** @category models\n * @since 0.1.0\n */\nexport type NoulAnswer = typeof NoulAnswer.Type;\n\n/** @category schemas\n * @since 0.1.0\n */\nexport const Answer = Schema.Union([ChoiceAnswer, ScoreAnswer, NoulAnswer]);\n\n/** @category models\n * @since 0.1.0\n */\nexport type Answer = ChoiceAnswer | ScoreAnswer | NoulAnswer;\n\n/** @category schemas\n * @since 0.1.0\n */\nexport const Usage = Schema.Struct({ input_tokens: Schema.Natural, output_tokens: Schema.Natural });\n\n/** @category models\n * @since 0.1.0\n */\nexport type Usage = typeof Usage.Type;\n\n/**\n * The wire response shape. `TypeSafeClient.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  model: Schema.String,\n  answers: Schema.Record(Schema.String, Answer),\n  usage: Usage,\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    : NoulAnswer;\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,eAAe,OAAO,OAAO;CACxC,MAAM,OAAO,QAAQ,MAAM;CAC3B,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;AAAY,CAAC;;;;AAUlF,MAAa,YAAY,OAAO,OAAO,OAAO,QAAQ,QAAQ;;;;AAU9D,MAAa,kBAAkB,OAAO,OAAO;CAC3C,OAAO,OAAO;CACd,OAAO;CACP,WAAW;AACb,CAAC;;;;;;;AAoBD,MAAa,cAAc,OAAO,OAAO,MAAM,OAAO,UAAU;CAAE,SAAS;CAAG,SAAS;AAAE,CAAC,CAAC;;;;;;;;AAS3F,MAAa,eAAe,OAAO,OAAO;CACxC,MAAM,OAAO,QAAQ,QAAQ;CAC7B,QAAQ,OAAO;CACf,eAAe,OAAO,OAAO,OAAO,QAAQ,WAAW;CACvD,YAAY;AACd,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;CACvD,YAAY;AACd,CAAC;;;;;;;AAoBD,MAAa,aAAa,OAAO,OAAO;CAAE,MAAM,OAAO,QAAQ,MAAM;CAAG,MAAM;AAAY,CAAC;;;;AAU3F,MAAa,SAAS,OAAO,MAAM;CAAC;CAAc;CAAa;AAAU,CAAC;;;;AAU1E,MAAa,QAAQ,OAAO,OAAO;CAAE,cAAc,OAAO;CAAS,eAAe,OAAO;AAAQ,CAAC;;;;;;;;AAclG,MAAa,mBAAmB,OAAO,OAAO;CAC5C,OAAO,OAAO;CACd,SAAS,OAAO,OAAO,OAAO,QAAQ,MAAM;CAC5C,OAAO;AACT,CAAC"}

package/dist/index.d.mts

@@ -0,0 +1,3 @@
+import { t as TypeSafeSchema_d_exports } from "./TypeSafeSchema.mjs";
+import { t as TypeSafeClient_d_exports } from "./TypeSafeClient.mjs";
+export { TypeSafeClient_d_exports as TypeSafeClient, TypeSafeSchema_d_exports as TypeSafeSchema };

package/dist/index.mjs

@@ -0,0 +1,3 @@
+import { n as TypeSafeClient_exports } from "./TypeSafeClient-OS5hTVMz.mjs";
+import { t as TypeSafeSchema_exports } from "./TypeSafeSchema.mjs";
+export { TypeSafeClient_exports as TypeSafeClient, TypeSafeSchema_exports as TypeSafeSchema };

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-typesafe","version":"0.1.0-beta.100","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"},"./type-safe-client":{"types":"./dist/TypeSafeClient.d.mts","default":"./dist/TypeSafeClient.mjs"},"./type-safe-schema":{"types":"./dist/TypeSafeSchema.d.mts","default":"./dist/TypeSafeSchema.mjs"}},"description":"TypeSafe AI evaluation with Effect HttpClient and request-derived answer types.","license":"MIT","repository":{"type":"git","url":"git+https://github.com/danieljvdm/effect-agent.git","directory":"packages/ai-typesafe"},"files":["dist","src"],"type":"module","sideEffects":[],"publishConfig":{"access":"public"},"scripts":{"build":"vp pack","check":"tsc --noEmit -p tsconfig.json","test":"vp test"}}

package/src/TypeSafeClient.ts

@@ -0,0 +1,145 @@
+/**
+ * An Effect HttpClient integration for TypeSafe's System One evaluations.
+ *
+ * @since 0.1.0
+ */
+import * as Config from "effect/Config";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import { flow, identity } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import * as Schema from "effect/Schema";
+import * as AiError from "effect/unstable/ai/AiError";
+import * as Headers from "effect/unstable/http/Headers";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
+import * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
+
+import * as Errors from "./internal/errors.ts";
+import { responseFor } from "./internal/schema.ts";
+import * as TypeSafeSchema from "./TypeSafeSchema.ts";
+
+/** @category services
+ * @since 0.1.0
+ */
+export interface Service {
+  readonly client: HttpClient.HttpClient;
+
+  /**
+   * Evaluate mixed questions against one state. Answers are validated against
+   * the submitted IDs, types, and criteria before receiving their inferred type.
+   * There are no automatic retries or timeouts; compose those with Effect.
+   */
+  readonly evaluate: <const Q extends TypeSafeSchema.Questions>(
+    options: TypeSafeSchema.EvaluateRequest<Q>,
+  ) => Effect.Effect<TypeSafeSchema.EvaluateResponse<Q>, AiError.AiError>;
+}
+
+/** @category services
+ * @since 0.1.0
+ */
+export class TypeSafeClient extends Context.Service<TypeSafeClient, Service>()(
+  "@effect-agent/ai-typesafe/TypeSafeClient",
+) {}
+
+/** @category options
+ * @since 0.1.0
+ */
+export interface Options {
+  readonly apiKey: Redacted.Redacted<string>;
+  /** Base URL, including the API version. Defaults to https://api.typesafe.ai/v1. */
+  readonly apiUrl?: string | undefined;
+  /** Applied after authentication and status filtering, for explicit HTTP policies. */
+  readonly transformClient?: ((client: HttpClient.HttpClient) => HttpClient.HttpClient) | undefined;
+}
+
+const encodeRequest = Schema.encodeEffect(Schema.fromJsonString(TypeSafeSchema.EvaluateRequest));
+
+/**
+ * Construct the client using a supplied, platform-neutral HttpClient.
+ * Acquiring the service does not send a request.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export const make = Effect.fnUntraced(function* (
+  options: Options,
+): Effect.fn.Return<Service, never, HttpClient.HttpClient> {
+  const apiKey = Redacted.value(options.apiKey);
+
+  const redact = (text: string) =>
+    apiKey.length === 0 ? text : text.replaceAll(apiKey, "<redacted>");
+
+  const client = (yield* HttpClient.HttpClient).pipe(
+    HttpClient.mapRequest(
+      flow(
+        HttpClientRequest.prependUrl(options.apiUrl ?? "https://api.typesafe.ai/v1"),
+        HttpClientRequest.bearerToken(options.apiKey),
+        HttpClientRequest.acceptJson,
+      ),
+    ),
+    HttpClient.filterStatusOk,
+    options.transformClient ?? identity,
+  );
+
+  const evaluate = Effect.fnUntraced(function* <const Q extends TypeSafeSchema.Questions>(
+    options: TypeSafeSchema.EvaluateRequest<Q>,
+  ): Effect.fn.Return<TypeSafeSchema.EvaluateResponse<Q>, AiError.AiError> {
+    const body = yield* encodeRequest(options).pipe(
+      Effect.mapError((error) =>
+        Errors.make(new AiError.InvalidRequestError({ description: redact(error.message) })),
+      ),
+    );
+
+    const schema = responseFor(options.questions);
+
+    return yield* client
+      .execute(
+        HttpClientRequest.post("/systemone").pipe(
+          HttpClientRequest.bodyText(body, "application/json"),
+        ),
+      )
+      .pipe(
+        Effect.flatMap(HttpClientResponse.schemaBodyJson(schema, { onExcessProperty: "error" })),
+        Effect.catchTags({
+          HttpClientError: (error) => Errors.mapHttpClientError(error, redact),
+          SchemaError: (error) => Effect.fail(Errors.mapSchemaError(error, redact)),
+        }),
+        Effect.updateService(Headers.CurrentRedactedNames, (names) => [...names, "authorization"]),
+      );
+  });
+
+  return TypeSafeClient.of({ client, evaluate });
+});
+
+/** @category layers
+ * @since 0.1.0
+ */
+export const layer = (
+  options: Options,
+): Layer.Layer<TypeSafeClient, never, HttpClient.HttpClient> =>
+  Layer.effect(TypeSafeClient, make(options));
+
+/**
+ * Configure the client with Effect Config. The API key defaults to
+ * `Config.Redacted("TYPESAFE_API_KEY")`.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export const layerConfig = (options?: {
+  readonly apiKey?: Config.Config<Redacted.Redacted<string>> | undefined;
+  readonly apiUrl?: Config.Config<string> | undefined;
+  readonly transformClient?: Options["transformClient"];
+}): Layer.Layer<TypeSafeClient, Config.ConfigError, HttpClient.HttpClient> =>
+  Layer.effect(
+    TypeSafeClient,
+    Effect.gen(function* () {
+      return yield* make({
+        apiKey: yield* options?.apiKey ?? Config.Redacted("TYPESAFE_API_KEY"),
+        apiUrl: options?.apiUrl === undefined ? undefined : yield* options.apiUrl,
+        transformClient: options?.transformClient,
+      });
+    }),
+  );