@effect-uai/typesafe-ai 0.16.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Betalyra Sociedade Unipessoal Lda.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,130 @@
+# @effect-uai/typesafe-ai
+
+TypeSafe AI provider for [`@effect-uai/core`](https://github.com/betalyra/effect-uai/tree/main/packages/core).
+Serves the `DecisionModel` capability with Jev, a System One model that
+answers typed questions about an input with probabilities instead of
+generating text.
+
+> Experimental. This class of model is new and the shape may change.
+
+## Install
+
+```sh
+pnpm add @effect-uai/core @effect-uai/typesafe-ai effect
+```
+
+## Wire it up
+
+```ts
+import { Config, Effect, Layer } from "effect"
+import { FetchHttpClient } from "effect/unstable/http"
+import { layer as jevLayer } from "@effect-uai/typesafe-ai/Jev"
+
+const provider = Layer.unwrap(
+  Effect.gen(function* () {
+    const apiKey = yield* Config.redacted("TYPESAFE_AI_API_KEY")
+    return jevLayer({ apiKey })
+  }),
+)
+
+const mainLayer = provider.pipe(Layer.provide(FetchHttpClient.layer))
+```
+
+One layer, two tags: `Jev` for its own reported `confidence`, `DecisionModel`
+for provider-portable code.
+
+## Decide
+
+```ts
+import { Schema } from "effect"
+import * as Decision from "@effect-uai/core/Decision"
+import { decide } from "@effect-uai/core/DecisionModel"
+
+const triage = Decision.make({
+  inputSchema: Schema.Struct({ message: Schema.String }),
+  decisions: {
+    department: Decision.classify({
+      instructions: "Which team should handle this?",
+      criteria: {
+        billing: "Payments, invoicing, refunds",
+        technical: "Bugs, outages, integrations",
+      },
+    }),
+    severity: Decision.rate({
+      instructions: "How severe is the reported issue?",
+      criteria: ["Cosmetic", "Degraded", "Blocking"],
+    }),
+    urgent: Decision.probability({ instructions: "Does this convey urgency?" }),
+  },
+})
+
+const program = Effect.gen(function* () {
+  const { answers } = yield* decide(triage, {
+    model: "jev-latest",
+    input: { message: "Payouts have been failing for 3 days." },
+  })
+
+  answers.department.labels.billing // number
+  answers.urgent.probability // number
+  answers.severity.legend[Decision.topLevel(answers.severity)] // "Degraded"
+
+  const leader = Decision.ranked(answers.department)[0]
+  return leader === undefined || leader.probability < 0.5 ? "escalate" : leader.label
+})
+```
+
+Every decision in a definition is answered in one call, and the encoded input
+is billed once, so batch them rather than calling per question.
+
+## Models
+
+`jev-latest` (default), `jev-preview`, `jev-1.13.0`. 64k tokens per request,
+of which roughly 32k for the encoded input plus the longest single decision.
+Text only.
+
+## What the input schema is for
+
+`inputSchema` encodes the input on the way out. A schema that omits a field
+keeps it from the model, which is the supported way to hold irrelevant or
+sensitive context out of a request. The vendor documents large irrelevant
+input as a distractor, so projecting deliberately is worth doing.
+
+## About the scores
+
+Probabilities sum to 1 within floating-point error and are comparable within
+one answer. Jev's own `confidence` is available on the `Jev` tag; it is not on
+the common answer because its formula is undocumented and it is absent on
+`probability` decisions. `Decision.confidence` and `Decision.margin` are
+computed from the distribution, documented, and defined for every kind. Gate
+on the top probability and `margin`, not on `confidence`: normalised entropy
+shrinks as the label count grows, so a threshold tuned on two labels quietly
+demands far more mass on four.
+
+Known weak spots per the vendor's own jaggedness notes: counting and
+arithmetic, date ordering, multi-hop reasoning, and rubric scores are weakly
+calibrated so `expectedLevel` should not be read back as a magnitude. Input is
+not treated as hostile, so an injected instruction in the input can steer an
+answer.
+
+## Errors
+
+| Status    | `AiError`                          |
+| --------- | ---------------------------------- |
+| 401       | `AuthFailed{subtype:"auth"}`       |
+| 402       | `AuthFailed{subtype:"billing"}`    |
+| 403       | `AuthFailed{subtype:"permission"}` |
+| 408 / 504 | `Timeout`                          |
+| 413       | `ContextLengthExceeded`            |
+| 422       | `InvalidRequest`                   |
+| 429       | `RateLimited`                      |
+| 5xx       | `Unavailable`                      |
+
+An input the schema cannot encode is `InvalidRequest` with `param: "input"`.
+An answer whose shape does not match the decision that asked for it is
+`GenerationFailed`.
+
+## See also
+
+- [Decision models](https://effect-uai.betalyra.com/decisions/)
+- [TypeSafe AI usage page](https://effect-uai.betalyra.com/decisions/providers/typesafe-ai/)
+- [`@effect-uai/core/Decision`](https://github.com/betalyra/effect-uai/tree/main/packages/core/src/decision-model)

package/dist/Jev.d.mts

@@ -0,0 +1,60 @@
+import { JevModel } from "./models.mjs";
+import { Context, Effect, Layer, Redacted } from "effect";
+import { HttpClient } from "effect/unstable/http";
+import * as AiError from "@effect-uai/core/AiError";
+import { CommonDecideRequest, DecideResponse, DecisionModel } from "@effect-uai/core/DecisionModel";
+import * as Decision from "@effect-uai/core/Decision";
+declare namespace Jev_d_exports {
+  export { Config, Jev, JevAnswerFor, JevAnswers, JevDecideRequest, JevDecideResponse, JevService, layer, make };
+}
+/**
+ * Jev reports its own `confidence` alongside the distribution, on Classify
+ * and Rate but not on Probability. The formula is undocumented, so it is not
+ * on the Common answer; `Decision.confidence` is ours and is defined for
+ * every kind.
+ */
+type JevAnswerFor<D> = Decision.AnswerFor<D> & ReportedConfidence<D>;
+/**
+ * Intersected rather than branched per kind, so `JevAnswers` stays provably
+ * assignable to `Answers`: TypeScript cannot see one deferred conditional as
+ * a subtype of another, but an intersection is always assignable to its
+ * members.
+ */
+type ReportedConfidence<D> = D extends {
+  readonly _tag: "Probability";
+} ? unknown : {
+  readonly confidence: number;
+};
+type JevAnswers<D extends Decision.Decisions> = { readonly [K in keyof D]: JevAnswerFor<D[K]>; };
+type JevDecideResponse<D extends Decision.Decisions> = Omit<DecideResponse<D>, "answers"> & {
+  readonly answers: JevAnswers<D>;
+};
+/** Narrows `model` to Jev's roster. */
+type JevDecideRequest<A> = Omit<CommonDecideRequest<A>, "model"> & {
+  readonly model: JevModel;
+};
+type JevService = {
+  readonly decide: <A, D extends Decision.Decisions>(definition: Decision.Definition<A, D>, request: JevDecideRequest<A>) => Effect.Effect<JevDecideResponse<D>, AiError.AiError>;
+};
+declare const Jev_base: Context.ServiceClass<Jev, "@betalyra/effect-uai/providers/typesafe-ai/Jev", JevService>;
+/**
+ * Provider-typed service tag. Yield this for Jev's own `confidence`; yield the
+ * generic `DecisionModel` tag for provider-portable code. Both are registered
+ * by {@link layer}.
+ */
+declare class Jev extends Jev_base {}
+type Config = {
+  readonly apiKey: Redacted.Redacted;
+  readonly baseUrl?: string;
+};
+/** Build a `JevService` value. For Layer-based setup, prefer {@link layer}. */
+declare const make: (config: Config) => Effect.Effect<JevService, never, HttpClient.HttpClient>;
+/**
+ * Layer registering both the provider-typed `Jev` tag and the generic
+ * `DecisionModel` tag over one implementation. `JevAnswers<D>` includes
+ * `Answers<D>`, so the generic registration forwards directly.
+ */
+declare const layer: (config: Config) => Layer.Layer<Jev | DecisionModel, never, HttpClient.HttpClient>;
+//#endregion
+export { Config, Jev, JevAnswerFor, JevAnswers, JevDecideRequest, JevDecideResponse, JevService, layer, make, Jev_d_exports as t };
+//# sourceMappingURL=Jev.d.mts.map

package/dist/Jev.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Jev.d.mts","names":[],"sources":["../src/Jev.ts"],"mappings":";;;;;;;;;;;;;;;KAsBY,aAAa,KAAK,SAAS,UAAU,KAAK,mBAAmB;;;;;;;KAQpE,mBAAmB,KAAK;WAAqB;;WAEnC;;KAEH,WAAW,UAAU,SAAS,yBAC9B,WAAW,IAAI,aAAa,EAAE;KAG9B,kBAAkB,UAAU,SAAS,aAAa,KAAK,eAAe;WACvE,SAAS,WAAW;;;KAInB,iBAAiB,KAAK,KAAK,oBAAoB;WAChD,OAAO;;KAGN;WACD,SAAS,GAAG,UAAU,SAAS,WACtC,YAAY,SAAS,WAAW,GAAG,IACnC,SAAS,iBAAiB,OACvB,OAAO,OAAO,kBAAkB,IAAI,QAAQ;;;;;;;;cAQtC,YAAY;KAIb;WACD,QAAQ,SAAS;WACjB;;;cAkQE,OAAI,QAAY,WAAS,OAAO,OAAO,mBAAmB,WAAW;;;;;;cAarE,QAAK,QACR,WACP,MAAM,MAAM,MAAM,sBAAsB,WAAW"}

package/dist/Jev.mjs

@@ -0,0 +1,203 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Context, Effect, Layer, Match, Record, Schema, pipe } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/unstable/http";
+import * as AiError from "@effect-uai/core/AiError";
+import { DecisionModel } from "@effect-uai/core/DecisionModel";
+//#region src/Jev.ts
+var Jev_exports = /* @__PURE__ */ __exportAll({
+	Jev: () => Jev,
+	layer: () => layer,
+	make: () => make
+});
+/**
+* Provider-typed service tag. Yield this for Jev's own `confidence`; yield the
+* generic `DecisionModel` tag for provider-portable code. Both are registered
+* by {@link layer}.
+*/
+var Jev = class extends Context.Service()("@betalyra/effect-uai/providers/typesafe-ai/Jev") {};
+const questionToWire = Match.type().pipe(Match.discriminatorsExhaustive("_tag")({
+	Classify: (decision) => ({
+		type: "choice",
+		instructions: decision.instructions,
+		criteria: decision.criteria
+	}),
+	Rate: (decision) => ({
+		type: "score",
+		instructions: decision.instructions,
+		criteria: decision.criteria
+	}),
+	Probability: (decision) => ({
+		type: "noul",
+		instructions: decision.instructions,
+		...decision.criteria !== void 0 && { criteria: decision.criteria }
+	})
+}));
+const WireChoiceAnswer = Schema.Struct({
+	type: Schema.Literal("choice"),
+	choice: Schema.String,
+	confidence: Schema.Number,
+	probabilities: Schema.Record(Schema.String, Schema.Number)
+});
+const WireScoreAnswer = Schema.Struct({
+	type: Schema.Literal("score"),
+	score: Schema.Number,
+	confidence: Schema.Number,
+	legend: Schema.Record(Schema.String, Schema.String),
+	probabilities: Schema.Record(Schema.String, Schema.Number)
+});
+const WireNoulAnswer = Schema.Struct({
+	type: Schema.Literal("noul"),
+	noul: Schema.Number
+});
+const WireUsage = Schema.Struct({
+	input_tokens: Schema.optional(Schema.Number),
+	output_tokens: Schema.optional(Schema.Number)
+});
+const WireResponse = Schema.Struct({
+	model: Schema.optional(Schema.String),
+	answers: Schema.Record(Schema.String, Schema.Unknown),
+	usage: Schema.optional(WireUsage)
+});
+const decodeChoice = Schema.decodeUnknownEffect(WireChoiceAnswer);
+const decodeScore = Schema.decodeUnknownEffect(WireScoreAnswer);
+const decodeNoul = Schema.decodeUnknownEffect(WireNoulAnswer);
+const wrongShape = (name, cause) => new AiError.GenerationFailed({
+	provider: "typesafe-ai",
+	message: `answer "${name}" did not match the kind its decision asked for`,
+	raw: cause
+});
+const missing = (name) => new AiError.GenerationFailed({
+	provider: "typesafe-ai",
+	message: `no answer for decision "${name}"`,
+	raw: void 0
+});
+/**
+* `probabilities` arrives keyed by level index as a string. Read it back
+* positionally against the rubric we sent, so a missing or extra index is a
+* decode failure rather than a hole in the tuple.
+*/
+const levelsOf = (name, criteria, probabilities) => Effect.forEach(criteria, (_, index) => {
+	const probability = probabilities[String(index)];
+	return probability === void 0 ? Effect.fail(wrongShape(name, `missing level ${index}`)) : Effect.succeed(probability);
+});
+const answerFor = (name, decision, raw) => Match.value(decision).pipe(Match.discriminatorsExhaustive("_tag")({
+	Classify: () => decodeChoice(raw).pipe(Effect.mapError((cause) => wrongShape(name, cause)), Effect.map((wire) => ({
+		_tag: "Classify",
+		labels: wire.probabilities
+	}))),
+	Rate: (rate) => decodeScore(raw).pipe(Effect.mapError((cause) => wrongShape(name, cause)), Effect.flatMap((wire) => Effect.map(levelsOf(name, rate.criteria, wire.probabilities), (levels) => ({
+		_tag: "Rate",
+		levels,
+		legend: rate.criteria
+	})))),
+	Probability: () => decodeNoul(raw).pipe(Effect.mapError((cause) => wrongShape(name, cause)), Effect.map((wire) => ({
+		_tag: "Probability",
+		probability: wire.noul
+	})))
+}));
+/**
+* The cast is the generic boundary: a record assembled at runtime cannot
+* prove it inhabits the caller's `JevAnswers<D>`. Each entry is decoded
+* against the kind its own decision asked for, so the shape is checked even
+* though the mapping is not.
+*/
+const answersOf = (decisions, wire) => pipe(Record.toEntries(decisions), Effect.forEach(([name, decision]) => {
+	const raw = wire.answers[name];
+	return raw === void 0 ? Effect.fail(missing(name)) : Effect.map(answerFor(name, decision, raw), (answer) => [name, answer]);
+}), Effect.map((entries) => Object.fromEntries(entries)));
+const transportFailure = (cause) => new AiError.Unavailable({
+	provider: "typesafe-ai",
+	raw: cause
+});
+const httpStatusError = (status, body) => {
+	const provider = "typesafe-ai";
+	const raw = body;
+	if (status === 429) return new AiError.RateLimited({
+		provider,
+		raw
+	});
+	if (status === 408 || status === 504) return new AiError.Timeout({
+		provider,
+		raw
+	});
+	if (status === 401) return new AiError.AuthFailed({
+		provider,
+		subtype: "auth",
+		raw
+	});
+	if (status === 403) return new AiError.AuthFailed({
+		provider,
+		subtype: "permission",
+		raw
+	});
+	if (status === 402) return new AiError.AuthFailed({
+		provider,
+		subtype: "billing",
+		raw
+	});
+	if (status === 413) return new AiError.ContextLengthExceeded({
+		provider,
+		raw
+	});
+	if (status >= 500) return new AiError.Unavailable({
+		provider,
+		status,
+		raw
+	});
+	return new AiError.InvalidRequest({
+		provider,
+		raw
+	});
+};
+const baseUrl = (config) => config.baseUrl ?? "https://api.typesafe.ai";
+const postSystemOne = (config, body) => Effect.gen(function* () {
+	const client = yield* HttpClient.HttpClient;
+	const httpRequest = HttpClientRequest.post(`${baseUrl(config)}/v1/systemone`).pipe(HttpClientRequest.bearerToken(config.apiKey), HttpClientRequest.bodyJsonUnsafe(body));
+	const response = yield* client.execute(httpRequest).pipe(Effect.mapError(transportFailure));
+	if (response.status >= 400) {
+		const text = yield* response.text.pipe(Effect.orElseSucceed(() => ""));
+		return yield* httpStatusError(response.status, text);
+	}
+	const json = yield* response.json.pipe(Effect.mapError(transportFailure));
+	return yield* Schema.decodeUnknownEffect(WireResponse)(json).pipe(Effect.mapError(transportFailure));
+});
+const decideImpl = (config) => (definition, request) => Effect.gen(function* () {
+	if (Record.isEmptyRecord(definition.decisions)) return yield* Effect.fail(new AiError.InvalidRequest({
+		provider: "typesafe-ai",
+		param: "decisions",
+		raw: "a definition must carry at least one decision"
+	}));
+	const state = yield* Schema.encodeEffect(definition.inputSchema)(request.input).pipe(Effect.mapError((cause) => new AiError.InvalidRequest({
+		provider: "typesafe-ai",
+		param: "input",
+		raw: cause
+	})));
+	const wire = yield* postSystemOne(config, {
+		model: request.model,
+		state,
+		questions: Record.map(definition.decisions, questionToWire)
+	});
+	return {
+		answers: yield* answersOf(definition.decisions, wire),
+		usage: {
+			...wire.usage?.input_tokens !== void 0 && { inputTokens: wire.usage.input_tokens },
+			...wire.usage?.output_tokens !== void 0 && { outputTokens: wire.usage.output_tokens }
+		}
+	};
+});
+/** Build a `JevService` value. For Layer-based setup, prefer {@link layer}. */
+const make = (config) => Effect.map(HttpClient.HttpClient, (client) => ({ decide: (definition, request) => decideImpl(config)(definition, request).pipe(Effect.provideService(HttpClient.HttpClient, client)) }));
+/**
+* Layer registering both the provider-typed `Jev` tag and the generic
+* `DecisionModel` tag over one implementation. `JevAnswers<D>` includes
+* `Answers<D>`, so the generic registration forwards directly.
+*/
+const layer = (config) => {
+	const typed = Layer.effect(Jev, make(config));
+	const generic = Layer.effect(DecisionModel, Effect.map(make(config), (service) => ({ decide: (definition, request) => service.decide(definition, request) })));
+	return Layer.merge(typed, generic);
+};
+//#endregion
+export { Jev, layer, make, Jev_exports as t };
+
+//# sourceMappingURL=Jev.mjs.map

package/dist/Jev.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Jev.mjs","names":[],"sources":["../src/Jev.ts"],"sourcesContent":["import { Context, Effect, Layer, Match, type Redacted, Record, Schema, pipe } from \"effect\"\nimport { HttpClient, HttpClientRequest } from \"effect/unstable/http\"\nimport * as AiError from \"@effect-uai/core/AiError\"\nimport * as Decision from \"@effect-uai/core/Decision\"\nimport {\n  type CommonDecideRequest,\n  type DecideResponse,\n  DecisionModel,\n  type DecisionModelService,\n} from \"@effect-uai/core/DecisionModel\"\nimport type { JevModel } from \"./models.js\"\n\n// ---------------------------------------------------------------------------\n// Public types\n// ---------------------------------------------------------------------------\n\n/**\n * Jev reports its own `confidence` alongside the distribution, on Classify\n * and Rate but not on Probability. The formula is undocumented, so it is not\n * on the Common answer; `Decision.confidence` is ours and is defined for\n * every kind.\n */\nexport type JevAnswerFor<D> = Decision.AnswerFor<D> & ReportedConfidence<D>\n\n/**\n * Intersected rather than branched per kind, so `JevAnswers` stays provably\n * assignable to `Answers`: TypeScript cannot see one deferred conditional as\n * a subtype of another, but an intersection is always assignable to its\n * members.\n */\ntype ReportedConfidence<D> = D extends { readonly _tag: \"Probability\" }\n  ? unknown\n  : { readonly confidence: number }\n\nexport type JevAnswers<D extends Decision.Decisions> = {\n  readonly [K in keyof D]: JevAnswerFor<D[K]>\n}\n\nexport type JevDecideResponse<D extends Decision.Decisions> = Omit<DecideResponse<D>, \"answers\"> & {\n  readonly answers: JevAnswers<D>\n}\n\n/** Narrows `model` to Jev's roster. */\nexport type JevDecideRequest<A> = Omit<CommonDecideRequest<A>, \"model\"> & {\n  readonly model: JevModel\n}\n\nexport type JevService = {\n  readonly decide: <A, D extends Decision.Decisions>(\n    definition: Decision.Definition<A, D>,\n    request: JevDecideRequest<A>,\n  ) => Effect.Effect<JevDecideResponse<D>, AiError.AiError>\n}\n\n/**\n * Provider-typed service tag. Yield this for Jev's own `confidence`; yield the\n * generic `DecisionModel` tag for provider-portable code. Both are registered\n * by {@link layer}.\n */\nexport class Jev extends Context.Service<Jev, JevService>()(\n  \"@betalyra/effect-uai/providers/typesafe-ai/Jev\",\n) {}\n\nexport type Config = {\n  readonly apiKey: Redacted.Redacted\n  readonly baseUrl?: string\n}\n\n// ---------------------------------------------------------------------------\n// Codec - request body\n// ---------------------------------------------------------------------------\n\ntype WireQuestion =\n  | { readonly type: \"choice\"; readonly instructions: string; readonly criteria: Decision.Labels }\n  | {\n      readonly type: \"score\"\n      readonly instructions: string\n      readonly criteria: ReadonlyArray<string>\n    }\n  | {\n      readonly type: \"noul\"\n      readonly instructions: string\n      readonly criteria?: Decision.Boundary\n    }\n\nconst questionToWire: (decision: Decision.Decision) => WireQuestion =\n  Match.type<Decision.Decision>().pipe(\n    Match.discriminatorsExhaustive(\"_tag\")({\n      Classify: (decision) => ({\n        type: \"choice\" as const,\n        instructions: decision.instructions,\n        criteria: decision.criteria,\n      }),\n      Rate: (decision) => ({\n        type: \"score\" as const,\n        instructions: decision.instructions,\n        criteria: decision.criteria,\n      }),\n      Probability: (decision) => ({\n        type: \"noul\" as const,\n        instructions: decision.instructions,\n        ...(decision.criteria !== undefined && { criteria: decision.criteria }),\n      }),\n    }),\n  )\n\ntype WireBody = {\n  readonly model: string\n  readonly state: unknown\n  readonly questions: Readonly<Record<string, WireQuestion>>\n}\n\n// ---------------------------------------------------------------------------\n// Codec - response\n// ---------------------------------------------------------------------------\n\nconst WireChoiceAnswer = Schema.Struct({\n  type: Schema.Literal(\"choice\"),\n  choice: Schema.String,\n  confidence: Schema.Number,\n  probabilities: Schema.Record(Schema.String, Schema.Number),\n})\n\nconst WireScoreAnswer = Schema.Struct({\n  type: Schema.Literal(\"score\"),\n  score: Schema.Number,\n  confidence: Schema.Number,\n  legend: Schema.Record(Schema.String, Schema.String),\n  probabilities: Schema.Record(Schema.String, Schema.Number),\n})\n\nconst WireNoulAnswer = Schema.Struct({\n  type: Schema.Literal(\"noul\"),\n  noul: Schema.Number,\n})\n\nconst WireUsage = Schema.Struct({\n  input_tokens: Schema.optional(Schema.Number),\n  output_tokens: Schema.optional(Schema.Number),\n})\n\nconst WireResponse = Schema.Struct({\n  model: Schema.optional(Schema.String),\n  answers: Schema.Record(Schema.String, Schema.Unknown),\n  usage: Schema.optional(WireUsage),\n})\ntype WireResponse = typeof WireResponse.Type\n\nconst decodeChoice = Schema.decodeUnknownEffect(WireChoiceAnswer)\nconst decodeScore = Schema.decodeUnknownEffect(WireScoreAnswer)\nconst decodeNoul = Schema.decodeUnknownEffect(WireNoulAnswer)\n\nconst wrongShape = (name: string, cause: unknown): AiError.AiError =>\n  new AiError.GenerationFailed({\n    provider: \"typesafe-ai\",\n    message: `answer \"${name}\" did not match the kind its decision asked for`,\n    raw: cause,\n  })\n\nconst missing = (name: string): AiError.AiError =>\n  new AiError.GenerationFailed({\n    provider: \"typesafe-ai\",\n    message: `no answer for decision \"${name}\"`,\n    raw: undefined,\n  })\n\n/**\n * `probabilities` arrives keyed by level index as a string. Read it back\n * positionally against the rubric we sent, so a missing or extra index is a\n * decode failure rather than a hole in the tuple.\n */\nconst levelsOf = (\n  name: string,\n  criteria: ReadonlyArray<string>,\n  probabilities: Readonly<Record<string, number>>,\n): Effect.Effect<ReadonlyArray<number>, AiError.AiError> =>\n  Effect.forEach(criteria, (_, index) => {\n    const probability = probabilities[String(index)]\n    return probability === undefined\n      ? Effect.fail(wrongShape(name, `missing level ${index}`))\n      : Effect.succeed(probability)\n  })\n\nconst answerFor = (\n  name: string,\n  decision: Decision.Decision,\n  raw: unknown,\n): Effect.Effect<Decision.Answer, AiError.AiError> =>\n  Match.value(decision).pipe(\n    Match.discriminatorsExhaustive(\"_tag\")({\n      Classify: () =>\n        decodeChoice(raw).pipe(\n          Effect.mapError((cause) => wrongShape(name, cause)),\n          Effect.map((wire) => ({ _tag: \"Classify\" as const, labels: wire.probabilities })),\n        ),\n      Rate: (rate) =>\n        decodeScore(raw).pipe(\n          Effect.mapError((cause) => wrongShape(name, cause)),\n          Effect.flatMap((wire) =>\n            Effect.map(levelsOf(name, rate.criteria, wire.probabilities), (levels) => ({\n              _tag: \"Rate\" as const,\n              levels,\n              legend: rate.criteria,\n            })),\n          ),\n        ),\n      Probability: () =>\n        decodeNoul(raw).pipe(\n          Effect.mapError((cause) => wrongShape(name, cause)),\n          Effect.map((wire) => ({ _tag: \"Probability\" as const, probability: wire.noul })),\n        ),\n    }),\n  ) as Effect.Effect<Decision.Answer, AiError.AiError>\n\n/**\n * The cast is the generic boundary: a record assembled at runtime cannot\n * prove it inhabits the caller's `JevAnswers<D>`. Each entry is decoded\n * against the kind its own decision asked for, so the shape is checked even\n * though the mapping is not.\n */\nconst answersOf = <D extends Decision.Decisions>(\n  decisions: D,\n  wire: WireResponse,\n): Effect.Effect<JevAnswers<D>, AiError.AiError> =>\n  pipe(\n    Record.toEntries(decisions),\n    Effect.forEach(([name, decision]) => {\n      const raw = wire.answers[name]\n      return raw === undefined\n        ? Effect.fail(missing(name))\n        : Effect.map(answerFor(name, decision, raw), (answer) => [name, answer] as const)\n    }),\n    Effect.map((entries) => Object.fromEntries(entries) as JevAnswers<D>),\n  )\n\n// ---------------------------------------------------------------------------\n// HTTP\n// ---------------------------------------------------------------------------\n\nconst transportFailure = (cause: unknown): AiError.AiError =>\n  new AiError.Unavailable({ provider: \"typesafe-ai\", raw: cause })\n\nconst httpStatusError = (status: number, body: string): AiError.AiError => {\n  const provider = \"typesafe-ai\"\n  const raw = body\n  if (status === 429) return new AiError.RateLimited({ provider, raw })\n  if (status === 408 || status === 504) return new AiError.Timeout({ provider, raw })\n  if (status === 401) return new AiError.AuthFailed({ provider, subtype: \"auth\", raw })\n  if (status === 403) return new AiError.AuthFailed({ provider, subtype: \"permission\", raw })\n  if (status === 402) return new AiError.AuthFailed({ provider, subtype: \"billing\", raw })\n  if (status === 413) return new AiError.ContextLengthExceeded({ provider, raw })\n  if (status >= 500) return new AiError.Unavailable({ provider, status, raw })\n  return new AiError.InvalidRequest({ provider, raw })\n}\n\nconst baseUrl = (config: Config): string => config.baseUrl ?? \"https://api.typesafe.ai\"\n\nconst postSystemOne = (\n  config: Config,\n  body: WireBody,\n): Effect.Effect<WireResponse, AiError.AiError, HttpClient.HttpClient> =>\n  Effect.gen(function* () {\n    const client = yield* HttpClient.HttpClient\n    const httpRequest = HttpClientRequest.post(`${baseUrl(config)}/v1/systemone`).pipe(\n      HttpClientRequest.bearerToken(config.apiKey),\n      HttpClientRequest.bodyJsonUnsafe(body),\n    )\n    const response = yield* client.execute(httpRequest).pipe(Effect.mapError(transportFailure))\n    if (response.status >= 400) {\n      const text = yield* response.text.pipe(Effect.orElseSucceed(() => \"\"))\n      return yield* httpStatusError(response.status, text)\n    }\n    const json = yield* response.json.pipe(Effect.mapError(transportFailure))\n    return yield* Schema.decodeUnknownEffect(WireResponse)(json).pipe(\n      Effect.mapError(transportFailure),\n    )\n  })\n\nconst decideImpl =\n  (config: Config) =>\n  <A, D extends Decision.Decisions>(\n    definition: Decision.Definition<A, D>,\n    request: JevDecideRequest<A>,\n  ): Effect.Effect<JevDecideResponse<D>, AiError.AiError, HttpClient.HttpClient> =>\n    Effect.gen(function* () {\n      if (Record.isEmptyRecord(definition.decisions)) {\n        return yield* Effect.fail(\n          new AiError.InvalidRequest({\n            provider: \"typesafe-ai\",\n            param: \"decisions\",\n            raw: \"a definition must carry at least one decision\",\n          }),\n        )\n      }\n      // A schema that rejects the input is the caller's bug, not a wire fault.\n      const state = yield* Schema.encodeEffect(definition.inputSchema)(request.input).pipe(\n        Effect.mapError(\n          (cause) =>\n            new AiError.InvalidRequest({ provider: \"typesafe-ai\", param: \"input\", raw: cause }),\n        ),\n      )\n      const wire = yield* postSystemOne(config, {\n        model: request.model,\n        state,\n        questions: Record.map(definition.decisions, questionToWire),\n      })\n      const answers = yield* answersOf(definition.decisions, wire)\n      return {\n        answers,\n        usage: {\n          ...(wire.usage?.input_tokens !== undefined && { inputTokens: wire.usage.input_tokens }),\n          ...(wire.usage?.output_tokens !== undefined && {\n            outputTokens: wire.usage.output_tokens,\n          }),\n        },\n      }\n    })\n\n// ---------------------------------------------------------------------------\n// Constructors\n// ---------------------------------------------------------------------------\n\n/** Build a `JevService` value. For Layer-based setup, prefer {@link layer}. */\nexport const make = (config: Config): Effect.Effect<JevService, never, HttpClient.HttpClient> =>\n  Effect.map(HttpClient.HttpClient, (client) => ({\n    decide: (definition, request) =>\n      decideImpl(config)(definition, request).pipe(\n        Effect.provideService(HttpClient.HttpClient, client),\n      ),\n  }))\n\n/**\n * Layer registering both the provider-typed `Jev` tag and the generic\n * `DecisionModel` tag over one implementation. `JevAnswers<D>` includes\n * `Answers<D>`, so the generic registration forwards directly.\n */\nexport const layer = (\n  config: Config,\n): Layer.Layer<Jev | DecisionModel, never, HttpClient.HttpClient> => {\n  const typed = Layer.effect(Jev, make(config))\n  const generic = Layer.effect(\n    DecisionModel,\n    Effect.map(make(config), (service): DecisionModelService => ({\n      decide: (definition, request) => service.decide(definition, request),\n    })),\n  )\n  return Layer.merge(typed, generic)\n}\n"],"mappings":";;;;;;;;;;;;;;;;AA2DA,IAAa,MAAb,cAAyB,QAAQ,QAAyB,CAAC,CACzD,gDACF,CAAC,CAAC,CAAC;AAwBH,MAAM,iBACJ,MAAM,KAAwB,CAAC,CAAC,KAC9B,MAAM,yBAAyB,MAAM,CAAC,CAAC;CACrC,WAAW,cAAc;EACvB,MAAM;EACN,cAAc,SAAS;EACvB,UAAU,SAAS;CACrB;CACA,OAAO,cAAc;EACnB,MAAM;EACN,cAAc,SAAS;EACvB,UAAU,SAAS;CACrB;CACA,cAAc,cAAc;EAC1B,MAAM;EACN,cAAc,SAAS;EACvB,GAAI,SAAS,aAAa,KAAA,KAAa,EAAE,UAAU,SAAS,SAAS;CACvE;AACF,CAAC,CACH;AAYF,MAAM,mBAAmB,OAAO,OAAO;CACrC,MAAM,OAAO,QAAQ,QAAQ;CAC7B,QAAQ,OAAO;CACf,YAAY,OAAO;CACnB,eAAe,OAAO,OAAO,OAAO,QAAQ,OAAO,MAAM;AAC3D,CAAC;AAED,MAAM,kBAAkB,OAAO,OAAO;CACpC,MAAM,OAAO,QAAQ,OAAO;CAC5B,OAAO,OAAO;CACd,YAAY,OAAO;CACnB,QAAQ,OAAO,OAAO,OAAO,QAAQ,OAAO,MAAM;CAClD,eAAe,OAAO,OAAO,OAAO,QAAQ,OAAO,MAAM;AAC3D,CAAC;AAED,MAAM,iBAAiB,OAAO,OAAO;CACnC,MAAM,OAAO,QAAQ,MAAM;CAC3B,MAAM,OAAO;AACf,CAAC;AAED,MAAM,YAAY,OAAO,OAAO;CAC9B,cAAc,OAAO,SAAS,OAAO,MAAM;CAC3C,eAAe,OAAO,SAAS,OAAO,MAAM;AAC9C,CAAC;AAED,MAAM,eAAe,OAAO,OAAO;CACjC,OAAO,OAAO,SAAS,OAAO,MAAM;CACpC,SAAS,OAAO,OAAO,OAAO,QAAQ,OAAO,OAAO;CACpD,OAAO,OAAO,SAAS,SAAS;AAClC,CAAC;AAGD,MAAM,eAAe,OAAO,oBAAoB,gBAAgB;AAChE,MAAM,cAAc,OAAO,oBAAoB,eAAe;AAC9D,MAAM,aAAa,OAAO,oBAAoB,cAAc;AAE5D,MAAM,cAAc,MAAc,UAChC,IAAI,QAAQ,iBAAiB;CAC3B,UAAU;CACV,SAAS,WAAW,KAAK;CACzB,KAAK;AACP,CAAC;AAEH,MAAM,WAAW,SACf,IAAI,QAAQ,iBAAiB;CAC3B,UAAU;CACV,SAAS,2BAA2B,KAAK;CACzC,KAAK,KAAA;AACP,CAAC;;;;;;AAOH,MAAM,YACJ,MACA,UACA,kBAEA,OAAO,QAAQ,WAAW,GAAG,UAAU;CACrC,MAAM,cAAc,cAAc,OAAO,KAAK;CAC9C,OAAO,gBAAgB,KAAA,IACnB,OAAO,KAAK,WAAW,MAAM,iBAAiB,OAAO,CAAC,IACtD,OAAO,QAAQ,WAAW;AAChC,CAAC;AAEH,MAAM,aACJ,MACA,UACA,QAEA,MAAM,MAAM,QAAQ,CAAC,CAAC,KACpB,MAAM,yBAAyB,MAAM,CAAC,CAAC;CACrC,gBACE,aAAa,GAAG,CAAC,CAAC,KAChB,OAAO,UAAU,UAAU,WAAW,MAAM,KAAK,CAAC,GAClD,OAAO,KAAK,UAAU;EAAE,MAAM;EAAqB,QAAQ,KAAK;CAAc,EAAE,CAClF;CACF,OAAO,SACL,YAAY,GAAG,CAAC,CAAC,KACf,OAAO,UAAU,UAAU,WAAW,MAAM,KAAK,CAAC,GAClD,OAAO,SAAS,SACd,OAAO,IAAI,SAAS,MAAM,KAAK,UAAU,KAAK,aAAa,IAAI,YAAY;EACzE,MAAM;EACN;EACA,QAAQ,KAAK;CACf,EAAE,CACJ,CACF;CACF,mBACE,WAAW,GAAG,CAAC,CAAC,KACd,OAAO,UAAU,UAAU,WAAW,MAAM,KAAK,CAAC,GAClD,OAAO,KAAK,UAAU;EAAE,MAAM;EAAwB,aAAa,KAAK;CAAK,EAAE,CACjF;AACJ,CAAC,CACH;;;;;;;AAQF,MAAM,aACJ,WACA,SAEA,KACE,OAAO,UAAU,SAAS,GAC1B,OAAO,SAAS,CAAC,MAAM,cAAc;CACnC,MAAM,MAAM,KAAK,QAAQ;CACzB,OAAO,QAAQ,KAAA,IACX,OAAO,KAAK,QAAQ,IAAI,CAAC,IACzB,OAAO,IAAI,UAAU,MAAM,UAAU,GAAG,IAAI,WAAW,CAAC,MAAM,MAAM,CAAU;AACpF,CAAC,GACD,OAAO,KAAK,YAAY,OAAO,YAAY,OAAO,CAAkB,CACtE;AAMF,MAAM,oBAAoB,UACxB,IAAI,QAAQ,YAAY;CAAE,UAAU;CAAe,KAAK;AAAM,CAAC;AAEjE,MAAM,mBAAmB,QAAgB,SAAkC;CACzE,MAAM,WAAW;CACjB,MAAM,MAAM;CACZ,IAAI,WAAW,KAAK,OAAO,IAAI,QAAQ,YAAY;EAAE;EAAU;CAAI,CAAC;CACpE,IAAI,WAAW,OAAO,WAAW,KAAK,OAAO,IAAI,QAAQ,QAAQ;EAAE;EAAU;CAAI,CAAC;CAClF,IAAI,WAAW,KAAK,OAAO,IAAI,QAAQ,WAAW;EAAE;EAAU,SAAS;EAAQ;CAAI,CAAC;CACpF,IAAI,WAAW,KAAK,OAAO,IAAI,QAAQ,WAAW;EAAE;EAAU,SAAS;EAAc;CAAI,CAAC;CAC1F,IAAI,WAAW,KAAK,OAAO,IAAI,QAAQ,WAAW;EAAE;EAAU,SAAS;EAAW;CAAI,CAAC;CACvF,IAAI,WAAW,KAAK,OAAO,IAAI,QAAQ,sBAAsB;EAAE;EAAU;CAAI,CAAC;CAC9E,IAAI,UAAU,KAAK,OAAO,IAAI,QAAQ,YAAY;EAAE;EAAU;EAAQ;CAAI,CAAC;CAC3E,OAAO,IAAI,QAAQ,eAAe;EAAE;EAAU;CAAI,CAAC;AACrD;AAEA,MAAM,WAAW,WAA2B,OAAO,WAAW;AAE9D,MAAM,iBACJ,QACA,SAEA,OAAO,IAAI,aAAa;CACtB,MAAM,SAAS,OAAO,WAAW;CACjC,MAAM,cAAc,kBAAkB,KAAK,GAAG,QAAQ,MAAM,EAAE,cAAc,CAAC,CAAC,KAC5E,kBAAkB,YAAY,OAAO,MAAM,GAC3C,kBAAkB,eAAe,IAAI,CACvC;CACA,MAAM,WAAW,OAAO,OAAO,QAAQ,WAAW,CAAC,CAAC,KAAK,OAAO,SAAS,gBAAgB,CAAC;CAC1F,IAAI,SAAS,UAAU,KAAK;EAC1B,MAAM,OAAO,OAAO,SAAS,KAAK,KAAK,OAAO,oBAAoB,EAAE,CAAC;EACrE,OAAO,OAAO,gBAAgB,SAAS,QAAQ,IAAI;CACrD;CACA,MAAM,OAAO,OAAO,SAAS,KAAK,KAAK,OAAO,SAAS,gBAAgB,CAAC;CACxE,OAAO,OAAO,OAAO,oBAAoB,YAAY,CAAC,CAAC,IAAI,CAAC,CAAC,KAC3D,OAAO,SAAS,gBAAgB,CAClC;AACF,CAAC;AAEH,MAAM,cACH,YAEC,YACA,YAEA,OAAO,IAAI,aAAa;CACtB,IAAI,OAAO,cAAc,WAAW,SAAS,GAC3C,OAAO,OAAO,OAAO,KACnB,IAAI,QAAQ,eAAe;EACzB,UAAU;EACV,OAAO;EACP,KAAK;CACP,CAAC,CACH;CAGF,MAAM,QAAQ,OAAO,OAAO,aAAa,WAAW,WAAW,CAAC,CAAC,QAAQ,KAAK,CAAC,CAAC,KAC9E,OAAO,UACJ,UACC,IAAI,QAAQ,eAAe;EAAE,UAAU;EAAe,OAAO;EAAS,KAAK;CAAM,CAAC,CACtF,CACF;CACA,MAAM,OAAO,OAAO,cAAc,QAAQ;EACxC,OAAO,QAAQ;EACf;EACA,WAAW,OAAO,IAAI,WAAW,WAAW,cAAc;CAC5D,CAAC;CAED,OAAO;EACL,SAAA,OAFqB,UAAU,WAAW,WAAW,IAAI;EAGzD,OAAO;GACL,GAAI,KAAK,OAAO,iBAAiB,KAAA,KAAa,EAAE,aAAa,KAAK,MAAM,aAAa;GACrF,GAAI,KAAK,OAAO,kBAAkB,KAAA,KAAa,EAC7C,cAAc,KAAK,MAAM,cAC3B;EACF;CACF;AACF,CAAC;;AAOL,MAAa,QAAQ,WACnB,OAAO,IAAI,WAAW,aAAa,YAAY,EAC7C,SAAS,YAAY,YACnB,WAAW,MAAM,CAAC,CAAC,YAAY,OAAO,CAAC,CAAC,KACtC,OAAO,eAAe,WAAW,YAAY,MAAM,CACrD,EACJ,EAAE;;;;;;AAOJ,MAAa,SACX,WACmE;CACnE,MAAM,QAAQ,MAAM,OAAO,KAAK,KAAK,MAAM,CAAC;CAC5C,MAAM,UAAU,MAAM,OACpB,eACA,OAAO,IAAI,KAAK,MAAM,IAAI,aAAmC,EAC3D,SAAS,YAAY,YAAY,QAAQ,OAAO,YAAY,OAAO,EACrE,EAAE,CACJ;CACA,OAAO,MAAM,MAAM,OAAO,OAAO;AACnC"}

package/dist/index.d.mts

@@ -0,0 +1,3 @@
+import { JevModel } from "./models.mjs";
+import { t as Jev_d_exports } from "./Jev.mjs";
+export { Jev_d_exports as Jev, JevModel };

package/dist/index.mjs

@@ -0,0 +1,3 @@
+import { t as Jev_exports } from "./Jev.mjs";
+import "./models.mjs";
+export { Jev_exports as Jev };

package/dist/models.d.mts

@@ -0,0 +1,18 @@
+//#region src/models.d.ts
+/**
+ * Jev model identifiers.
+ *
+ * - `jev-latest`: most recent stable release, the SDK default.
+ * - `jev-preview`: currently identical to `jev-latest`.
+ * - `jev-1.13.0`: pinned.
+ *
+ * 64k tokens per request, of which ~32k for the encoded input plus the
+ * longest single decision. Text only.
+ *
+ * The `(string & {})` tail accepts any string so new releases work without
+ * an SDK update.
+ */
+type JevModel = "jev-latest" | "jev-preview" | "jev-1.13.0" | (string & {});
+//#endregion
+export { JevModel };
+//# sourceMappingURL=models.d.mts.map

package/dist/models.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.mts","names":[],"sources":["../src/models.ts"],"mappings":";;;;;;;;;;;;;;KAaY"}

package/dist/models.mjs

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

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,59 @@
+{
+  "name": "@effect-uai/typesafe-ai",
+  "version": "0.16.0",
+  "description": "TypeSafe AI provider for @effect-uai/core (Jev System One decision model).",
+  "keywords": [
+    "ai",
+    "classification",
+    "decision-model",
+    "effect",
+    "jev",
+    "typesafe"
+  ],
+  "homepage": "https://github.com/betalyra/effect-uai/tree/main/packages/providers/typesafe-ai",
+  "bugs": {
+    "url": "https://github.com/betalyra/effect-uai/issues"
+  },
+  "license": "MIT",
+  "author": "Betalyra",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/betalyra/effect-uai",
+    "directory": "packages/providers/typesafe-ai"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./Jev": {
+      "types": "./dist/Jev.d.mts",
+      "import": "./dist/Jev.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "effect": "4.0.0-rc.111",
+    "typescript": "^7.0.2",
+    "@effect-uai/core": "0.16.0"
+  },
+  "peerDependencies": {
+    "@effect-uai/core": ">=0.17.0 <1",
+    "effect": ">=4.0.0-rc.111 <5.0.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/Jev.ts

@@ -0,0 +1,348 @@
+import { Context, Effect, Layer, Match, type Redacted, Record, Schema, pipe } from "effect"
+import { HttpClient, HttpClientRequest } from "effect/unstable/http"
+import * as AiError from "@effect-uai/core/AiError"
+import * as Decision from "@effect-uai/core/Decision"
+import {
+  type CommonDecideRequest,
+  type DecideResponse,
+  DecisionModel,
+  type DecisionModelService,
+} from "@effect-uai/core/DecisionModel"
+import type { JevModel } from "./models.js"
+
+// ---------------------------------------------------------------------------
+// Public types
+// ---------------------------------------------------------------------------
+
+/**
+ * Jev reports its own `confidence` alongside the distribution, on Classify
+ * and Rate but not on Probability. The formula is undocumented, so it is not
+ * on the Common answer; `Decision.confidence` is ours and is defined for
+ * every kind.
+ */
+export type JevAnswerFor<D> = Decision.AnswerFor<D> & ReportedConfidence<D>
+
+/**
+ * Intersected rather than branched per kind, so `JevAnswers` stays provably
+ * assignable to `Answers`: TypeScript cannot see one deferred conditional as
+ * a subtype of another, but an intersection is always assignable to its
+ * members.
+ */
+type ReportedConfidence<D> = D extends { readonly _tag: "Probability" }
+  ? unknown
+  : { readonly confidence: number }
+
+export type JevAnswers<D extends Decision.Decisions> = {
+  readonly [K in keyof D]: JevAnswerFor<D[K]>
+}
+
+export type JevDecideResponse<D extends Decision.Decisions> = Omit<DecideResponse<D>, "answers"> & {
+  readonly answers: JevAnswers<D>
+}
+
+/** Narrows `model` to Jev's roster. */
+export type JevDecideRequest<A> = Omit<CommonDecideRequest<A>, "model"> & {
+  readonly model: JevModel
+}
+
+export type JevService = {
+  readonly decide: <A, D extends Decision.Decisions>(
+    definition: Decision.Definition<A, D>,
+    request: JevDecideRequest<A>,
+  ) => Effect.Effect<JevDecideResponse<D>, AiError.AiError>
+}
+
+/**
+ * Provider-typed service tag. Yield this for Jev's own `confidence`; yield the
+ * generic `DecisionModel` tag for provider-portable code. Both are registered
+ * by {@link layer}.
+ */
+export class Jev extends Context.Service<Jev, JevService>()(
+  "@betalyra/effect-uai/providers/typesafe-ai/Jev",
+) {}
+
+export type Config = {
+  readonly apiKey: Redacted.Redacted
+  readonly baseUrl?: string
+}
+
+// ---------------------------------------------------------------------------
+// Codec - request body
+// ---------------------------------------------------------------------------
+
+type WireQuestion =
+  | { readonly type: "choice"; readonly instructions: string; readonly criteria: Decision.Labels }
+  | {
+      readonly type: "score"
+      readonly instructions: string
+      readonly criteria: ReadonlyArray<string>
+    }
+  | {
+      readonly type: "noul"
+      readonly instructions: string
+      readonly criteria?: Decision.Boundary
+    }
+
+const questionToWire: (decision: Decision.Decision) => WireQuestion =
+  Match.type<Decision.Decision>().pipe(
+    Match.discriminatorsExhaustive("_tag")({
+      Classify: (decision) => ({
+        type: "choice" as const,
+        instructions: decision.instructions,
+        criteria: decision.criteria,
+      }),
+      Rate: (decision) => ({
+        type: "score" as const,
+        instructions: decision.instructions,
+        criteria: decision.criteria,
+      }),
+      Probability: (decision) => ({
+        type: "noul" as const,
+        instructions: decision.instructions,
+        ...(decision.criteria !== undefined && { criteria: decision.criteria }),
+      }),
+    }),
+  )
+
+type WireBody = {
+  readonly model: string
+  readonly state: unknown
+  readonly questions: Readonly<Record<string, WireQuestion>>
+}
+
+// ---------------------------------------------------------------------------
+// Codec - response
+// ---------------------------------------------------------------------------
+
+const WireChoiceAnswer = Schema.Struct({
+  type: Schema.Literal("choice"),
+  choice: Schema.String,
+  confidence: Schema.Number,
+  probabilities: Schema.Record(Schema.String, Schema.Number),
+})
+
+const WireScoreAnswer = Schema.Struct({
+  type: Schema.Literal("score"),
+  score: Schema.Number,
+  confidence: Schema.Number,
+  legend: Schema.Record(Schema.String, Schema.String),
+  probabilities: Schema.Record(Schema.String, Schema.Number),
+})
+
+const WireNoulAnswer = Schema.Struct({
+  type: Schema.Literal("noul"),
+  noul: Schema.Number,
+})
+
+const WireUsage = Schema.Struct({
+  input_tokens: Schema.optional(Schema.Number),
+  output_tokens: Schema.optional(Schema.Number),
+})
+
+const WireResponse = Schema.Struct({
+  model: Schema.optional(Schema.String),
+  answers: Schema.Record(Schema.String, Schema.Unknown),
+  usage: Schema.optional(WireUsage),
+})
+type WireResponse = typeof WireResponse.Type
+
+const decodeChoice = Schema.decodeUnknownEffect(WireChoiceAnswer)
+const decodeScore = Schema.decodeUnknownEffect(WireScoreAnswer)
+const decodeNoul = Schema.decodeUnknownEffect(WireNoulAnswer)
+
+const wrongShape = (name: string, cause: unknown): AiError.AiError =>
+  new AiError.GenerationFailed({
+    provider: "typesafe-ai",
+    message: `answer "${name}" did not match the kind its decision asked for`,
+    raw: cause,
+  })
+
+const missing = (name: string): AiError.AiError =>
+  new AiError.GenerationFailed({
+    provider: "typesafe-ai",
+    message: `no answer for decision "${name}"`,
+    raw: undefined,
+  })
+
+/**
+ * `probabilities` arrives keyed by level index as a string. Read it back
+ * positionally against the rubric we sent, so a missing or extra index is a
+ * decode failure rather than a hole in the tuple.
+ */
+const levelsOf = (
+  name: string,
+  criteria: ReadonlyArray<string>,
+  probabilities: Readonly<Record<string, number>>,
+): Effect.Effect<ReadonlyArray<number>, AiError.AiError> =>
+  Effect.forEach(criteria, (_, index) => {
+    const probability = probabilities[String(index)]
+    return probability === undefined
+      ? Effect.fail(wrongShape(name, `missing level ${index}`))
+      : Effect.succeed(probability)
+  })
+
+const answerFor = (
+  name: string,
+  decision: Decision.Decision,
+  raw: unknown,
+): Effect.Effect<Decision.Answer, AiError.AiError> =>
+  Match.value(decision).pipe(
+    Match.discriminatorsExhaustive("_tag")({
+      Classify: () =>
+        decodeChoice(raw).pipe(
+          Effect.mapError((cause) => wrongShape(name, cause)),
+          Effect.map((wire) => ({ _tag: "Classify" as const, labels: wire.probabilities })),
+        ),
+      Rate: (rate) =>
+        decodeScore(raw).pipe(
+          Effect.mapError((cause) => wrongShape(name, cause)),
+          Effect.flatMap((wire) =>
+            Effect.map(levelsOf(name, rate.criteria, wire.probabilities), (levels) => ({
+              _tag: "Rate" as const,
+              levels,
+              legend: rate.criteria,
+            })),
+          ),
+        ),
+      Probability: () =>
+        decodeNoul(raw).pipe(
+          Effect.mapError((cause) => wrongShape(name, cause)),
+          Effect.map((wire) => ({ _tag: "Probability" as const, probability: wire.noul })),
+        ),
+    }),
+  ) as Effect.Effect<Decision.Answer, AiError.AiError>
+
+/**
+ * The cast is the generic boundary: a record assembled at runtime cannot
+ * prove it inhabits the caller's `JevAnswers<D>`. Each entry is decoded
+ * against the kind its own decision asked for, so the shape is checked even
+ * though the mapping is not.
+ */
+const answersOf = <D extends Decision.Decisions>(
+  decisions: D,
+  wire: WireResponse,
+): Effect.Effect<JevAnswers<D>, AiError.AiError> =>
+  pipe(
+    Record.toEntries(decisions),
+    Effect.forEach(([name, decision]) => {
+      const raw = wire.answers[name]
+      return raw === undefined
+        ? Effect.fail(missing(name))
+        : Effect.map(answerFor(name, decision, raw), (answer) => [name, answer] as const)
+    }),
+    Effect.map((entries) => Object.fromEntries(entries) as JevAnswers<D>),
+  )
+
+// ---------------------------------------------------------------------------
+// HTTP
+// ---------------------------------------------------------------------------
+
+const transportFailure = (cause: unknown): AiError.AiError =>
+  new AiError.Unavailable({ provider: "typesafe-ai", raw: cause })
+
+const httpStatusError = (status: number, body: string): AiError.AiError => {
+  const provider = "typesafe-ai"
+  const raw = body
+  if (status === 429) return new AiError.RateLimited({ provider, raw })
+  if (status === 408 || status === 504) return new AiError.Timeout({ provider, raw })
+  if (status === 401) return new AiError.AuthFailed({ provider, subtype: "auth", raw })
+  if (status === 403) return new AiError.AuthFailed({ provider, subtype: "permission", raw })
+  if (status === 402) return new AiError.AuthFailed({ provider, subtype: "billing", raw })
+  if (status === 413) return new AiError.ContextLengthExceeded({ provider, raw })
+  if (status >= 500) return new AiError.Unavailable({ provider, status, raw })
+  return new AiError.InvalidRequest({ provider, raw })
+}
+
+const baseUrl = (config: Config): string => config.baseUrl ?? "https://api.typesafe.ai"
+
+const postSystemOne = (
+  config: Config,
+  body: WireBody,
+): Effect.Effect<WireResponse, AiError.AiError, HttpClient.HttpClient> =>
+  Effect.gen(function* () {
+    const client = yield* HttpClient.HttpClient
+    const httpRequest = HttpClientRequest.post(`${baseUrl(config)}/v1/systemone`).pipe(
+      HttpClientRequest.bearerToken(config.apiKey),
+      HttpClientRequest.bodyJsonUnsafe(body),
+    )
+    const response = yield* client.execute(httpRequest).pipe(Effect.mapError(transportFailure))
+    if (response.status >= 400) {
+      const text = yield* response.text.pipe(Effect.orElseSucceed(() => ""))
+      return yield* httpStatusError(response.status, text)
+    }
+    const json = yield* response.json.pipe(Effect.mapError(transportFailure))
+    return yield* Schema.decodeUnknownEffect(WireResponse)(json).pipe(
+      Effect.mapError(transportFailure),
+    )
+  })
+
+const decideImpl =
+  (config: Config) =>
+  <A, D extends Decision.Decisions>(
+    definition: Decision.Definition<A, D>,
+    request: JevDecideRequest<A>,
+  ): Effect.Effect<JevDecideResponse<D>, AiError.AiError, HttpClient.HttpClient> =>
+    Effect.gen(function* () {
+      if (Record.isEmptyRecord(definition.decisions)) {
+        return yield* Effect.fail(
+          new AiError.InvalidRequest({
+            provider: "typesafe-ai",
+            param: "decisions",
+            raw: "a definition must carry at least one decision",
+          }),
+        )
+      }
+      // A schema that rejects the input is the caller's bug, not a wire fault.
+      const state = yield* Schema.encodeEffect(definition.inputSchema)(request.input).pipe(
+        Effect.mapError(
+          (cause) =>
+            new AiError.InvalidRequest({ provider: "typesafe-ai", param: "input", raw: cause }),
+        ),
+      )
+      const wire = yield* postSystemOne(config, {
+        model: request.model,
+        state,
+        questions: Record.map(definition.decisions, questionToWire),
+      })
+      const answers = yield* answersOf(definition.decisions, wire)
+      return {
+        answers,
+        usage: {
+          ...(wire.usage?.input_tokens !== undefined && { inputTokens: wire.usage.input_tokens }),
+          ...(wire.usage?.output_tokens !== undefined && {
+            outputTokens: wire.usage.output_tokens,
+          }),
+        },
+      }
+    })
+
+// ---------------------------------------------------------------------------
+// Constructors
+// ---------------------------------------------------------------------------
+
+/** Build a `JevService` value. For Layer-based setup, prefer {@link layer}. */
+export const make = (config: Config): Effect.Effect<JevService, never, HttpClient.HttpClient> =>
+  Effect.map(HttpClient.HttpClient, (client) => ({
+    decide: (definition, request) =>
+      decideImpl(config)(definition, request).pipe(
+        Effect.provideService(HttpClient.HttpClient, client),
+      ),
+  }))
+
+/**
+ * Layer registering both the provider-typed `Jev` tag and the generic
+ * `DecisionModel` tag over one implementation. `JevAnswers<D>` includes
+ * `Answers<D>`, so the generic registration forwards directly.
+ */
+export const layer = (
+  config: Config,
+): Layer.Layer<Jev | DecisionModel, never, HttpClient.HttpClient> => {
+  const typed = Layer.effect(Jev, make(config))
+  const generic = Layer.effect(
+    DecisionModel,
+    Effect.map(make(config), (service): DecisionModelService => ({
+      decide: (definition, request) => service.decide(definition, request),
+    })),
+  )
+  return Layer.merge(typed, generic)
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * as Jev from "./Jev.js"
+export * from "./models.js"

package/src/models.ts

@@ -0,0 +1,19 @@
+/**
+ * Jev model identifiers.
+ *
+ * - `jev-latest`: most recent stable release, the SDK default.
+ * - `jev-preview`: currently identical to `jev-latest`.
+ * - `jev-1.13.0`: pinned.
+ *
+ * 64k tokens per request, of which ~32k for the encoded input plus the
+ * longest single decision. Text only.
+ *
+ * The `(string & {})` tail accepts any string so new releases work without
+ * an SDK update.
+ */
+export type JevModel =
+  | "jev-latest"
+  | "jev-preview"
+  | "jev-1.13.0"
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  | (string & {})