@effect-uai/core 0.1.0 → 0.3.0

package/dist/domain/AiError.d.mts

@@ -1,2 +1,2 @@
-import { a as Cancelled, c as GenerationFailed, d as RateLimited, f as Scope, i as AuthSubtype, l as IncompleteTurn, m as Unavailable, o as ContentFiltered, p as Timeout, r as AuthFailed, s as ContextLengthExceeded, t as AiError, u as InvalidRequest } from "../AiError-CqmYjXyx.mjs";
+import { a as Cancelled, c as GenerationFailed, d as RateLimited, f as Scope, i as AuthSubtype, l as IncompleteTurn, m as Unavailable, o as ContentFiltered, p as Timeout, r as AuthFailed, s as ContextLengthExceeded, t as AiError, u as InvalidRequest } from "../AiError-CBuPHVKA.mjs";
 export { AiError, AuthFailed, AuthSubtype, Cancelled, ContentFiltered, ContextLengthExceeded, GenerationFailed, IncompleteTurn, InvalidRequest, RateLimited, Scope, Timeout, Unavailable };

package/dist/domain/AiError.mjs

@@ -1,4 +1,4 @@
-import { t as __exportAll } from "../chunk-CfYAbeIz.mjs";
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
 import { Data } from "effect";
 //#region src/domain/AiError.ts
 var AiError_exports = /* @__PURE__ */ __exportAll({

package/dist/domain/Image.d.mts

@@ -0,0 +1,2 @@
+import { a as ImageUrlSource, c as imageBytes, d as isImageBytes, f as isImageUrl, i as ImageSource, l as imageUrl, n as ImageBytesSource, r as ImageMimeType, s as imageBase64, t as ImageBase64Source, u as isImageBase64 } from "../Image-BZmKfIdq.mjs";
+export { ImageBase64Source, ImageBytesSource, ImageMimeType, ImageSource, ImageUrlSource, imageBase64, imageBytes, imageUrl, isImageBase64, isImageBytes, isImageUrl };

package/dist/domain/Image.mjs

@@ -0,0 +1,58 @@
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { Schema } from "effect";
+//#region src/domain/Image.ts
+var Image_exports = /* @__PURE__ */ __exportAll({
+	ImageBase64Source: () => ImageBase64Source,
+	ImageBytesSource: () => ImageBytesSource,
+	ImageSource: () => ImageSource,
+	ImageUrlSource: () => ImageUrlSource,
+	imageBase64: () => imageBase64,
+	imageBytes: () => imageBytes,
+	imageUrl: () => imageUrl,
+	isImageBase64: () => isImageBase64,
+	isImageBytes: () => isImageBytes,
+	isImageUrl: () => isImageUrl
+});
+const ImageMimeTypeSchema = Schema.String;
+const ImageUrlSource = Schema.TaggedStruct("url", {
+	url: Schema.String,
+	mimeType: Schema.optional(ImageMimeTypeSchema)
+});
+const ImageBase64Source = Schema.TaggedStruct("base64", {
+	base64: Schema.String,
+	mimeType: ImageMimeTypeSchema
+});
+const ImageBytesSource = Schema.TaggedStruct("bytes", {
+	bytes: Schema.Uint8Array,
+	mimeType: ImageMimeTypeSchema
+});
+const ImageSource = Schema.Union([
+	ImageUrlSource,
+	ImageBase64Source,
+	ImageBytesSource
+]);
+const imageUrl = (url, mimeType) => mimeType !== void 0 ? {
+	_tag: "url",
+	url,
+	mimeType
+} : {
+	_tag: "url",
+	url
+};
+const imageBase64 = (base64, mimeType) => ({
+	_tag: "base64",
+	base64,
+	mimeType
+});
+const imageBytes = (bytes, mimeType) => ({
+	_tag: "bytes",
+	bytes,
+	mimeType
+});
+const isImageUrl = Schema.is(ImageUrlSource);
+const isImageBase64 = Schema.is(ImageBase64Source);
+const isImageBytes = Schema.is(ImageBytesSource);
+//#endregion
+export { ImageBase64Source, ImageBytesSource, ImageSource, ImageUrlSource, imageBase64, imageBytes, imageUrl, isImageBase64, isImageBytes, isImageUrl, Image_exports as t };
+
+//# sourceMappingURL=Image.mjs.map

package/dist/domain/Image.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Image.mjs","names":[],"sources":["../../src/domain/Image.ts"],"sourcesContent":["import { Schema } from \"effect\"\nimport type { MediaBase64, MediaBytes, MediaSource, MediaUrl } from \"./Media.js\"\n\n/**\n * Image MIME types AI providers typically accept. The first four are the\n * universal subset (Cohere v4, Voyage multimodal, Jina v4, Google\n * `gemini-embedding-2`); HEIC / HEIF are Google-specific. The\n * `(string & {})` tail keeps autocomplete on the literals while still\n * accepting any string, so a newly-supported format works without an\n * SDK update.\n */\nexport type ImageMimeType =\n  | \"image/png\"\n  | \"image/jpeg\"\n  | \"image/webp\"\n  | \"image/gif\"\n  | \"image/heic\"\n  | \"image/heif\"\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  | (string & {})\n\nconst ImageMimeTypeSchema = Schema.String as unknown as Schema.Schema<ImageMimeType>\n\nexport type ImageUrlSource = MediaUrl<ImageMimeType>\nexport type ImageBase64Source = MediaBase64<ImageMimeType>\nexport type ImageBytesSource = MediaBytes<ImageMimeType>\n\n/**\n * Where an image lives. Provider layers normalize across these:\n * `bytes` becomes a base64 data URI for OpenAI / Anthropic, an\n * `inlineData` part for Gemini, and a separate field for Cohere /\n * Voyage. URL constraints (must be HTTPS, must be public, …) are\n * provider-specific and validated at the layer, not in the type.\n */\nexport type ImageSource = MediaSource<ImageMimeType>\n\nexport const ImageUrlSource = Schema.TaggedStruct(\"url\", {\n  url: Schema.String,\n  mimeType: Schema.optional(ImageMimeTypeSchema),\n})\n\nexport const ImageBase64Source = Schema.TaggedStruct(\"base64\", {\n  base64: Schema.String,\n  mimeType: ImageMimeTypeSchema,\n})\n\nexport const ImageBytesSource = Schema.TaggedStruct(\"bytes\", {\n  bytes: Schema.Uint8Array,\n  mimeType: ImageMimeTypeSchema,\n})\n\nexport const ImageSource: Schema.Schema<ImageSource> = Schema.Union([\n  ImageUrlSource,\n  ImageBase64Source,\n  ImageBytesSource,\n]) as unknown as Schema.Schema<ImageSource>\n\nexport const imageUrl = (url: string, mimeType?: ImageMimeType): ImageUrlSource =>\n  mimeType !== undefined ? { _tag: \"url\", url, mimeType } : { _tag: \"url\", url }\n\nexport const imageBase64 = (base64: string, mimeType: ImageMimeType): ImageBase64Source => ({\n  _tag: \"base64\",\n  base64,\n  mimeType,\n})\n\nexport const imageBytes = (bytes: Uint8Array, mimeType: ImageMimeType): ImageBytesSource => ({\n  _tag: \"bytes\",\n  bytes,\n  mimeType,\n})\n\nexport const isImageUrl = Schema.is(ImageUrlSource)\nexport const isImageBase64 = Schema.is(ImageBase64Source)\nexport const isImageBytes = Schema.is(ImageBytesSource)\n"],"mappings":";;;;;;;;;;;;;;;AAqBA,MAAM,sBAAsB,OAAO;AAenC,MAAa,iBAAiB,OAAO,aAAa,OAAO;CACvD,KAAK,OAAO;CACZ,UAAU,OAAO,SAAS,oBAAoB;CAC/C,CAAC;AAEF,MAAa,oBAAoB,OAAO,aAAa,UAAU;CAC7D,QAAQ,OAAO;CACf,UAAU;CACX,CAAC;AAEF,MAAa,mBAAmB,OAAO,aAAa,SAAS;CAC3D,OAAO,OAAO;CACd,UAAU;CACX,CAAC;AAEF,MAAa,cAA0C,OAAO,MAAM;CAClE;CACA;CACA;CACD,CAAC;AAEF,MAAa,YAAY,KAAa,aACpC,aAAa,KAAA,IAAY;CAAE,MAAM;CAAO;CAAK;CAAU,GAAG;CAAE,MAAM;CAAO;CAAK;AAEhF,MAAa,eAAe,QAAgB,cAAgD;CAC1F,MAAM;CACN;CACA;CACD;AAED,MAAa,cAAc,OAAmB,cAA+C;CAC3F,MAAM;CACN;CACA;CACD;AAED,MAAa,aAAa,OAAO,GAAG,eAAe;AACnD,MAAa,gBAAgB,OAAO,GAAG,kBAAkB;AACzD,MAAa,eAAe,OAAO,GAAG,iBAAiB"}

package/dist/domain/Items.d.mts

@@ -1,2 +1,2 @@
-import { A as isFunctionCall, B as isUrlCitation, C as UrlCitation, D as isContainerFileCitation, E as functionCallOutput, F as isInputText, H as userText, I as isMessage, L as isOutputText, M as isImageBase64Source, N as isImageUrlSource, O as isFileCitation, P as isInputImage, R as isReasoning, S as StopReason, T as assistantText, V as systemText, _ as OutputText, a as FilePath, b as Refusal, c as ImageBase64Source, d as InputImage, f as InputText, g as Message, i as FileCitation, j as isFunctionCallOutput, k as isFilePath, l as ImageSource, m as Item, n as ContainerFileCitation, o as FunctionCall, p as InputTokensDetails, r as ContentBlock, s as FunctionCallOutput, t as Annotation, u as ImageUrlSource, v as OutputTokensDetails, w as Usage, x as Role, y as Reasoning, z as isRefusal } from "../Items-D1C2686t.mjs";
-export { Annotation, ContainerFileCitation, ContentBlock, FileCitation, FilePath, FunctionCall, FunctionCallOutput, ImageBase64Source, ImageSource, ImageUrlSource, InputImage, InputText, InputTokensDetails, Item, Message, OutputText, OutputTokensDetails, Reasoning, Refusal, Role, StopReason, UrlCitation, Usage, assistantText, functionCallOutput, isContainerFileCitation, isFileCitation, isFilePath, isFunctionCall, isFunctionCallOutput, isImageBase64Source, isImageUrlSource, isInputImage, isInputText, isMessage, isOutputText, isReasoning, isRefusal, isUrlCitation, systemText, userText };
+import { A as isInputText, C as functionCallOutput, D as isFunctionCall, E as isFilePath, F as isUrlCitation, I as systemText, L as userText, M as isOutputText, N as isReasoning, O as isFunctionCallOutput, P as isRefusal, S as assistantText, T as isFileCitation, _ as Refusal, a as FilePath, b as UrlCitation, c as InputImage, d as Item, g as Reasoning, h as OutputTokensDetails, i as FileCitation, j as isMessage, k as isInputImage, l as InputText, m as OutputText, n as ContainerFileCitation, o as FunctionCall, p as Message, r as ContentBlock, s as FunctionCallOutput, t as Annotation, u as InputTokensDetails, v as Role, w as isContainerFileCitation, x as Usage, y as StopReason } from "../Items-CB8Bo3FI.mjs";
+export { Annotation, ContainerFileCitation, ContentBlock, FileCitation, FilePath, FunctionCall, FunctionCallOutput, InputImage, InputText, InputTokensDetails, Item, Message, OutputText, OutputTokensDetails, Reasoning, Refusal, Role, StopReason, UrlCitation, Usage, assistantText, functionCallOutput, isContainerFileCitation, isFileCitation, isFilePath, isFunctionCall, isFunctionCallOutput, isInputImage, isInputText, isMessage, isOutputText, isReasoning, isRefusal, isUrlCitation, systemText, userText };

package/dist/domain/Items.mjs

@@ -1,4 +1,5 @@
-import { t as __exportAll } from "../chunk-CfYAbeIz.mjs";
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { ImageSource } from "./Image.mjs";
 import { Schema } from "effect";
 //#region src/domain/Items.ts
 var Items_exports = /* @__PURE__ */ __exportAll({
@@ -9,9 +10,6 @@ var Items_exports = /* @__PURE__ */ __exportAll({
 	FilePath: () => FilePath,
 	FunctionCall: () => FunctionCall,
 	FunctionCallOutput: () => FunctionCallOutput,
-	ImageBase64Source: () => ImageBase64Source,
-	ImageSource: () => ImageSource,
-	ImageUrlSource: () => ImageUrlSource,
 	InputImage: () => InputImage,
 	InputText: () => InputText,
 	InputTokensDetails: () => InputTokensDetails,
@@ -32,8 +30,6 @@ var Items_exports = /* @__PURE__ */ __exportAll({
 	isFilePath: () => isFilePath,
 	isFunctionCall: () => isFunctionCall,
 	isFunctionCallOutput: () => isFunctionCallOutput,
-	isImageBase64Source: () => isImageBase64Source,
-	isImageUrlSource: () => isImageUrlSource,
 	isInputImage: () => isInputImage,
 	isInputText: () => isInputText,
 	isMessage: () => isMessage,
@@ -49,31 +45,12 @@ const InputText = Schema.Struct({
 	text: Schema.String
 });
 /**
-* Where an image lives. `url` covers HTTP(S) URLs (the model fetches
-* them); `base64` covers inline bytes embedded in the request. Provider
-* encoders dispatch on `_tag`. File-id / uploaded-asset references are
-* provider-specific and stay out of this union for now.
-*/
-const ImageUrlSource = Schema.Struct({
-	_tag: Schema.Literal("url"),
-	url: Schema.String
-});
-/**
-* Inline image bytes. `data` is **already base64-encoded** (matches what
-* the wire formats expect; no double-encoding needed downstream).
-* `media_type` is the MIME type, e.g. `"image/png"`.
-*/
-const ImageBase64Source = Schema.Struct({
-	_tag: Schema.Literal("base64"),
-	media_type: Schema.String,
-	data: Schema.String
-});
-const ImageSource = Schema.Union([ImageUrlSource, ImageBase64Source]);
-const isImageUrlSource = (s) => s._tag === "url";
-const isImageBase64Source = (s) => s._tag === "base64";
-/**
 * User-provided image content block. Pair with `InputText` inside a
 * `Message.content` array to ask "what's in this image?" style questions.
+*
+* `source` is the cross-modality `ImageSource` from `domain/Image.ts` -
+* url, base64, or raw bytes. Provider codecs encode bytes to whatever
+* wire format the provider wants.
 */
 const InputImage = Schema.Struct({
 	type: Schema.Literal("input_image"),
@@ -109,10 +86,10 @@ const Annotation = Schema.Union([
 	ContainerFileCitation,
 	FilePath
 ]);
-const isUrlCitation = (a) => a.type === "url_citation";
-const isFileCitation = (a) => a.type === "file_citation";
-const isContainerFileCitation = (a) => a.type === "container_file_citation";
-const isFilePath = (a) => a.type === "file_path";
+const isUrlCitation = Schema.is(UrlCitation);
+const isFileCitation = Schema.is(FileCitation);
+const isContainerFileCitation = Schema.is(ContainerFileCitation);
+const isFilePath = Schema.is(FilePath);
 const OutputText = Schema.Struct({
 	type: Schema.Literal("output_text"),
 	text: Schema.String,
@@ -178,14 +155,14 @@ const Item = Schema.Union([
 	FunctionCallOutput,
 	Reasoning
 ]);
-const isInputText = (block) => block.type === "input_text";
-const isInputImage = (block) => block.type === "input_image";
-const isOutputText = (block) => block.type === "output_text";
-const isRefusal = (block) => block.type === "refusal";
-const isMessage = (item) => item.type === "message";
-const isFunctionCall = (item) => item.type === "function_call";
-const isFunctionCallOutput = (item) => item.type === "function_call_output";
-const isReasoning = (item) => item.type === "reasoning";
+const isInputText = Schema.is(InputText);
+const isInputImage = Schema.is(InputImage);
+const isOutputText = Schema.is(OutputText);
+const isRefusal = Schema.is(Refusal);
+const isMessage = Schema.is(Message);
+const isFunctionCall = Schema.is(FunctionCall);
+const isFunctionCallOutput = Schema.is(FunctionCallOutput);
+const isReasoning = Schema.is(Reasoning);
 const InputTokensDetails = Schema.Struct({ cached_tokens: Schema.optional(Schema.Number) });
 const OutputTokensDetails = Schema.Struct({ reasoning_tokens: Schema.optional(Schema.Number) });
 const Usage = Schema.Struct({
@@ -233,6 +210,6 @@ const functionCallOutput = (call_id, output) => ({
 	output
 });
 //#endregion
-export { Annotation, ContainerFileCitation, ContentBlock, FileCitation, FilePath, FunctionCall, FunctionCallOutput, ImageBase64Source, ImageSource, ImageUrlSource, InputImage, InputText, InputTokensDetails, Item, Message, OutputText, OutputTokensDetails, Reasoning, Refusal, Role, StopReason, UrlCitation, Usage, assistantText, functionCallOutput, isContainerFileCitation, isFileCitation, isFilePath, isFunctionCall, isFunctionCallOutput, isImageBase64Source, isImageUrlSource, isInputImage, isInputText, isMessage, isOutputText, isReasoning, isRefusal, isUrlCitation, systemText, Items_exports as t, userText };
+export { Annotation, ContainerFileCitation, ContentBlock, FileCitation, FilePath, FunctionCall, FunctionCallOutput, InputImage, InputText, InputTokensDetails, Item, Message, OutputText, OutputTokensDetails, Reasoning, Refusal, Role, StopReason, UrlCitation, Usage, assistantText, functionCallOutput, isContainerFileCitation, isFileCitation, isFilePath, isFunctionCall, isFunctionCallOutput, isInputImage, isInputText, isMessage, isOutputText, isReasoning, isRefusal, isUrlCitation, systemText, Items_exports as t, userText };
 
 //# sourceMappingURL=Items.mjs.map

package/dist/domain/Items.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Items.mjs","names":[],"sources":["../../src/domain/Items.ts"],"sourcesContent":["import { Schema } from \"effect\"\n\n// ---------------------------------------------------------------------------\n// Content blocks (inside Message.content)\n// ---------------------------------------------------------------------------\n\nexport const InputText = Schema.Struct({\n  type: Schema.Literal(\"input_text\"),\n  text: Schema.String,\n})\nexport type InputText = typeof InputText.Type\n\n/**\n * Where an image lives. `url` covers HTTP(S) URLs (the model fetches\n * them); `base64` covers inline bytes embedded in the request. Provider\n * encoders dispatch on `_tag`. File-id / uploaded-asset references are\n * provider-specific and stay out of this union for now.\n */\nexport const ImageUrlSource = Schema.Struct({\n  _tag: Schema.Literal(\"url\"),\n  url: Schema.String,\n})\nexport type ImageUrlSource = typeof ImageUrlSource.Type\n\n/**\n * Inline image bytes. `data` is **already base64-encoded** (matches what\n * the wire formats expect; no double-encoding needed downstream).\n * `media_type` is the MIME type, e.g. `\"image/png\"`.\n */\nexport const ImageBase64Source = Schema.Struct({\n  _tag: Schema.Literal(\"base64\"),\n  media_type: Schema.String,\n  data: Schema.String,\n})\nexport type ImageBase64Source = typeof ImageBase64Source.Type\n\nexport const ImageSource = Schema.Union([ImageUrlSource, ImageBase64Source])\nexport type ImageSource = typeof ImageSource.Type\n\nexport const isImageUrlSource = (s: ImageSource): s is ImageUrlSource => s._tag === \"url\"\nexport const isImageBase64Source = (s: ImageSource): s is ImageBase64Source => s._tag === \"base64\"\n\n/**\n * User-provided image content block. Pair with `InputText` inside a\n * `Message.content` array to ask \"what's in this image?\" style questions.\n */\nexport const InputImage = Schema.Struct({\n  type: Schema.Literal(\"input_image\"),\n  source: ImageSource,\n})\nexport type InputImage = typeof InputImage.Type\n\n// ---------------------------------------------------------------------------\n// Annotations - source / citation pointers attached to `output_text` blocks.\n// Mirrors OpenAI Responses API; other providers can omit or map onto these\n// shapes.\n// ---------------------------------------------------------------------------\n\nexport const UrlCitation = Schema.Struct({\n  type: Schema.Literal(\"url_citation\"),\n  url: Schema.String,\n  start_index: Schema.Number,\n  end_index: Schema.Number,\n  title: Schema.String,\n})\nexport type UrlCitation = typeof UrlCitation.Type\n\nexport const FileCitation = Schema.Struct({\n  type: Schema.Literal(\"file_citation\"),\n  file_id: Schema.String,\n  index: Schema.Number,\n})\nexport type FileCitation = typeof FileCitation.Type\n\nexport const ContainerFileCitation = Schema.Struct({\n  type: Schema.Literal(\"container_file_citation\"),\n  container_id: Schema.String,\n  file_id: Schema.String,\n  start_index: Schema.Number,\n  end_index: Schema.Number,\n})\nexport type ContainerFileCitation = typeof ContainerFileCitation.Type\n\nexport const FilePath = Schema.Struct({\n  type: Schema.Literal(\"file_path\"),\n  file_id: Schema.String,\n  index: Schema.Number,\n})\nexport type FilePath = typeof FilePath.Type\n\nexport const Annotation = Schema.Union([UrlCitation, FileCitation, ContainerFileCitation, FilePath])\nexport type Annotation = typeof Annotation.Type\n\nexport const isUrlCitation = (a: Annotation): a is UrlCitation => a.type === \"url_citation\"\nexport const isFileCitation = (a: Annotation): a is FileCitation => a.type === \"file_citation\"\nexport const isContainerFileCitation = (a: Annotation): a is ContainerFileCitation =>\n  a.type === \"container_file_citation\"\nexport const isFilePath = (a: Annotation): a is FilePath => a.type === \"file_path\"\n\nexport const OutputText = Schema.Struct({\n  type: Schema.Literal(\"output_text\"),\n  text: Schema.String,\n  annotations: Schema.optional(Schema.Array(Annotation)),\n})\nexport type OutputText = typeof OutputText.Type\n\n/**\n * Model-emitted refusal. Distinct from `output_text`: the model declined\n * to answer rather than producing normal output. Pair with\n * `stop_reason: \"refusal\"` on the surrounding `Turn`. Streamed via the\n * `refusal_delta` `TurnEvent`.\n */\nexport const Refusal = Schema.Struct({\n  type: Schema.Literal(\"refusal\"),\n  text: Schema.String,\n})\nexport type Refusal = typeof Refusal.Type\n\nexport const ContentBlock = Schema.Union([InputText, InputImage, OutputText, Refusal])\nexport type ContentBlock = typeof ContentBlock.Type\n\nexport const Role = Schema.Literals([\"user\", \"assistant\", \"system\"])\nexport type Role = typeof Role.Type\n\n// ---------------------------------------------------------------------------\n// Provider passthrough - every Item type carries this opaque slot.\n// The framework never reads or interprets it; provider modules decode\n// their own data via their own typed readers (see e.g.\n// the `@effect-uai/responses` package).\n// ---------------------------------------------------------------------------\n\nconst ProviderData = Schema.optional(Schema.Unknown)\n\n// ---------------------------------------------------------------------------\n// Items\n// ---------------------------------------------------------------------------\n\nexport const Message = Schema.Struct({\n  type: Schema.Literal(\"message\"),\n  role: Role,\n  content: Schema.Array(ContentBlock),\n  providerData: ProviderData,\n})\nexport type Message = typeof Message.Type\n\nexport const FunctionCall = Schema.Struct({\n  type: Schema.Literal(\"function_call\"),\n  call_id: Schema.String,\n  name: Schema.String,\n  // JSON-encoded arguments string, mirroring OpenAI Responses API\n  arguments: Schema.String,\n  providerData: ProviderData,\n})\nexport type FunctionCall = typeof FunctionCall.Type\n\nexport const FunctionCallOutput = Schema.Struct({\n  type: Schema.Literal(\"function_call_output\"),\n  call_id: Schema.String,\n  output: Schema.String,\n  providerData: ProviderData,\n})\nexport type FunctionCallOutput = typeof FunctionCallOutput.Type\n\n/**\n * Reasoning item - top-level, mirrors OpenAI Responses API. Common shape\n * across providers covers `summary` (human-readable text) and `signature`\n * (opaque round-trip blob - Anthropic's signed thinking, OpenAI's\n * encrypted_content, etc.). Provider-specific fields go in `providerData`.\n */\nexport const Reasoning = Schema.Struct({\n  type: Schema.Literal(\"reasoning\"),\n  id: Schema.optional(Schema.String),\n  summary: Schema.optional(Schema.String),\n  signature: Schema.optional(Schema.String),\n  providerData: ProviderData,\n})\nexport type Reasoning = typeof Reasoning.Type\n\nexport const Item = Schema.Union([Message, FunctionCall, FunctionCallOutput, Reasoning])\nexport type Item = typeof Item.Type\n\n// ---------------------------------------------------------------------------\n// Type guards\n// ---------------------------------------------------------------------------\n\nexport const isInputText = (block: ContentBlock): block is InputText => block.type === \"input_text\"\nexport const isInputImage = (block: ContentBlock): block is InputImage =>\n  block.type === \"input_image\"\nexport const isOutputText = (block: ContentBlock): block is OutputText =>\n  block.type === \"output_text\"\nexport const isRefusal = (block: ContentBlock): block is Refusal => block.type === \"refusal\"\n\nexport const isMessage = (item: Item): item is Message => item.type === \"message\"\nexport const isFunctionCall = (item: Item): item is FunctionCall => item.type === \"function_call\"\nexport const isFunctionCallOutput = (item: Item): item is FunctionCallOutput =>\n  item.type === \"function_call_output\"\nexport const isReasoning = (item: Item): item is Reasoning => item.type === \"reasoning\"\n\n// ---------------------------------------------------------------------------\n// Usage and stop reason\n// ---------------------------------------------------------------------------\n\nexport const InputTokensDetails = Schema.Struct({\n  cached_tokens: Schema.optional(Schema.Number),\n})\nexport type InputTokensDetails = typeof InputTokensDetails.Type\n\nexport const OutputTokensDetails = Schema.Struct({\n  reasoning_tokens: Schema.optional(Schema.Number),\n})\nexport type OutputTokensDetails = typeof OutputTokensDetails.Type\n\nexport const Usage = Schema.Struct({\n  input_tokens: Schema.optional(Schema.Number),\n  output_tokens: Schema.optional(Schema.Number),\n  total_tokens: Schema.optional(Schema.Number),\n  input_tokens_details: Schema.optional(InputTokensDetails),\n  output_tokens_details: Schema.optional(OutputTokensDetails),\n})\nexport type Usage = typeof Usage.Type\n\nexport const StopReason = Schema.Literals([\n  \"stop\",\n  \"tool_calls\",\n  \"max_tokens\",\n  \"refusal\",\n  /** Provider-side safety classifier flagged the output. */\n  \"content_filter\",\n  /** Server-enforced cap on tool calls per turn was hit. */\n  \"max_tool_calls\",\n])\nexport type StopReason = typeof StopReason.Type\n\n// ---------------------------------------------------------------------------\n// Helper constructors\n// ---------------------------------------------------------------------------\n\nexport const userText = (text: string): Message => ({\n  type: \"message\",\n  role: \"user\",\n  content: [{ type: \"input_text\", text }],\n})\n\nexport const systemText = (text: string): Message => ({\n  type: \"message\",\n  role: \"system\",\n  content: [{ type: \"input_text\", text }],\n})\n\nexport const assistantText = (text: string): Message => ({\n  type: \"message\",\n  role: \"assistant\",\n  content: [{ type: \"output_text\", text }],\n})\n\nexport const functionCallOutput = (call_id: string, output: string): FunctionCallOutput => ({\n  type: \"function_call_output\",\n  call_id,\n  output,\n})\n"],"mappings":"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"}
+{"version":3,"file":"Items.mjs","names":[],"sources":["../../src/domain/Items.ts"],"sourcesContent":["import { Schema } from \"effect\"\nimport { ImageSource } from \"./Image.js\"\n\n// ---------------------------------------------------------------------------\n// Content blocks (inside Message.content)\n// ---------------------------------------------------------------------------\n\nexport const InputText = Schema.Struct({\n  type: Schema.Literal(\"input_text\"),\n  text: Schema.String,\n})\nexport type InputText = typeof InputText.Type\n\n/**\n * User-provided image content block. Pair with `InputText` inside a\n * `Message.content` array to ask \"what's in this image?\" style questions.\n *\n * `source` is the cross-modality `ImageSource` from `domain/Image.ts` -\n * url, base64, or raw bytes. Provider codecs encode bytes to whatever\n * wire format the provider wants.\n */\nexport const InputImage = Schema.Struct({\n  type: Schema.Literal(\"input_image\"),\n  source: ImageSource,\n})\nexport type InputImage = typeof InputImage.Type\n\n// ---------------------------------------------------------------------------\n// Annotations - source / citation pointers attached to `output_text` blocks.\n// Mirrors OpenAI Responses API; other providers can omit or map onto these\n// shapes.\n// ---------------------------------------------------------------------------\n\nexport const UrlCitation = Schema.Struct({\n  type: Schema.Literal(\"url_citation\"),\n  url: Schema.String,\n  start_index: Schema.Number,\n  end_index: Schema.Number,\n  title: Schema.String,\n})\nexport type UrlCitation = typeof UrlCitation.Type\n\nexport const FileCitation = Schema.Struct({\n  type: Schema.Literal(\"file_citation\"),\n  file_id: Schema.String,\n  index: Schema.Number,\n})\nexport type FileCitation = typeof FileCitation.Type\n\nexport const ContainerFileCitation = Schema.Struct({\n  type: Schema.Literal(\"container_file_citation\"),\n  container_id: Schema.String,\n  file_id: Schema.String,\n  start_index: Schema.Number,\n  end_index: Schema.Number,\n})\nexport type ContainerFileCitation = typeof ContainerFileCitation.Type\n\nexport const FilePath = Schema.Struct({\n  type: Schema.Literal(\"file_path\"),\n  file_id: Schema.String,\n  index: Schema.Number,\n})\nexport type FilePath = typeof FilePath.Type\n\nexport const Annotation = Schema.Union([UrlCitation, FileCitation, ContainerFileCitation, FilePath])\nexport type Annotation = typeof Annotation.Type\n\nexport const isUrlCitation = Schema.is(UrlCitation)\nexport const isFileCitation = Schema.is(FileCitation)\nexport const isContainerFileCitation = Schema.is(ContainerFileCitation)\nexport const isFilePath = Schema.is(FilePath)\n\nexport const OutputText = Schema.Struct({\n  type: Schema.Literal(\"output_text\"),\n  text: Schema.String,\n  annotations: Schema.optional(Schema.Array(Annotation)),\n})\nexport type OutputText = typeof OutputText.Type\n\n/**\n * Model-emitted refusal. Distinct from `output_text`: the model declined\n * to answer rather than producing normal output. Pair with\n * `stop_reason: \"refusal\"` on the surrounding `Turn`. Streamed via the\n * `refusal_delta` `TurnEvent`.\n */\nexport const Refusal = Schema.Struct({\n  type: Schema.Literal(\"refusal\"),\n  text: Schema.String,\n})\nexport type Refusal = typeof Refusal.Type\n\nexport const ContentBlock = Schema.Union([InputText, InputImage, OutputText, Refusal])\nexport type ContentBlock = typeof ContentBlock.Type\n\nexport const Role = Schema.Literals([\"user\", \"assistant\", \"system\"])\nexport type Role = typeof Role.Type\n\n// ---------------------------------------------------------------------------\n// Provider passthrough - every Item type carries this opaque slot.\n// The framework never reads or interprets it; provider modules decode\n// their own data via their own typed readers (see e.g.\n// the `@effect-uai/responses` package).\n// ---------------------------------------------------------------------------\n\nconst ProviderData = Schema.optional(Schema.Unknown)\n\n// ---------------------------------------------------------------------------\n// Items\n// ---------------------------------------------------------------------------\n\nexport const Message = Schema.Struct({\n  type: Schema.Literal(\"message\"),\n  role: Role,\n  content: Schema.Array(ContentBlock),\n  providerData: ProviderData,\n})\nexport type Message = typeof Message.Type\n\nexport const FunctionCall = Schema.Struct({\n  type: Schema.Literal(\"function_call\"),\n  call_id: Schema.String,\n  name: Schema.String,\n  // JSON-encoded arguments string, mirroring OpenAI Responses API\n  arguments: Schema.String,\n  providerData: ProviderData,\n})\nexport type FunctionCall = typeof FunctionCall.Type\n\nexport const FunctionCallOutput = Schema.Struct({\n  type: Schema.Literal(\"function_call_output\"),\n  call_id: Schema.String,\n  output: Schema.String,\n  providerData: ProviderData,\n})\nexport type FunctionCallOutput = typeof FunctionCallOutput.Type\n\n/**\n * Reasoning item - top-level, mirrors OpenAI Responses API. Common shape\n * across providers covers `summary` (human-readable text) and `signature`\n * (opaque round-trip blob - Anthropic's signed thinking, OpenAI's\n * encrypted_content, etc.). Provider-specific fields go in `providerData`.\n */\nexport const Reasoning = Schema.Struct({\n  type: Schema.Literal(\"reasoning\"),\n  id: Schema.optional(Schema.String),\n  summary: Schema.optional(Schema.String),\n  signature: Schema.optional(Schema.String),\n  providerData: ProviderData,\n})\nexport type Reasoning = typeof Reasoning.Type\n\nexport const Item = Schema.Union([Message, FunctionCall, FunctionCallOutput, Reasoning])\nexport type Item = typeof Item.Type\n\n// ---------------------------------------------------------------------------\n// Type guards\n// ---------------------------------------------------------------------------\n\nexport const isInputText = Schema.is(InputText)\nexport const isInputImage = Schema.is(InputImage)\nexport const isOutputText = Schema.is(OutputText)\nexport const isRefusal = Schema.is(Refusal)\n\nexport const isMessage = Schema.is(Message)\nexport const isFunctionCall = Schema.is(FunctionCall)\nexport const isFunctionCallOutput = Schema.is(FunctionCallOutput)\nexport const isReasoning = Schema.is(Reasoning)\n\n// ---------------------------------------------------------------------------\n// Usage and stop reason\n// ---------------------------------------------------------------------------\n\nexport const InputTokensDetails = Schema.Struct({\n  cached_tokens: Schema.optional(Schema.Number),\n})\nexport type InputTokensDetails = typeof InputTokensDetails.Type\n\nexport const OutputTokensDetails = Schema.Struct({\n  reasoning_tokens: Schema.optional(Schema.Number),\n})\nexport type OutputTokensDetails = typeof OutputTokensDetails.Type\n\nexport const Usage = Schema.Struct({\n  input_tokens: Schema.optional(Schema.Number),\n  output_tokens: Schema.optional(Schema.Number),\n  total_tokens: Schema.optional(Schema.Number),\n  input_tokens_details: Schema.optional(InputTokensDetails),\n  output_tokens_details: Schema.optional(OutputTokensDetails),\n})\nexport type Usage = typeof Usage.Type\n\nexport const StopReason = Schema.Literals([\n  \"stop\",\n  \"tool_calls\",\n  \"max_tokens\",\n  \"refusal\",\n  /** Provider-side safety classifier flagged the output. */\n  \"content_filter\",\n  /** Server-enforced cap on tool calls per turn was hit. */\n  \"max_tool_calls\",\n])\nexport type StopReason = typeof StopReason.Type\n\n// ---------------------------------------------------------------------------\n// Helper constructors\n// ---------------------------------------------------------------------------\n\nexport const userText = (text: string): Message => ({\n  type: \"message\",\n  role: \"user\",\n  content: [{ type: \"input_text\", text }],\n})\n\nexport const systemText = (text: string): Message => ({\n  type: \"message\",\n  role: \"system\",\n  content: [{ type: \"input_text\", text }],\n})\n\nexport const assistantText = (text: string): Message => ({\n  type: \"message\",\n  role: \"assistant\",\n  content: [{ type: \"output_text\", text }],\n})\n\nexport const functionCallOutput = (call_id: string, output: string): FunctionCallOutput => ({\n  type: \"function_call_output\",\n  call_id,\n  output,\n})\n"],"mappings":"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"}

package/dist/domain/Media.d.mts

@@ -0,0 +1,2 @@
+import { c as isMediaUrl, i as MediaUrl, n as MediaBytes, o as isMediaBase64, r as MediaSource, s as isMediaBytes, t as MediaBase64 } from "../Media-D_CpcM1Z.mjs";
+export { MediaBase64, MediaBytes, MediaSource, MediaUrl, isMediaBase64, isMediaBytes, isMediaUrl };

package/dist/domain/Media.mjs

@@ -0,0 +1,14 @@
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+//#region src/domain/Media.ts
+var Media_exports = /* @__PURE__ */ __exportAll({
+	isMediaBase64: () => isMediaBase64,
+	isMediaBytes: () => isMediaBytes,
+	isMediaUrl: () => isMediaUrl
+});
+const isMediaUrl = (s) => s._tag === "url";
+const isMediaBase64 = (s) => s._tag === "base64";
+const isMediaBytes = (s) => s._tag === "bytes";
+//#endregion
+export { isMediaBase64, isMediaBytes, isMediaUrl, Media_exports as t };
+
+//# sourceMappingURL=Media.mjs.map

package/dist/domain/Media.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Media.mjs","names":[],"sources":["../../src/domain/Media.ts"],"sourcesContent":["/**\n * Cross-modality media reference shape.\n *\n * Every \"media at rest\" reference - image, audio, video, document - is one\n * of three variants:\n *\n *   - `url`    : a remote address (HTTP, GCS, etc.). The model fetches it.\n *               `mimeType` is optional - servers usually set Content-Type.\n *               Some providers (Gemini `fileData`) want it explicit.\n *\n *   - `base64` : an inline base64-encoded payload. Always carries a\n *               `mimeType` so the consumer knows how to decode.\n *\n *   - `bytes`  : raw `Uint8Array`. Provider layers normalize to base64 or\n *               multipart upload at the wire boundary - users don't need\n *               to encode themselves.\n *\n * Per-modality files (`Image.ts`, future `Audio.ts` / `Video.ts` /\n * `Document.ts`) instantiate this shape with their typed MIME union to\n * get autocomplete on common formats while keeping the structural type\n * uniform across modalities.\n *\n * Streaming media (live mic feed, streaming TTS playback) is *not*\n * modeled here. Streams carry effect parameters (`Stream<A, E, R>`) and\n * lifecycle (Scope, cancellation) that don't apply to media at rest. The\n * complementary type lives alongside this one as `*Stream` in each\n * per-modality file when those modalities land.\n *\n * Provider-uploaded asset references (OpenAI Files `file_id`, Gemini\n * Files API URIs, Anthropic file IDs) are also out of scope here -\n * they're a separate union (`FileRef`) added when needed.\n */\n\nexport type MediaUrl<M extends string = string> = {\n  readonly _tag: \"url\"\n  readonly url: string\n  readonly mimeType?: M\n}\n\nexport type MediaBase64<M extends string = string> = {\n  readonly _tag: \"base64\"\n  readonly base64: string\n  readonly mimeType: M\n}\n\nexport type MediaBytes<M extends string = string> = {\n  readonly _tag: \"bytes\"\n  readonly bytes: Uint8Array\n  readonly mimeType: M\n}\n\nexport type MediaSource<M extends string = string> = MediaUrl<M> | MediaBase64<M> | MediaBytes<M>\n\nexport const isMediaUrl = <M extends string>(s: MediaSource<M>): s is MediaUrl<M> =>\n  s._tag === \"url\"\n\nexport const isMediaBase64 = <M extends string>(s: MediaSource<M>): s is MediaBase64<M> =>\n  s._tag === \"base64\"\n\nexport const isMediaBytes = <M extends string>(s: MediaSource<M>): s is MediaBytes<M> =>\n  s._tag === \"bytes\"\n"],"mappings":";;;;;;;AAqDA,MAAa,cAAgC,MAC3C,EAAE,SAAS;AAEb,MAAa,iBAAmC,MAC9C,EAAE,SAAS;AAEb,MAAa,gBAAkC,MAC7C,EAAE,SAAS"}

package/dist/domain/Turn.d.mts

@@ -1,2 +1,2 @@
-import { a as TurnEvent, c as cursor, d as reasonings, f as textDeltas, i as Turn, l as functionCalls, n as InteractionEvent, p as toStructured, r as RefusalRejected, s as assistantMessages, t as Cursor, u as isTurnComplete } from "../Turn-rlTfuHaQ.mjs";
-export { Cursor, InteractionEvent, RefusalRejected, Turn, TurnEvent, assistantMessages, cursor, functionCalls, isTurnComplete, reasonings, textDeltas, toStructured };
+import { c as functionCalls, d as textDeltas, f as toStructured, i as TurnEvent, l as isTurnComplete, n as RefusalRejected, o as appendTurn, r as Turn, s as assistantMessages, t as InteractionEvent, u as reasonings } from "../Turn-OPaILVIB.mjs";
+export { InteractionEvent, RefusalRejected, Turn, TurnEvent, appendTurn, assistantMessages, functionCalls, isTurnComplete, reasonings, textDeltas, toStructured };

package/dist/domain/Turn.mjs

@@ -1,4 +1,4 @@
-import { t as __exportAll } from "../chunk-CfYAbeIz.mjs";
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
 import { Item, StopReason, Usage, isOutputText, isRefusal } from "./Items.mjs";
 import { parseJson } from "../structured-format/StructuredFormat.mjs";
 import { Data, Effect, Result, Schema, Stream, pipe } from "effect";
@@ -6,8 +6,8 @@ import { Data, Effect, Result, Schema, Stream, pipe } from "effect";
 var Turn_exports = /* @__PURE__ */ __exportAll({
 	RefusalRejected: () => RefusalRejected,
 	Turn: () => Turn,
+	appendTurn: () => appendTurn,
 	assistantMessages: () => assistantMessages,
-	cursor: () => cursor,
 	functionCalls: () => functionCalls,
 	isTurnComplete: () => isTurnComplete,
 	reasonings: () => reasonings,
@@ -29,13 +29,17 @@ const functionCalls = (turn) => turn.items.filter((i) => i.type === "function_ca
 const reasonings = (turn) => turn.items.filter((i) => i.type === "reasoning");
 const assistantMessages = (turn) => turn.items.filter((i) => i.type === "message" && i.role === "assistant");
 /**
-* Build a `Cursor<S>` from a state record and the just-completed turn.
-* Extends `state.history` with `turn.items` and stamps the turn.
+* Append a completed turn and optional follow-up items to a state record's
+* history. Recipes use this at the point where structured tool results are
+* converted to model-facing `FunctionCallOutput`s.
 */
-const cursor = (state, turn) => ({
+const appendTurn = (state, turn, items = []) => ({
 	...state,
-	history: [...state.history, ...turn.items],
-	turn
+	history: [
+		...state.history,
+		...turn.items,
+		...items
+	]
 });
 /**
 * Project a `TurnEvent` stream onto its `text_delta` payloads. Other
@@ -77,6 +81,6 @@ const lastAssistantContent = (turn) => {
 */
 const toStructured = (turn, format) => pipe(lastAssistantContent(turn), ({ text, refused }) => refused ? Effect.fail(new RefusalRejected({ turn })) : parseJson(format)(text));
 //#endregion
-export { RefusalRejected, Turn, assistantMessages, cursor, functionCalls, isTurnComplete, reasonings, Turn_exports as t, textDeltas, toStructured };
+export { RefusalRejected, Turn, appendTurn, assistantMessages, functionCalls, isTurnComplete, reasonings, Turn_exports as t, textDeltas, toStructured };
 
 //# sourceMappingURL=Turn.mjs.map

package/dist/domain/Turn.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Turn.mjs","names":["StructuredFormat.parseJson"],"sources":["../../src/domain/Turn.ts"],"sourcesContent":["import { Data, Effect, Result, Schema, Stream, pipe } from \"effect\"\nimport * as StructuredFormat from \"../structured-format/StructuredFormat.js\"\nimport {\n  FunctionCall,\n  FunctionCallOutput,\n  Item,\n  isOutputText,\n  isRefusal,\n  Message,\n  Reasoning,\n  StopReason,\n  Usage,\n} from \"./Items.js\"\n\n/**\n * The result of a single LLM generation. A turn produces zero or more items\n * (typically one assistant message and zero or more function_call items)\n * and reports usage + a stop reason.\n */\nexport const Turn = Schema.Struct({\n  items: Schema.Array(Item),\n  usage: Usage,\n  stop_reason: StopReason,\n})\nexport type Turn = typeof Turn.Type\n\n/**\n * Canonical events emitted while a single turn is being generated. Most\n * variants are streaming deltas (text, reasoning, tool-call args); the\n * terminal `turn_complete` carries the assembled `Turn`. Lifecycle members\n * aren't deltas, hence the union name.\n */\nexport type TurnEvent =\n  | { readonly type: \"text_delta\"; readonly text: string }\n  | {\n      readonly type: \"reasoning_delta\"\n      readonly text: string\n      /**\n       * `trace` is the model's raw chain-of-thought; `summary` is a\n       * model-written summary intended for display. OpenAI Responses emits\n       * both as separate wire events; Anthropic and Gemini only emit\n       * `trace`. Consumers who just want any reasoning text match once;\n       * those who want only summaries filter `kind === \"summary\"`.\n       */\n      readonly kind: \"trace\" | \"summary\"\n    }\n  /**\n   * The model declined to answer. `text` is the (streamed) explanation.\n   * Distinct from the failure channel: a refusal is normal model output and\n   * the stream still completes with `turn_complete`. OpenAI Responses emits\n   * this; Anthropic surfaces refusals via `stop_reason`, and Gemini collapses\n   * them into `finishReason: SAFETY` - both go without a `refusal_delta`.\n   */\n  | { readonly type: \"refusal_delta\"; readonly text: string }\n  | { readonly type: \"tool_call_start\"; readonly call_id: string; readonly name: string }\n  | { readonly type: \"tool_call_args_delta\"; readonly call_id: string; readonly delta: string }\n  /**\n   * Mid-stream cumulative usage. Carries the full `Usage` (including cache\n   * token fields when the provider surfaces them) so consumers can drive\n   * live budget / cost tracking without waiting for `turn_complete`.\n   * Anthropic emits this on `message_start` and `message_delta`; other\n   * providers may not emit any `usage_update` and only deliver usage via\n   * `turn_complete.turn.usage`.\n   */\n  | { readonly type: \"usage_update\"; readonly usage: Usage }\n  | { readonly type: \"turn_complete\"; readonly turn: Turn }\n\n/**\n * What flows out of an agent loop body to its consumer per turn: every\n * `TurnEvent` the provider emits (including the terminal `turn_complete`\n * carrying the assembled `Turn`), plus the output of any tool the loop ran.\n * Both variants carry a `type` discriminator.\n */\nexport type InteractionEvent = TurnEvent | FunctionCallOutput\n\nexport const isTurnComplete = (d: TurnEvent): d is Extract<TurnEvent, { type: \"turn_complete\" }> =>\n  d.type === \"turn_complete\"\n\nexport const functionCalls = (turn: Turn): ReadonlyArray<FunctionCall> =>\n  turn.items.filter((i): i is FunctionCall => i.type === \"function_call\")\n\nexport const reasonings = (turn: Turn): ReadonlyArray<Reasoning> =>\n  turn.items.filter((i): i is Reasoning => i.type === \"reasoning\")\n\nexport const assistantMessages = (turn: Turn): ReadonlyArray<Message> =>\n  turn.items.filter((i): i is Message => i.type === \"message\" && i.role === \"assistant\")\n\n/**\n * State stamped with the just-completed `Turn`. Recipes use this as the\n * intermediate value between \"turn lands\" and \"compute next state\": extend\n * `state.history` with the turn's items, and keep the assembled turn\n * around for stop-reason / usage / function-call inspection.\n *\n * Generic over the recipe's state shape - any record carrying a\n * `history: ReadonlyArray<Item>` field works.\n */\nexport type Cursor<S> = S & { readonly turn: Turn }\n\n/**\n * Build a `Cursor<S>` from a state record and the just-completed turn.\n * Extends `state.history` with `turn.items` and stamps the turn.\n */\nexport const cursor = <S extends { readonly history: ReadonlyArray<Item> }>(\n  state: S,\n  turn: Turn,\n): Cursor<S> => ({\n  ...state,\n  history: [...state.history, ...turn.items],\n  turn,\n})\n\n// ---------------------------------------------------------------------------\n// Stream operators\n// ---------------------------------------------------------------------------\n\n/**\n * Project a `TurnEvent` stream onto its `text_delta` payloads. Other\n * variants are dropped. Composes with `Lines.lines` +\n * `decodeJsonLines` for prompted-JSONL streaming.\n */\nexport const textDeltas = <E, R>(\n  self: Stream.Stream<TurnEvent, E, R>,\n): Stream.Stream<string, E, R> =>\n  self.pipe(\n    Stream.filterMap((ev) =>\n      ev.type === \"text_delta\" ? Result.succeed(ev.text) : Result.failVoid,\n    ),\n  )\n\n// ---------------------------------------------------------------------------\n// Structured-output integration\n// ---------------------------------------------------------------------------\n\n/**\n * The assistant message on the just-completed turn was a refusal block,\n * not an `output_text` payload. Returned by `toStructured` to short-circuit\n * decoding before `JSON.parse` / schema validation runs.\n */\nexport class RefusalRejected extends Data.TaggedError(\"RefusalRejected\")<{\n  readonly turn: Turn\n}> {}\n\nconst lastAssistantContent = (turn: Turn): { readonly text: string; readonly refused: boolean } => {\n  const assistants = assistantMessages(turn)\n  const last = assistants[assistants.length - 1]\n  if (last === undefined) return { text: \"\", refused: false }\n  if (last.content.some(isRefusal)) return { text: \"\", refused: true }\n  const text = last.content\n    .filter(isOutputText)\n    .map((b) => b.text)\n    .join(\"\")\n  return { text, refused: false }\n}\n\n/**\n * Validate a completed `Turn` against a `StructuredFormat`. Concatenates\n * `output_text` blocks on the last assistant message, then runs\n * `JSON.parse` + the format's schema validation.\n *\n * Three failure modes:\n * - `RefusalRejected` — the assistant emitted a refusal block.\n * - `JsonParseError` — the assembled text wasn't valid JSON.\n * - `StructuredDecodeError` — the JSON didn't match the schema.\n */\nexport const toStructured = <A>(\n  turn: Turn,\n  format: StructuredFormat.StructuredFormat<A>,\n): Effect.Effect<\n  A,\n  RefusalRejected | StructuredFormat.JsonParseError | StructuredFormat.StructuredDecodeError\n> =>\n  pipe(lastAssistantContent(turn), ({ text, refused }) =>\n    refused ? Effect.fail(new RefusalRejected({ turn })) : StructuredFormat.parseJson(format)(text),\n  )\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAmBA,MAAa,OAAO,OAAO,OAAO;CAChC,OAAO,OAAO,MAAM,KAAK;CACzB,OAAO;CACP,aAAa;CACd,CAAC;AAoDF,MAAa,kBAAkB,MAC7B,EAAE,SAAS;AAEb,MAAa,iBAAiB,SAC5B,KAAK,MAAM,QAAQ,MAAyB,EAAE,SAAS,gBAAgB;AAEzE,MAAa,cAAc,SACzB,KAAK,MAAM,QAAQ,MAAsB,EAAE,SAAS,YAAY;AAElE,MAAa,qBAAqB,SAChC,KAAK,MAAM,QAAQ,MAAoB,EAAE,SAAS,aAAa,EAAE,SAAS,YAAY;;;;;AAiBxF,MAAa,UACX,OACA,UACe;CACf,GAAG;CACH,SAAS,CAAC,GAAG,MAAM,SAAS,GAAG,KAAK,MAAM;CAC1C;CACD;;;;;;AAWD,MAAa,cACX,SAEA,KAAK,KACH,OAAO,WAAW,OAChB,GAAG,SAAS,eAAe,OAAO,QAAQ,GAAG,KAAK,GAAG,OAAO,SAC7D,CACF;;;;;;AAWH,IAAa,kBAAb,cAAqC,KAAK,YAAY,kBAAkB,CAErE;AAEH,MAAM,wBAAwB,SAAqE;CACjG,MAAM,aAAa,kBAAkB,KAAK;CAC1C,MAAM,OAAO,WAAW,WAAW,SAAS;AAC5C,KAAI,SAAS,KAAA,EAAW,QAAO;EAAE,MAAM;EAAI,SAAS;EAAO;AAC3D,KAAI,KAAK,QAAQ,KAAK,UAAU,CAAE,QAAO;EAAE,MAAM;EAAI,SAAS;EAAM;AAKpE,QAAO;EAAE,MAJI,KAAK,QACf,OAAO,aAAa,CACpB,KAAK,MAAM,EAAE,KAAK,CAClB,KAAK,GACK;EAAE,SAAS;EAAO;;;;;;;;;;;;AAajC,MAAa,gBACX,MACA,WAKA,KAAK,qBAAqB,KAAK,GAAG,EAAE,MAAM,cACxC,UAAU,OAAO,KAAK,IAAI,gBAAgB,EAAE,MAAM,CAAC,CAAC,GAAGA,UAA2B,OAAO,CAAC,KAAK,CAChG"}
+{"version":3,"file":"Turn.mjs","names":["StructuredFormat.parseJson"],"sources":["../../src/domain/Turn.ts"],"sourcesContent":["import { Data, Effect, Result, Schema, Stream, pipe } from \"effect\"\nimport * as StructuredFormat from \"../structured-format/StructuredFormat.js\"\nimport {\n  FunctionCall,\n  FunctionCallOutput,\n  Item,\n  isOutputText,\n  isRefusal,\n  Message,\n  Reasoning,\n  StopReason,\n  Usage,\n} from \"./Items.js\"\n\n/**\n * The result of a single LLM generation. A turn produces zero or more items\n * (typically one assistant message and zero or more function_call items)\n * and reports usage + a stop reason.\n */\nexport const Turn = Schema.Struct({\n  items: Schema.Array(Item),\n  usage: Usage,\n  stop_reason: StopReason,\n})\nexport type Turn = typeof Turn.Type\n\n/**\n * Canonical events emitted while a single turn is being generated. Most\n * variants are streaming deltas (text, reasoning, tool-call args); the\n * terminal `turn_complete` carries the assembled `Turn`. Lifecycle members\n * aren't deltas, hence the union name.\n */\nexport type TurnEvent =\n  | { readonly type: \"text_delta\"; readonly text: string }\n  | {\n      readonly type: \"reasoning_delta\"\n      readonly text: string\n      /**\n       * `trace` is the model's raw chain-of-thought; `summary` is a\n       * model-written summary intended for display. OpenAI Responses emits\n       * both as separate wire events; Anthropic and Gemini only emit\n       * `trace`. Consumers who just want any reasoning text match once;\n       * those who want only summaries filter `kind === \"summary\"`.\n       */\n      readonly kind: \"trace\" | \"summary\"\n    }\n  /**\n   * The model declined to answer. `text` is the (streamed) explanation.\n   * Distinct from the failure channel: a refusal is normal model output and\n   * the stream still completes with `turn_complete`. OpenAI Responses emits\n   * this; Anthropic surfaces refusals via `stop_reason`, and Gemini collapses\n   * them into `finishReason: SAFETY` - both go without a `refusal_delta`.\n   */\n  | { readonly type: \"refusal_delta\"; readonly text: string }\n  | { readonly type: \"tool_call_start\"; readonly call_id: string; readonly name: string }\n  | { readonly type: \"tool_call_args_delta\"; readonly call_id: string; readonly delta: string }\n  /**\n   * Mid-stream cumulative usage. Carries the full `Usage` (including cache\n   * token fields when the provider surfaces them) so consumers can drive\n   * live budget / cost tracking without waiting for `turn_complete`.\n   * Anthropic emits this on `message_start` and `message_delta`; other\n   * providers may not emit any `usage_update` and only deliver usage via\n   * `turn_complete.turn.usage`.\n   */\n  | { readonly type: \"usage_update\"; readonly usage: Usage }\n  | { readonly type: \"turn_complete\"; readonly turn: Turn }\n\n/**\n * What flows out of an agent loop body to its consumer per turn: every\n * `TurnEvent` the provider emits (including the terminal `turn_complete`\n * carrying the assembled `Turn`), plus the output of any tool the loop ran.\n * Both variants carry a `type` discriminator.\n */\nexport type InteractionEvent = TurnEvent | FunctionCallOutput\n\nexport const isTurnComplete = (d: TurnEvent): d is Extract<TurnEvent, { type: \"turn_complete\" }> =>\n  d.type === \"turn_complete\"\n\nexport const functionCalls = (turn: Turn): ReadonlyArray<FunctionCall> =>\n  turn.items.filter((i): i is FunctionCall => i.type === \"function_call\")\n\nexport const reasonings = (turn: Turn): ReadonlyArray<Reasoning> =>\n  turn.items.filter((i): i is Reasoning => i.type === \"reasoning\")\n\nexport const assistantMessages = (turn: Turn): ReadonlyArray<Message> =>\n  turn.items.filter((i): i is Message => i.type === \"message\" && i.role === \"assistant\")\n\n/**\n * Append a completed turn and optional follow-up items to a state record's\n * history. Recipes use this at the point where structured tool results are\n * converted to model-facing `FunctionCallOutput`s.\n */\nexport const appendTurn = <S extends { readonly history: ReadonlyArray<Item> }>(\n  state: S,\n  turn: Turn,\n  items: ReadonlyArray<Item> = [],\n): S => ({\n  ...state,\n  history: [...state.history, ...turn.items, ...items],\n})\n\n// ---------------------------------------------------------------------------\n// Stream operators\n// ---------------------------------------------------------------------------\n\n/**\n * Project a `TurnEvent` stream onto its `text_delta` payloads. Other\n * variants are dropped. Composes with `Lines.lines` +\n * `decodeJsonLines` for prompted-JSONL streaming.\n */\nexport const textDeltas = <E, R>(\n  self: Stream.Stream<TurnEvent, E, R>,\n): Stream.Stream<string, E, R> =>\n  self.pipe(\n    Stream.filterMap((ev) =>\n      ev.type === \"text_delta\" ? Result.succeed(ev.text) : Result.failVoid,\n    ),\n  )\n\n// ---------------------------------------------------------------------------\n// Structured-output integration\n// ---------------------------------------------------------------------------\n\n/**\n * The assistant message on the just-completed turn was a refusal block,\n * not an `output_text` payload. Returned by `toStructured` to short-circuit\n * decoding before `JSON.parse` / schema validation runs.\n */\nexport class RefusalRejected extends Data.TaggedError(\"RefusalRejected\")<{\n  readonly turn: Turn\n}> {}\n\nconst lastAssistantContent = (turn: Turn): { readonly text: string; readonly refused: boolean } => {\n  const assistants = assistantMessages(turn)\n  const last = assistants[assistants.length - 1]\n  if (last === undefined) return { text: \"\", refused: false }\n  if (last.content.some(isRefusal)) return { text: \"\", refused: true }\n  const text = last.content\n    .filter(isOutputText)\n    .map((b) => b.text)\n    .join(\"\")\n  return { text, refused: false }\n}\n\n/**\n * Validate a completed `Turn` against a `StructuredFormat`. Concatenates\n * `output_text` blocks on the last assistant message, then runs\n * `JSON.parse` + the format's schema validation.\n *\n * Three failure modes:\n * - `RefusalRejected` — the assistant emitted a refusal block.\n * - `JsonParseError` — the assembled text wasn't valid JSON.\n * - `StructuredDecodeError` — the JSON didn't match the schema.\n */\nexport const toStructured = <A>(\n  turn: Turn,\n  format: StructuredFormat.StructuredFormat<A>,\n): Effect.Effect<\n  A,\n  RefusalRejected | StructuredFormat.JsonParseError | StructuredFormat.StructuredDecodeError\n> =>\n  pipe(lastAssistantContent(turn), ({ text, refused }) =>\n    refused ? Effect.fail(new RefusalRejected({ turn })) : StructuredFormat.parseJson(format)(text),\n  )\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAmBA,MAAa,OAAO,OAAO,OAAO;CAChC,OAAO,OAAO,MAAM,KAAK;CACzB,OAAO;CACP,aAAa;CACd,CAAC;AAoDF,MAAa,kBAAkB,MAC7B,EAAE,SAAS;AAEb,MAAa,iBAAiB,SAC5B,KAAK,MAAM,QAAQ,MAAyB,EAAE,SAAS,gBAAgB;AAEzE,MAAa,cAAc,SACzB,KAAK,MAAM,QAAQ,MAAsB,EAAE,SAAS,YAAY;AAElE,MAAa,qBAAqB,SAChC,KAAK,MAAM,QAAQ,MAAoB,EAAE,SAAS,aAAa,EAAE,SAAS,YAAY;;;;;;AAOxF,MAAa,cACX,OACA,MACA,QAA6B,EAAE,MACxB;CACP,GAAG;CACH,SAAS;EAAC,GAAG,MAAM;EAAS,GAAG,KAAK;EAAO,GAAG;EAAM;CACrD;;;;;;AAWD,MAAa,cACX,SAEA,KAAK,KACH,OAAO,WAAW,OAChB,GAAG,SAAS,eAAe,OAAO,QAAQ,GAAG,KAAK,GAAG,OAAO,SAC7D,CACF;;;;;;AAWH,IAAa,kBAAb,cAAqC,KAAK,YAAY,kBAAkB,CAErE;AAEH,MAAM,wBAAwB,SAAqE;CACjG,MAAM,aAAa,kBAAkB,KAAK;CAC1C,MAAM,OAAO,WAAW,WAAW,SAAS;AAC5C,KAAI,SAAS,KAAA,EAAW,QAAO;EAAE,MAAM;EAAI,SAAS;EAAO;AAC3D,KAAI,KAAK,QAAQ,KAAK,UAAU,CAAE,QAAO;EAAE,MAAM;EAAI,SAAS;EAAM;AAKpE,QAAO;EAAE,MAJI,KAAK,QACf,OAAO,aAAa,CACpB,KAAK,MAAM,EAAE,KAAK,CAClB,KAAK,GACK;EAAE,SAAS;EAAO;;;;;;;;;;;;AAajC,MAAa,gBACX,MACA,WAKA,KAAK,qBAAqB,KAAK,GAAG,EAAE,MAAM,cACxC,UAAU,OAAO,KAAK,IAAI,gBAAgB,EAAE,MAAM,CAAC,CAAC,GAAGA,UAA2B,OAAO,CAAC,KAAK,CAChG"}

package/dist/embedding-model/Embedding.d.mts

@@ -0,0 +1,107 @@
+import { i as ImageSource } from "../Image-BZmKfIdq.mjs";
+
+//#region src/embedding-model/Embedding.d.ts
+declare namespace Embedding_d_exports {
+  export { BinaryEmbedding, EmbedContentPart, EmbedInput, Embedding, Float32Embedding, Int8Embedding, MultivectorEmbedding, SparseEmbedding, Usage, isBinary, isFloat32, isInt8, isMultivector, isSparse };
+}
+/**
+ * One part of a mixed text+image input. Used inside `EmbedInput.content[]`
+ * for providers that accept interleaved modalities in a single embed call
+ * (Cohere v4, Voyage multimodal, Jina v4, Google `gemini-embedding-2`).
+ */
+type EmbedContentPart = {
+  readonly text: string;
+} | {
+  readonly image: ImageSource;
+};
+/**
+ * What you embed. The `string` shorthand covers the common text-only case;
+ * structured variants exist for image-only and mixed-modality inputs.
+ *
+ * Not every provider accepts every variant: text-only providers (OpenAI,
+ * Mixedbread today) handle `string` and `{ text }`; multimodal providers
+ * (Google, Jina v4, Voyage multimodal, Cohere v4) handle all four. A
+ * provider layer rejects shapes it can't encode as `AiError.InvalidRequest`.
+ */
+type EmbedInput = string | {
+  readonly text: string;
+} | {
+  readonly image: ImageSource;
+} | {
+  readonly content: ReadonlyArray<EmbedContentPart>;
+};
+/** Dense float32 vector. The default representation across all providers. */
+type Float32Embedding = {
+  readonly _tag: "float32";
+  readonly vector: Float32Array;
+};
+/**
+ * Dense int8-quantized vector. ~4x smaller than float32 with minimal
+ * recall loss on most benchmarks.
+ */
+type Int8Embedding = {
+  readonly _tag: "int8";
+  readonly vector: Int8Array;
+};
+/**
+ * Dense binary-quantized vector. One bit per dimension, packed into bytes.
+ * ~32x smaller than float32; meaningful recall loss but useful for hot
+ * indexes paired with a float32 reranker pass.
+ */
+type BinaryEmbedding = {
+  readonly _tag: "binary";
+  readonly vector: Uint8Array;
+};
+/**
+ * Sparse vector. Token-keyed weights for hybrid search (dense + lexical-
+ * style sparse). The single hosted producer today is Jina's `elser-v2`
+ * model, which returns subword tokens (e.g. `"bread"`, `"##ing"`) with
+ * their relevance weights.
+ *
+ * The shape is `Record<string, number>` rather than `(indices, values)`
+ * because real hosted learned-sparse encoders (ELSER, SPLADE) emit token
+ * strings with no shared vocabulary index. Converting to integer indices
+ * would either need a vocabulary table the model doesn't expose, or
+ * lose the cross-vector matching semantics. If a provider ever exposes
+ * index-valued sparse vectors (Pinecone-style, where you bring your own
+ * vocab), add an `IndexSparseEmbedding` sibling arm with `_tag:
+ * "sparse-indexed"`.
+ *
+ * Score with `Vector.sparseCosine` — dot product over the intersection
+ * of keys, normalized by the L2 norms of both maps.
+ */
+type SparseEmbedding = {
+  readonly _tag: "sparse";
+  readonly weights: Readonly<Record<string, number>>;
+};
+/**
+ * Multivector / late-interaction output: one float32 vector per token.
+ * Score documents with `Vector.maxSim` (ColBERT-style: per query vector,
+ * max dot product across doc vectors, summed). Typically ~50-500 vectors
+ * per document, each shorter than a single-vector embedding (~128 dim
+ * vs ~1024).
+ *
+ * Quantized multivector forms aren't modeled for the same reason as
+ * sparse - nothing on hosted APIs ships them yet.
+ */
+type MultivectorEmbedding = {
+  readonly _tag: "multivector";
+  readonly vectors: ReadonlyArray<Float32Array>;
+};
+type Embedding = Float32Embedding | Int8Embedding | BinaryEmbedding | SparseEmbedding | MultivectorEmbedding;
+declare const isFloat32: (e: Embedding) => e is Float32Embedding;
+declare const isInt8: (e: Embedding) => e is Int8Embedding;
+declare const isBinary: (e: Embedding) => e is BinaryEmbedding;
+declare const isSparse: (e: Embedding) => e is SparseEmbedding;
+declare const isMultivector: (e: Embedding) => e is MultivectorEmbedding;
+/**
+ * Token usage for one embed / embedMany call. One value per HTTP request,
+ * not per input vector. Most providers populate `inputTokens`; the field
+ * is optional for those that don't (or for mock layers in tests).
+ */
+type Usage = {
+  readonly inputTokens?: number;
+};
+//#endregion
+export { BinaryEmbedding, EmbedContentPart, EmbedInput, Embedding, Float32Embedding, Int8Embedding, MultivectorEmbedding, SparseEmbedding, Usage, isBinary, isFloat32, isInt8, isMultivector, isSparse, Embedding_d_exports as t };
+//# sourceMappingURL=Embedding.d.mts.map

package/dist/embedding-model/Embedding.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Embedding.d.mts","names":[],"sources":["../../src/embedding-model/Embedding.ts"],"mappings":";;;;;;;;;;;KAOY,gBAAA;EAAA,SAA8B,IAAA;AAAA;EAAA,SAA4B,KAAA,EAAO,WAAA;AAAA;;;;;;;;;;KAWjE,UAAA;EAAA,SAEG,IAAA;AAAA;EAAA,SACA,KAAA,EAAO,WAAA;AAAA;EAAA,SACP,OAAA,EAAS,aAAA,CAAc,gBAAA;AAAA;;KAY1B,gBAAA;EAAA,SACD,IAAA;EAAA,SACA,MAAA,EAAQ,YAAA;AAAA;;;;;KAOP,aAAA;EAAA,SACD,IAAA;EAAA,SACA,MAAA,EAAQ,SAAA;AAAA;;;;;;KAQP,eAAA;EAAA,SACD,IAAA;EAAA,SACA,MAAA,EAAQ,UAAA;AAAA;;;;;;AAZnB;;;;;;;;;AAUA;;;;KAuBY,eAAA;EAAA,SACD,IAAA;EAAA,SACA,OAAA,EAAS,QAAA,CAAS,MAAA;AAAA;;AAF7B;;;;;;;;;KAeY,oBAAA;EAAA,SACD,IAAA;EAAA,SACA,OAAA,EAAS,aAAA,CAAc,YAAA;AAAA;AAAA,KAGtB,SAAA,GACR,gBAAA,GACA,aAAA,GACA,eAAA,GACA,eAAA,GACA,oBAAA;AAAA,cAES,SAAA,GAAa,CAAA,EAAG,SAAA,KAAY,CAAA,IAAK,gBAAA;AAAA,cACjC,MAAA,GAAU,CAAA,EAAG,SAAA,KAAY,CAAA,IAAK,aAAA;AAAA,cAC9B,QAAA,GAAY,CAAA,EAAG,SAAA,KAAY,CAAA,IAAK,eAAA;AAAA,cAChC,QAAA,GAAY,CAAA,EAAG,SAAA,KAAY,CAAA,IAAK,eAAA;AAAA,cAChC,aAAA,GAAiB,CAAA,EAAG,SAAA,KAAY,CAAA,IAAK,oBAAA;;AAXlD;;;;KAkBY,KAAA;EAAA,SACD,WAAA;AAAA"}

package/dist/embedding-model/Embedding.mjs

@@ -0,0 +1,18 @@
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+//#region src/embedding-model/Embedding.ts
+var Embedding_exports = /* @__PURE__ */ __exportAll({
+	isBinary: () => isBinary,
+	isFloat32: () => isFloat32,
+	isInt8: () => isInt8,
+	isMultivector: () => isMultivector,
+	isSparse: () => isSparse
+});
+const isFloat32 = (e) => e._tag === "float32";
+const isInt8 = (e) => e._tag === "int8";
+const isBinary = (e) => e._tag === "binary";
+const isSparse = (e) => e._tag === "sparse";
+const isMultivector = (e) => e._tag === "multivector";
+//#endregion
+export { isBinary, isFloat32, isInt8, isMultivector, isSparse, Embedding_exports as t };
+
+//# sourceMappingURL=Embedding.mjs.map

package/dist/embedding-model/Embedding.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Embedding.mjs","names":[],"sources":["../../src/embedding-model/Embedding.ts"],"sourcesContent":["import type { ImageSource } from \"../domain/Image.js\"\n\n/**\n * One part of a mixed text+image input. Used inside `EmbedInput.content[]`\n * for providers that accept interleaved modalities in a single embed call\n * (Cohere v4, Voyage multimodal, Jina v4, Google `gemini-embedding-2`).\n */\nexport type EmbedContentPart = { readonly text: string } | { readonly image: ImageSource }\n\n/**\n * What you embed. The `string` shorthand covers the common text-only case;\n * structured variants exist for image-only and mixed-modality inputs.\n *\n * Not every provider accepts every variant: text-only providers (OpenAI,\n * Mixedbread today) handle `string` and `{ text }`; multimodal providers\n * (Google, Jina v4, Voyage multimodal, Cohere v4) handle all four. A\n * provider layer rejects shapes it can't encode as `AiError.InvalidRequest`.\n */\nexport type EmbedInput =\n  | string\n  | { readonly text: string }\n  | { readonly image: ImageSource }\n  | { readonly content: ReadonlyArray<EmbedContentPart> }\n\n// ---------------------------------------------------------------------------\n// Embedding representations\n//\n// The `_tag` reflects the wire form the provider returned, *not* what the\n// consumer asked for - request `encoding: \"int8\"` and you get back an\n// `Int8Embedding`. Math primitives are typed against the named interfaces\n// (see `Vector.ts`) so e.g. `sparseCosine` only accepts `SparseEmbedding`.\n// ---------------------------------------------------------------------------\n\n/** Dense float32 vector. The default representation across all providers. */\nexport type Float32Embedding = {\n  readonly _tag: \"float32\"\n  readonly vector: Float32Array\n}\n\n/**\n * Dense int8-quantized vector. ~4x smaller than float32 with minimal\n * recall loss on most benchmarks.\n */\nexport type Int8Embedding = {\n  readonly _tag: \"int8\"\n  readonly vector: Int8Array\n}\n\n/**\n * Dense binary-quantized vector. One bit per dimension, packed into bytes.\n * ~32x smaller than float32; meaningful recall loss but useful for hot\n * indexes paired with a float32 reranker pass.\n */\nexport type BinaryEmbedding = {\n  readonly _tag: \"binary\"\n  readonly vector: Uint8Array\n}\n\n/**\n * Sparse vector. Token-keyed weights for hybrid search (dense + lexical-\n * style sparse). The single hosted producer today is Jina's `elser-v2`\n * model, which returns subword tokens (e.g. `\"bread\"`, `\"##ing\"`) with\n * their relevance weights.\n *\n * The shape is `Record<string, number>` rather than `(indices, values)`\n * because real hosted learned-sparse encoders (ELSER, SPLADE) emit token\n * strings with no shared vocabulary index. Converting to integer indices\n * would either need a vocabulary table the model doesn't expose, or\n * lose the cross-vector matching semantics. If a provider ever exposes\n * index-valued sparse vectors (Pinecone-style, where you bring your own\n * vocab), add an `IndexSparseEmbedding` sibling arm with `_tag:\n * \"sparse-indexed\"`.\n *\n * Score with `Vector.sparseCosine` — dot product over the intersection\n * of keys, normalized by the L2 norms of both maps.\n */\nexport type SparseEmbedding = {\n  readonly _tag: \"sparse\"\n  readonly weights: Readonly<Record<string, number>>\n}\n\n/**\n * Multivector / late-interaction output: one float32 vector per token.\n * Score documents with `Vector.maxSim` (ColBERT-style: per query vector,\n * max dot product across doc vectors, summed). Typically ~50-500 vectors\n * per document, each shorter than a single-vector embedding (~128 dim\n * vs ~1024).\n *\n * Quantized multivector forms aren't modeled for the same reason as\n * sparse - nothing on hosted APIs ships them yet.\n */\nexport type MultivectorEmbedding = {\n  readonly _tag: \"multivector\"\n  readonly vectors: ReadonlyArray<Float32Array>\n}\n\nexport type Embedding =\n  | Float32Embedding\n  | Int8Embedding\n  | BinaryEmbedding\n  | SparseEmbedding\n  | MultivectorEmbedding\n\nexport const isFloat32 = (e: Embedding): e is Float32Embedding => e._tag === \"float32\"\nexport const isInt8 = (e: Embedding): e is Int8Embedding => e._tag === \"int8\"\nexport const isBinary = (e: Embedding): e is BinaryEmbedding => e._tag === \"binary\"\nexport const isSparse = (e: Embedding): e is SparseEmbedding => e._tag === \"sparse\"\nexport const isMultivector = (e: Embedding): e is MultivectorEmbedding => e._tag === \"multivector\"\n\n/**\n * Token usage for one embed / embedMany call. One value per HTTP request,\n * not per input vector. Most providers populate `inputTokens`; the field\n * is optional for those that don't (or for mock layers in tests).\n */\nexport type Usage = {\n  readonly inputTokens?: number\n}\n"],"mappings":";;;;;;;;;AAuGA,MAAa,aAAa,MAAwC,EAAE,SAAS;AAC7E,MAAa,UAAU,MAAqC,EAAE,SAAS;AACvE,MAAa,YAAY,MAAuC,EAAE,SAAS;AAC3E,MAAa,YAAY,MAAuC,EAAE,SAAS;AAC3E,MAAa,iBAAiB,MAA4C,EAAE,SAAS"}