@effect-uai/responses 0.2.0 → 0.4.0

package/dist/streamEvents.mjs

@@ -0,0 +1,170 @@
+import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
+import { WireOutputItem, WireResponseCompleted, turnFromCompleted } from "./codec.mjs";
+import { Match, Schema } from "effect";
+//#region src/streamEvents.ts
+var streamEvents_exports = /* @__PURE__ */ __exportAll({
+	KnownProviderEvent: () => KnownProviderEvent,
+	ProviderEvent: () => ProviderEvent,
+	eventToDeltas: () => eventToDeltas,
+	makeCallIdLookup: () => makeCallIdLookup
+});
+const OutputItemAdded = Schema.Struct({
+	type: Schema.Literal("response.output_item.added"),
+	item: WireOutputItem
+});
+const OutputTextDelta = Schema.Struct({
+	type: Schema.Literal("response.output_text.delta"),
+	delta: Schema.String
+});
+const FunctionArgsDelta = Schema.Struct({
+	type: Schema.Literal("response.function_call_arguments.delta"),
+	item_id: Schema.String,
+	delta: Schema.String
+});
+const ReasoningTextDelta = Schema.Struct({
+	type: Schema.Literal("response.reasoning_text.delta"),
+	delta: Schema.String
+});
+const ReasoningSummaryDelta = Schema.Struct({
+	type: Schema.Literal("response.reasoning_summary_text.delta"),
+	delta: Schema.String
+});
+const RefusalDelta = Schema.Struct({
+	type: Schema.Literal("response.refusal.delta"),
+	delta: Schema.String
+});
+const RefusalDone = Schema.Struct({
+	type: Schema.Literal("response.refusal.done"),
+	refusal: Schema.optional(Schema.String)
+});
+const Completed = Schema.Struct({
+	type: Schema.Literal("response.completed"),
+	response: WireResponseCompleted
+});
+const Incomplete = Schema.Struct({
+	type: Schema.Literal("response.incomplete"),
+	response: WireResponseCompleted
+});
+const Failed = Schema.Struct({
+	type: Schema.Literal("response.failed"),
+	response: WireResponseCompleted
+});
+const ErrorEvent = Schema.Struct({
+	type: Schema.Literal("error"),
+	message: Schema.optional(Schema.String),
+	code: Schema.optional(Schema.String)
+});
+/**
+* Catch-all variant for wire events that fail to decode against any known
+* schema, plus events that fail to JSON-parse. The decoder never produces
+* this directly - it's synthesized by `sseEventToProviderEvent` when
+* `decodeKnown` fails.
+*/
+const Unknown = Schema.Struct({
+	type: Schema.Literal("_unknown"),
+	raw: Schema.Unknown
+});
+/**
+* Internal: union of variants we actually know how to decode from the wire.
+* Used as the decode target; failures are caught and re-emitted as `Unknown`.
+*/
+const KnownProviderEvent = Schema.Union([
+	OutputItemAdded,
+	OutputTextDelta,
+	FunctionArgsDelta,
+	ReasoningTextDelta,
+	ReasoningSummaryDelta,
+	RefusalDelta,
+	RefusalDone,
+	Completed,
+	Incomplete,
+	Failed,
+	ErrorEvent
+]);
+/**
+* Public: every event the native stream can emit. Discriminated on `type`.
+* The `_unknown` branch closes the cardinality so downstream `Match.exhaustive`
+* cannot silently miss a wire event we didn't model.
+*/
+const ProviderEvent = Schema.Union([
+	OutputItemAdded,
+	OutputTextDelta,
+	FunctionArgsDelta,
+	ReasoningTextDelta,
+	ReasoningSummaryDelta,
+	RefusalDelta,
+	RefusalDone,
+	Completed,
+	Incomplete,
+	Failed,
+	ErrorEvent,
+	Unknown
+]);
+const makeCallIdLookup = () => {
+	const map = /* @__PURE__ */ new Map();
+	return {
+		resolve: (id) => map.get(id),
+		remember: (id, callId) => {
+			map.set(id, callId);
+		}
+	};
+};
+/**
+* Translate a decoded provider event into zero-or-more `TurnEvent`s.
+* Mutates `lookup` to record `(item_id → call_id)` from `output_item.added`
+* so subsequent `function_call_arguments.delta` events can be tagged with
+* the right call id.
+*/
+const eventToDeltas = (event, lookup) => Match.value(event).pipe(Match.discriminatorsExhaustive("type")({
+	"response.output_item.added": ({ item }) => {
+		if (item.type !== "function_call") return [];
+		if (item.id !== void 0) lookup.remember(item.id, item.call_id);
+		return [{
+			type: "tool_call_start",
+			call_id: item.call_id,
+			name: item.name
+		}];
+	},
+	"response.output_text.delta": ({ delta }) => [{
+		type: "text_delta",
+		text: delta
+	}],
+	"response.function_call_arguments.delta": ({ item_id, delta }) => {
+		const call_id = lookup.resolve(item_id);
+		return call_id === void 0 ? [] : [{
+			type: "tool_call_args_delta",
+			call_id,
+			delta
+		}];
+	},
+	"response.reasoning_text.delta": ({ delta }) => [{
+		type: "reasoning_delta",
+		text: delta,
+		kind: "trace"
+	}],
+	"response.reasoning_summary_text.delta": ({ delta }) => [{
+		type: "reasoning_delta",
+		text: delta,
+		kind: "summary"
+	}],
+	"response.refusal.delta": ({ delta }) => [{
+		type: "refusal_delta",
+		text: delta
+	}],
+	"response.refusal.done": () => [],
+	"response.completed": ({ response }) => [{
+		type: "turn_complete",
+		turn: turnFromCompleted(response)
+	}],
+	"response.incomplete": ({ response }) => [{
+		type: "turn_complete",
+		turn: turnFromCompleted(response)
+	}],
+	"response.failed": () => [],
+	error: () => [],
+	_unknown: () => []
+}));
+//#endregion
+export { KnownProviderEvent, ProviderEvent, eventToDeltas, makeCallIdLookup, streamEvents_exports as t };
+
+//# sourceMappingURL=streamEvents.mjs.map

package/dist/streamEvents.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"streamEvents.mjs","names":[],"sources":["../src/streamEvents.ts"],"sourcesContent":["import { Match, Schema } from \"effect\"\nimport type { TurnEvent } from \"@effect-uai/core/Turn\"\nimport { WireOutputItem, WireResponseCompleted, turnFromCompleted } from \"./codec.js\"\n\n// ---------------------------------------------------------------------------\n// Schemas for the SSE event payloads we care about. The Responses API ships\n// many event types; we model only the ones that map to a `TurnEvent`. All\n// others are silently ignored at the dispatch site.\n// ---------------------------------------------------------------------------\n\nconst OutputItemAdded = Schema.Struct({\n  type: Schema.Literal(\"response.output_item.added\"),\n  item: WireOutputItem,\n})\n\nconst OutputTextDelta = Schema.Struct({\n  type: Schema.Literal(\"response.output_text.delta\"),\n  delta: Schema.String,\n})\n\nconst FunctionArgsDelta = Schema.Struct({\n  type: Schema.Literal(\"response.function_call_arguments.delta\"),\n  item_id: Schema.String,\n  delta: Schema.String,\n})\n\nconst ReasoningTextDelta = Schema.Struct({\n  type: Schema.Literal(\"response.reasoning_text.delta\"),\n  delta: Schema.String,\n})\n\nconst ReasoningSummaryDelta = Schema.Struct({\n  type: Schema.Literal(\"response.reasoning_summary_text.delta\"),\n  delta: Schema.String,\n})\n\nconst RefusalDelta = Schema.Struct({\n  type: Schema.Literal(\"response.refusal.delta\"),\n  delta: Schema.String,\n})\n\nconst RefusalDone = Schema.Struct({\n  type: Schema.Literal(\"response.refusal.done\"),\n  refusal: Schema.optional(Schema.String),\n})\n\nconst Completed = Schema.Struct({\n  type: Schema.Literal(\"response.completed\"),\n  response: WireResponseCompleted,\n})\n\nconst Incomplete = Schema.Struct({\n  type: Schema.Literal(\"response.incomplete\"),\n  response: WireResponseCompleted,\n})\n\nconst Failed = Schema.Struct({\n  type: Schema.Literal(\"response.failed\"),\n  response: WireResponseCompleted,\n})\n\nconst ErrorEvent = Schema.Struct({\n  type: Schema.Literal(\"error\"),\n  message: Schema.optional(Schema.String),\n  code: Schema.optional(Schema.String),\n})\n\n/**\n * Catch-all variant for wire events that fail to decode against any known\n * schema, plus events that fail to JSON-parse. The decoder never produces\n * this directly - it's synthesized by `sseEventToProviderEvent` when\n * `decodeKnown` fails.\n */\nconst Unknown = Schema.Struct({\n  type: Schema.Literal(\"_unknown\"),\n  raw: Schema.Unknown,\n})\n\n/**\n * Internal: union of variants we actually know how to decode from the wire.\n * Used as the decode target; failures are caught and re-emitted as `Unknown`.\n */\nexport const KnownProviderEvent = Schema.Union([\n  OutputItemAdded,\n  OutputTextDelta,\n  FunctionArgsDelta,\n  ReasoningTextDelta,\n  ReasoningSummaryDelta,\n  RefusalDelta,\n  RefusalDone,\n  Completed,\n  Incomplete,\n  Failed,\n  ErrorEvent,\n])\n\n/**\n * Public: every event the native stream can emit. Discriminated on `type`.\n * The `_unknown` branch closes the cardinality so downstream `Match.exhaustive`\n * cannot silently miss a wire event we didn't model.\n */\nexport const ProviderEvent = Schema.Union([\n  OutputItemAdded,\n  OutputTextDelta,\n  FunctionArgsDelta,\n  ReasoningTextDelta,\n  ReasoningSummaryDelta,\n  RefusalDelta,\n  RefusalDone,\n  Completed,\n  Incomplete,\n  Failed,\n  ErrorEvent,\n  Unknown,\n])\nexport type ProviderEvent = typeof ProviderEvent.Type\n\n// `call_id` lookup for `function_call_arguments.delta`. The SSE event\n// references the *item id*, not the call id; we keep a small map populated\n// from the `output_item.added` events.\nexport type CallIdLookup = {\n  readonly resolve: (itemId: string) => string | undefined\n  readonly remember: (itemId: string, callId: string) => void\n}\n\nexport const makeCallIdLookup = (): CallIdLookup => {\n  const map = new Map<string, string>()\n  return {\n    resolve: (id) => map.get(id),\n    remember: (id, callId) => {\n      map.set(id, callId)\n    },\n  }\n}\n\n/**\n * Translate a decoded provider event into zero-or-more `TurnEvent`s.\n * Mutates `lookup` to record `(item_id → call_id)` from `output_item.added`\n * so subsequent `function_call_arguments.delta` events can be tagged with\n * the right call id.\n */\nexport const eventToDeltas = (\n  event: ProviderEvent,\n  lookup: CallIdLookup,\n): ReadonlyArray<TurnEvent> =>\n  Match.value(event).pipe(\n    Match.discriminatorsExhaustive(\"type\")({\n      \"response.output_item.added\": ({ item }) => {\n        if (item.type !== \"function_call\") return []\n        if (item.id !== undefined) lookup.remember(item.id, item.call_id)\n        return [\n          {\n            type: \"tool_call_start\" as const,\n            call_id: item.call_id,\n            name: item.name,\n          },\n        ]\n      },\n      \"response.output_text.delta\": ({ delta }) => [{ type: \"text_delta\" as const, text: delta }],\n      \"response.function_call_arguments.delta\": ({ item_id, delta }) => {\n        const call_id = lookup.resolve(item_id)\n        return call_id === undefined\n          ? []\n          : [{ type: \"tool_call_args_delta\" as const, call_id, delta }]\n      },\n      \"response.reasoning_text.delta\": ({ delta }) => [\n        { type: \"reasoning_delta\" as const, text: delta, kind: \"trace\" as const },\n      ],\n      \"response.reasoning_summary_text.delta\": ({ delta }) => [\n        { type: \"reasoning_delta\" as const, text: delta, kind: \"summary\" as const },\n      ],\n      \"response.refusal.delta\": ({ delta }) => [{ type: \"refusal_delta\" as const, text: delta }],\n      // Terminal marker for the refusal stream; the deltas already covered\n      // the text, so no canonical event is emitted here.\n      \"response.refusal.done\": () => [],\n      \"response.completed\": ({ response }) => [\n        { type: \"turn_complete\" as const, turn: turnFromCompleted(response) },\n      ],\n      // Incomplete = the model stopped early but produced a usable partial\n      // turn (max_tokens, content_filter, max_tool_calls, refusal). Same\n      // payload shape as `response.completed`; the stop_reason carries the\n      // reason.\n      \"response.incomplete\": ({ response }) => [\n        { type: \"turn_complete\" as const, turn: turnFromCompleted(response) },\n      ],\n      // Failed and error are surfaced separately as `AiError` by the stream\n      // pipeline, not as canonical events.\n      \"response.failed\": () => [],\n      error: () => [],\n      // No silent drops: unknown wire events flow through `streamNative` but\n      // produce no canonical delta. Step 3 (canonical `other` event) replaces\n      // this with a forwarded `other` delta on `TurnEvent`.\n      _unknown: () => [],\n    }),\n  )\n"],"mappings":";;;;;;;;;;AAUA,MAAM,kBAAkB,OAAO,OAAO;CACpC,MAAM,OAAO,QAAQ,6BAA6B;CAClD,MAAM;CACP,CAAC;AAEF,MAAM,kBAAkB,OAAO,OAAO;CACpC,MAAM,OAAO,QAAQ,6BAA6B;CAClD,OAAO,OAAO;CACf,CAAC;AAEF,MAAM,oBAAoB,OAAO,OAAO;CACtC,MAAM,OAAO,QAAQ,yCAAyC;CAC9D,SAAS,OAAO;CAChB,OAAO,OAAO;CACf,CAAC;AAEF,MAAM,qBAAqB,OAAO,OAAO;CACvC,MAAM,OAAO,QAAQ,gCAAgC;CACrD,OAAO,OAAO;CACf,CAAC;AAEF,MAAM,wBAAwB,OAAO,OAAO;CAC1C,MAAM,OAAO,QAAQ,wCAAwC;CAC7D,OAAO,OAAO;CACf,CAAC;AAEF,MAAM,eAAe,OAAO,OAAO;CACjC,MAAM,OAAO,QAAQ,yBAAyB;CAC9C,OAAO,OAAO;CACf,CAAC;AAEF,MAAM,cAAc,OAAO,OAAO;CAChC,MAAM,OAAO,QAAQ,wBAAwB;CAC7C,SAAS,OAAO,SAAS,OAAO,OAAO;CACxC,CAAC;AAEF,MAAM,YAAY,OAAO,OAAO;CAC9B,MAAM,OAAO,QAAQ,qBAAqB;CAC1C,UAAU;CACX,CAAC;AAEF,MAAM,aAAa,OAAO,OAAO;CAC/B,MAAM,OAAO,QAAQ,sBAAsB;CAC3C,UAAU;CACX,CAAC;AAEF,MAAM,SAAS,OAAO,OAAO;CAC3B,MAAM,OAAO,QAAQ,kBAAkB;CACvC,UAAU;CACX,CAAC;AAEF,MAAM,aAAa,OAAO,OAAO;CAC/B,MAAM,OAAO,QAAQ,QAAQ;CAC7B,SAAS,OAAO,SAAS,OAAO,OAAO;CACvC,MAAM,OAAO,SAAS,OAAO,OAAO;CACrC,CAAC;;;;;;;AAQF,MAAM,UAAU,OAAO,OAAO;CAC5B,MAAM,OAAO,QAAQ,WAAW;CAChC,KAAK,OAAO;CACb,CAAC;;;;;AAMF,MAAa,qBAAqB,OAAO,MAAM;CAC7C;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;;;;;;AAOF,MAAa,gBAAgB,OAAO,MAAM;CACxC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;AAWF,MAAa,yBAAuC;CAClD,MAAM,sBAAM,IAAI,KAAqB;AACrC,QAAO;EACL,UAAU,OAAO,IAAI,IAAI,GAAG;EAC5B,WAAW,IAAI,WAAW;AACxB,OAAI,IAAI,IAAI,OAAO;;EAEtB;;;;;;;;AASH,MAAa,iBACX,OACA,WAEA,MAAM,MAAM,MAAM,CAAC,KACjB,MAAM,yBAAyB,OAAO,CAAC;CACrC,+BAA+B,EAAE,WAAW;AAC1C,MAAI,KAAK,SAAS,gBAAiB,QAAO,EAAE;AAC5C,MAAI,KAAK,OAAO,KAAA,EAAW,QAAO,SAAS,KAAK,IAAI,KAAK,QAAQ;AACjE,SAAO,CACL;GACE,MAAM;GACN,SAAS,KAAK;GACd,MAAM,KAAK;GACZ,CACF;;CAEH,+BAA+B,EAAE,YAAY,CAAC;EAAE,MAAM;EAAuB,MAAM;EAAO,CAAC;CAC3F,2CAA2C,EAAE,SAAS,YAAY;EAChE,MAAM,UAAU,OAAO,QAAQ,QAAQ;AACvC,SAAO,YAAY,KAAA,IACf,EAAE,GACF,CAAC;GAAE,MAAM;GAAiC;GAAS;GAAO,CAAC;;CAEjE,kCAAkC,EAAE,YAAY,CAC9C;EAAE,MAAM;EAA4B,MAAM;EAAO,MAAM;EAAkB,CAC1E;CACD,0CAA0C,EAAE,YAAY,CACtD;EAAE,MAAM;EAA4B,MAAM;EAAO,MAAM;EAAoB,CAC5E;CACD,2BAA2B,EAAE,YAAY,CAAC;EAAE,MAAM;EAA0B,MAAM;EAAO,CAAC;CAG1F,+BAA+B,EAAE;CACjC,uBAAuB,EAAE,eAAe,CACtC;EAAE,MAAM;EAA0B,MAAM,kBAAkB,SAAS;EAAE,CACtE;CAKD,wBAAwB,EAAE,eAAe,CACvC;EAAE,MAAM;EAA0B,MAAM,kBAAkB,SAAS;EAAE,CACtE;CAGD,yBAAyB,EAAE;CAC3B,aAAa,EAAE;CAIf,gBAAgB,EAAE;CACnB,CAAC,CACH"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect-uai/responses",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "OpenAI Responses API provider for @effect-uai/core.",
   "keywords": [
     "ai",
@@ -20,6 +20,12 @@
     "url": "https://github.com/betalyra/effect-uai",
     "directory": "packages/providers/responses"
   },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
   "type": "module",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.mts",
@@ -27,25 +33,27 @@
     ".": {
       "types": "./dist/index.d.mts",
       "import": "./dist/index.mjs"
+    },
+    "./Responses": {
+      "types": "./dist/Responses.d.mts",
+      "import": "./dist/Responses.mjs"
+    },
+    "./OpenAIEmbedding": {
+      "types": "./dist/OpenAIEmbedding.d.mts",
+      "import": "./dist/OpenAIEmbedding.mjs"
     }
   },
-  "files": [
-    "dist",
-    "src",
-    "README.md",
-    "LICENSE"
-  ],
   "publishConfig": {
     "access": "public"
   },
-  "peerDependencies": {
-    "effect": "4.0.0-beta.57",
-    "@effect-uai/core": "^0.2.0"
-  },
   "devDependencies": {
     "effect": "4.0.0-beta.57",
     "typescript": "^6.0.3",
-    "@effect-uai/core": "0.2.0"
+    "@effect-uai/core": "0.4.0"
+  },
+  "peerDependencies": {
+    "@effect-uai/core": ">=0.2.0 <1",
+    "effect": "4.0.0-beta.57"
   },
   "scripts": {
     "build": "tsdown",

package/src/OpenAIEmbedding.ts

@@ -0,0 +1,275 @@
+import { Context, Effect, Layer, Redacted, Schema } from "effect"
+import { HttpClient, HttpClientRequest } from "effect/unstable/http"
+import * as AiError from "@effect-uai/core/AiError"
+import type { Embedding, EmbedContentPart, EmbedInput, Usage } from "@effect-uai/core/Embedding"
+import {
+  type CommonEmbedManyRequest,
+  type CommonEmbedRequest,
+  EmbeddingModel,
+  type EmbeddingModelService,
+  type EmbedManyResponse,
+  type EmbedResponse,
+} from "@effect-uai/core/EmbeddingModel"
+import type { OpenAIEmbeddingModel } from "./models.js"
+
+// ---------------------------------------------------------------------------
+// Public types
+// ---------------------------------------------------------------------------
+
+/**
+ * OpenAI's embedding API has no task-type semantics, so `task` is omitted
+ * from the request type intentionally - passing it would be a compile
+ * error. The generic `EmbeddingModel` registration accepts and silently
+ * ignores `task` from `CommonEmbedRequest`.
+ */
+export type OpenAIEmbedRequest = Omit<CommonEmbedRequest, "model" | "task"> & {
+  /** Narrows `CommonEmbedRequest.model` to the typed OpenAI union. */
+  readonly model: OpenAIEmbeddingModel
+}
+
+export type OpenAIEmbedManyRequest = Omit<OpenAIEmbedRequest, "input"> & {
+  readonly inputs: ReadonlyArray<EmbedInput>
+}
+
+export type OpenAIEmbeddingService = {
+  readonly embed: (request: OpenAIEmbedRequest) => Effect.Effect<EmbedResponse, AiError.AiError>
+  readonly embedMany: (
+    request: OpenAIEmbedManyRequest,
+  ) => Effect.Effect<EmbedManyResponse, AiError.AiError>
+}
+
+/**
+ * Provider-typed service tag. Yield this for OpenAI-typed embedding
+ * requests; yield the generic `EmbeddingModel` tag for provider-portable
+ * code. Both are registered by `layer`.
+ */
+export class OpenAIEmbedding extends Context.Service<OpenAIEmbedding, OpenAIEmbeddingService>()(
+  "@betalyra/effect-uai/providers/responses/OpenAIEmbedding",
+) {}
+
+export type Config = {
+  readonly apiKey: Redacted.Redacted
+  readonly baseUrl?: string
+}
+
+// ---------------------------------------------------------------------------
+// Codec - input flattening to the single string OpenAI expects
+// ---------------------------------------------------------------------------
+
+const imageRejected = (param: string): AiError.AiError =>
+  new AiError.InvalidRequest({
+    provider: "openai",
+    param,
+    raw: "OpenAI embeddings are text-only; pass a string or { text }",
+  })
+
+const partToText = (
+  param: string,
+  part: EmbedContentPart,
+): Effect.Effect<string, AiError.AiError> =>
+  "text" in part ? Effect.succeed(part.text) : Effect.fail(imageRejected(param))
+
+/**
+ * OpenAI accepts a single string per input. Pure-text `content[]` is
+ * concatenated with newlines (treats them as paragraphs of one document);
+ * any image part fails with `InvalidRequest`.
+ */
+const inputToString = (input: EmbedInput): Effect.Effect<string, AiError.AiError> => {
+  if (typeof input === "string") return Effect.succeed(input)
+  if ("text" in input) return Effect.succeed(input.text)
+  if ("image" in input) return Effect.fail(imageRejected("input.image"))
+  return Effect.forEach(input.content, (p, i) => partToText(`input.content[${i}].image`, p)).pipe(
+    Effect.map((texts) => texts.join("\n")),
+  )
+}
+
+// ---------------------------------------------------------------------------
+// Codec - request body
+// ---------------------------------------------------------------------------
+
+type WireBody = {
+  readonly model: string
+  readonly input: string | ReadonlyArray<string>
+  readonly dimensions?: number
+  readonly encoding_format?: "float" | "base64"
+}
+
+const buildSingleBody = (request: OpenAIEmbedRequest): Effect.Effect<WireBody, AiError.AiError> =>
+  inputToString(request.input).pipe(
+    Effect.map((input) => ({
+      model: request.model,
+      input,
+      ...(request.dimensions !== undefined && { dimensions: request.dimensions }),
+    })),
+  )
+
+const buildBatchBody = (
+  request: OpenAIEmbedManyRequest,
+): Effect.Effect<WireBody, AiError.AiError> =>
+  Effect.forEach(request.inputs, inputToString).pipe(
+    Effect.map((inputs) => ({
+      model: request.model,
+      input: inputs,
+      ...(request.dimensions !== undefined && { dimensions: request.dimensions }),
+    })),
+  )
+
+// ---------------------------------------------------------------------------
+// Codec - response
+// ---------------------------------------------------------------------------
+
+const WireEmbeddingItem = Schema.Struct({
+  embedding: Schema.Array(Schema.Number),
+  index: Schema.Number,
+})
+
+const WireUsage = Schema.Struct({
+  prompt_tokens: Schema.Number,
+  total_tokens: Schema.Number,
+})
+
+const WireResponse = Schema.Struct({
+  data: Schema.Array(WireEmbeddingItem),
+  model: Schema.String,
+  usage: WireUsage,
+})
+
+const valuesToEmbedding = (values: ReadonlyArray<number>): Embedding => ({
+  _tag: "float32",
+  vector: Float32Array.from(values),
+})
+
+// OpenAI returns `data[]` unsorted in theory; sort by `index` so caller
+// gets results in the order they passed inputs.
+const orderedEmbeddings = (
+  data: ReadonlyArray<{ readonly embedding: ReadonlyArray<number>; readonly index: number }>,
+): ReadonlyArray<Embedding> =>
+  [...data].sort((a, b) => a.index - b.index).map((item) => valuesToEmbedding(item.embedding))
+
+// ---------------------------------------------------------------------------
+// HTTP errors
+// ---------------------------------------------------------------------------
+
+const httpStatusError = (status: number, body: string): AiError.AiError => {
+  const provider = "openai"
+  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 transportFailure = (cause: unknown): AiError.AiError =>
+  new AiError.Unavailable({ provider: "openai", raw: cause })
+
+// ---------------------------------------------------------------------------
+// HTTP plumbing
+// ---------------------------------------------------------------------------
+
+const baseUrl = (cfg: Config): string => cfg.baseUrl ?? "https://api.openai.com/v1"
+
+const postEmbed = (
+  cfg: Config,
+  body: WireBody,
+): Effect.Effect<typeof WireResponse.Type, AiError.AiError, HttpClient.HttpClient> =>
+  Effect.gen(function* () {
+    const client = yield* HttpClient.HttpClient
+    const httpRequest = HttpClientRequest.post(`${baseUrl(cfg)}/embeddings`).pipe(
+      HttpClientRequest.bearerToken(cfg.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* Effect.fail(httpStatusError(response.status, text))
+    }
+    const json = yield* response.json.pipe(Effect.mapError(transportFailure))
+    return yield* Schema.decodeUnknownEffect(WireResponse)(json).pipe(
+      Effect.mapError(transportFailure),
+    )
+  })
+
+// ---------------------------------------------------------------------------
+// Service implementation
+// ---------------------------------------------------------------------------
+
+const usageOf = (u: typeof WireUsage.Type): Usage => ({ inputTokens: u.prompt_tokens })
+
+const embedImpl =
+  (cfg: Config) =>
+  (
+    request: OpenAIEmbedRequest,
+  ): Effect.Effect<EmbedResponse, AiError.AiError, HttpClient.HttpClient> =>
+    buildSingleBody(request).pipe(
+      Effect.flatMap((body) => postEmbed(cfg, body)),
+      Effect.flatMap((decoded) => {
+        const first = decoded.data[0]
+        if (first === undefined) {
+          return Effect.fail(transportFailure("OpenAI returned empty `data` array"))
+        }
+        return Effect.succeed<EmbedResponse>({
+          embedding: valuesToEmbedding(first.embedding),
+          usage: usageOf(decoded.usage),
+        })
+      }),
+    )
+
+const embedManyImpl =
+  (cfg: Config) =>
+  (
+    request: OpenAIEmbedManyRequest,
+  ): Effect.Effect<EmbedManyResponse, AiError.AiError, HttpClient.HttpClient> =>
+    buildBatchBody(request).pipe(
+      Effect.flatMap((body) => postEmbed(cfg, body)),
+      Effect.map(
+        (decoded): EmbedManyResponse => ({
+          embeddings: orderedEmbeddings(decoded.data),
+          usage: usageOf(decoded.usage),
+        }),
+      ),
+    )
+
+// ---------------------------------------------------------------------------
+// Constructors
+// ---------------------------------------------------------------------------
+
+/**
+ * Build an `OpenAIEmbeddingService` value. For Layer-based setup, prefer
+ * `layer`.
+ */
+export const make = (
+  cfg: Config,
+): Effect.Effect<OpenAIEmbeddingService, never, HttpClient.HttpClient> =>
+  Effect.map(HttpClient.HttpClient.asEffect(), (client) => ({
+    embed: (request) =>
+      embedImpl(cfg)(request).pipe(Effect.provideService(HttpClient.HttpClient, client)),
+    embedMany: (request) =>
+      embedManyImpl(cfg)(request).pipe(Effect.provideService(HttpClient.HttpClient, client)),
+  }))
+
+/**
+ * Layer that registers both the provider-specific `OpenAIEmbedding` tag
+ * and the generic `EmbeddingModel` tag, sharing one underlying
+ * implementation. The generic registration trusts the caller; invalid
+ * encodings produce an `InvalidRequest` from OpenAI's API.
+ */
+export const layer = (
+  cfg: Config,
+): Layer.Layer<OpenAIEmbedding | EmbeddingModel, never, HttpClient.HttpClient> => {
+  const typed = Layer.effect(OpenAIEmbedding, make(cfg))
+  const generic = Layer.effect(
+    EmbeddingModel,
+    Effect.map(
+      make(cfg),
+      (s): EmbeddingModelService => ({
+        embed: (req: CommonEmbedRequest) => s.embed(req as OpenAIEmbedRequest),
+        embedMany: (req: CommonEmbedManyRequest) => s.embedMany(req as OpenAIEmbedManyRequest),
+      }),
+    ),
+  )
+  return Layer.merge(typed, generic)
+}

package/src/Responses.ts

@@ -1,7 +1,6 @@
 import { Context, Effect, Layer, Match, Option, Redacted, Schema, Stream } from "effect"
 import { HttpClient, HttpClientRequest } from "effect/unstable/http"
 import * as AiError from "@effect-uai/core/AiError"
-import { matchType } from "@effect-uai/core/Match"
 import * as StructuredFormat from "@effect-uai/core/StructuredFormat"
 import {
   type CommonRequest,
@@ -23,7 +22,7 @@ import {
 // Public types
 // ---------------------------------------------------------------------------
 
-export interface ResponsesRequest extends Omit<CommonRequest, "model"> {
+export type ResponsesRequest = Omit<CommonRequest, "model"> & {
   /**
    * Narrows `CommonRequest.model` (`string`) to the typed `OpenAIModel`
    * literal union for autocomplete.
@@ -52,7 +51,7 @@ export interface ResponsesRequest extends Omit<CommonRequest, "model"> {
   readonly verbosity?: "low" | "medium" | "high"
 }
 
-export interface ResponsesService {
+export type ResponsesService = {
   /**
    * Stream the provider's native event vocabulary (post-SSE-decode).
    * Use this when you need full vendor fidelity. For provider-portable
@@ -86,7 +85,7 @@ export class Responses extends Context.Service<Responses, ResponsesService>()(
   "@betalyra/effect-uai/providers/responses/Responses",
 ) {}
 
-export interface Config {
+export type Config = {
   readonly apiKey: Redacted.Redacted
   readonly baseUrl?: string
 }
@@ -172,19 +171,18 @@ const makeUnknown = (raw: unknown): ProviderEvent => ({ type: "_unknown", raw })
  * and produce `Option.none`.
  */
 const eventToError = Match.type<ProviderEvent>().pipe(
-  matchType(
-    "error",
-    (e): AiError.AiError => new AiError.Unavailable({ provider: "responses", raw: e }),
-  ),
-  matchType("response.failed", (e): AiError.AiError => {
-    const code = e.response.error?.code
-    const message = e.response.error?.message
-    return new AiError.GenerationFailed({
-      provider: "responses",
-      ...(code !== undefined && code !== null && { code }),
-      ...(message !== undefined && message !== null && { message }),
-      raw: e,
-    })
+  Match.discriminators("type")({
+    error: (e): AiError.AiError => new AiError.Unavailable({ provider: "responses", raw: e }),
+    "response.failed": (e): AiError.AiError => {
+      const code = e.response.error?.code
+      const message = e.response.error?.message
+      return new AiError.GenerationFailed({
+        provider: "responses",
+        ...(code !== undefined && code !== null && { code }),
+        ...(message !== undefined && message !== null && { message }),
+        raw: e,
+      })
+    },
   }),
   Match.option,
 )