@effect-uai/core 0.5.2 → 0.7.0

package/dist/domain/Turn.d.mts

@@ -1,2 +1,388 @@
-import { c as assistantText, d as isTurnComplete, f as reasonings, i as TurnEvent, l as assistantTexts, m as toStructured, n as RefusalRejected, o as appendTurn, p as textDeltas, r as Turn, s as assistantMessages, t as InteractionEvent, u as functionCalls } from "../Turn-0CwCAyVe.mjs";
-export { InteractionEvent, RefusalRejected, Turn, TurnEvent, appendTurn, assistantMessages, assistantText, assistantTexts, functionCalls, isTurnComplete, reasonings, textDeltas, toStructured };
+import { i as ImageSource } from "../Image-HNmMpMTh.mjs";
+import { d as Message, m as Reasoning, o as HistoryItem, v as ToolCall, x as Usage, y as ToolCallOutput } from "../Items-D8UaXQx_.mjs";
+import { i as StructuredFormat, n as JsonParseError, r as StructuredDecodeError } from "../StructuredFormat-BbN4dosH.mjs";
+import { Data, Effect, Schema, Stream } from "effect";
+import * as _$effect_Types0 from "effect/Types";
+import * as _$effect_Cause0 from "effect/Cause";
+import * as _$effect_Unify0 from "effect/Unify";
+
+//#region src/domain/Turn.d.ts
+declare namespace Turn_d_exports {
+  export { InteractionEvent, RefusalRejected, Turn, TurnEvent, appendToHistory, assistantMessages, assistantText, assistantTexts, decodeStructured, getToolCalls, isTurnComplete, reasonings, textDeltas };
+}
+/**
+ * The result of a single LLM generation. A turn produces zero or more items
+ * (typically one assistant message and zero or more function_call items)
+ * and reports usage + a stop reason.
+ */
+declare const Turn: Schema.Struct<{
+  readonly items: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"message">;
+    readonly role: Schema.Literals<readonly ["user", "assistant", "system"]>;
+    readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+      readonly type: Schema.Literal<"input_text">;
+      readonly text: Schema.String;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"input_image">;
+      readonly source: Schema.Schema<ImageSource>;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"output_text">;
+      readonly text: Schema.String;
+      readonly annotations: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"url_citation">;
+        readonly url: Schema.String;
+        readonly start_index: Schema.Number;
+        readonly end_index: Schema.Number;
+        readonly title: Schema.String;
+      }>, Schema.Struct<{
+        readonly type: Schema.Literal<"file_citation">;
+        readonly file_id: Schema.String;
+        readonly index: Schema.Number;
+      }>, Schema.Struct<{
+        readonly type: Schema.Literal<"container_file_citation">;
+        readonly container_id: Schema.String;
+        readonly file_id: Schema.String;
+        readonly start_index: Schema.Number;
+        readonly end_index: Schema.Number;
+      }>, Schema.Struct<{
+        readonly type: Schema.Literal<"file_path">;
+        readonly file_id: Schema.String;
+        readonly index: Schema.Number;
+      }>]>>>;
+    }>, Schema.Struct<{
+      readonly type: Schema.Literal<"refusal">;
+      readonly text: Schema.String;
+    }>]>>;
+    readonly providerData: Schema.optional<Schema.Unknown>;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"function_call">;
+    readonly call_id: Schema.String;
+    readonly name: Schema.String;
+    readonly arguments: Schema.String;
+    readonly providerData: Schema.optional<Schema.Unknown>;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"function_call_output">;
+    readonly call_id: Schema.String;
+    readonly output: Schema.String;
+    readonly providerData: Schema.optional<Schema.Unknown>;
+  }>, Schema.Struct<{
+    readonly type: Schema.Literal<"reasoning">;
+    readonly id: Schema.optional<Schema.String>;
+    readonly summary: Schema.optional<Schema.String>;
+    readonly signature: Schema.optional<Schema.String>;
+    readonly providerData: Schema.optional<Schema.Unknown>;
+  }>]>>;
+  readonly usage: Schema.Struct<{
+    readonly input_tokens: Schema.optional<Schema.Number>;
+    readonly output_tokens: Schema.optional<Schema.Number>;
+    readonly total_tokens: Schema.optional<Schema.Number>;
+    readonly input_tokens_details: Schema.optional<Schema.Struct<{
+      readonly cached_tokens: Schema.optional<Schema.Number>;
+    }>>;
+    readonly output_tokens_details: Schema.optional<Schema.Struct<{
+      readonly reasoning_tokens: Schema.optional<Schema.Number>;
+    }>>;
+  }>;
+  readonly stop_reason: Schema.Literals<readonly ["stop", "tool_calls", "max_tokens", "refusal", "content_filter", "max_tool_calls"]>;
+}>;
+type Turn = typeof Turn.Type;
+/**
+ * Canonical events emitted while a single turn is being generated. Most
+ * variants are streaming deltas (text, reasoning, tool-call args); the
+ * terminal `TurnComplete` carries the assembled `Turn`. Lifecycle members
+ * aren't deltas, hence the union name.
+ *
+ * `ReasoningDelta.kind`: `trace` is the model's raw chain-of-thought;
+ * `summary` is a model-written summary intended for display. OpenAI
+ * Responses emits both; Anthropic and Gemini only emit `trace`.
+ *
+ * `RefusalDelta`: the model declined to answer. OpenAI Responses emits
+ * this as its own event; Anthropic surfaces refusals via `stop_reason`
+ * and Gemini collapses them into `finishReason: SAFETY` — both go
+ * without a `RefusalDelta`.
+ *
+ * `UsageUpdate`: mid-stream cumulative usage. Anthropic emits this on
+ * `message_start` and `message_delta`; other providers may only deliver
+ * usage via `TurnComplete.turn.usage`.
+ */
+type TurnEvent = Data.TaggedEnum<{
+  TextDelta: {
+    readonly text: string;
+  };
+  ReasoningDelta: {
+    readonly text: string;
+    readonly kind: "trace" | "summary";
+  };
+  RefusalDelta: {
+    readonly text: string;
+  };
+  ToolCallStart: {
+    readonly call_id: string;
+    readonly name: string;
+  };
+  ToolCallArgsDelta: {
+    readonly call_id: string;
+    readonly delta: string;
+  };
+  UsageUpdate: {
+    readonly usage: Usage;
+  };
+  TurnComplete: {
+    readonly turn: Turn;
+  };
+}>;
+declare const TurnEvent: {
+  readonly TextDelta: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "TextDelta";
+    readonly text: string;
+  }, "_tag">;
+  readonly ReasoningDelta: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "ReasoningDelta";
+    readonly text: string;
+    readonly kind: "trace" | "summary";
+  }, "_tag">;
+  readonly RefusalDelta: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "RefusalDelta";
+    readonly text: string;
+  }, "_tag">;
+  readonly ToolCallStart: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "ToolCallStart";
+    readonly call_id: string;
+    readonly name: string;
+  }, "_tag">;
+  readonly ToolCallArgsDelta: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "ToolCallArgsDelta";
+    readonly call_id: string;
+    readonly delta: string;
+  }, "_tag">;
+  readonly UsageUpdate: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "UsageUpdate";
+    readonly usage: Usage;
+  }, "_tag">;
+  readonly TurnComplete: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "TurnComplete";
+    readonly turn: Turn;
+  }, "_tag">;
+  readonly $is: <Tag extends "TextDelta" | "ReasoningDelta" | "RefusalDelta" | "ToolCallStart" | "ToolCallArgsDelta" | "UsageUpdate" | "TurnComplete">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "TextDelta";
+    readonly text: string;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "ReasoningDelta";
+    readonly text: string;
+    readonly kind: "trace" | "summary";
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "RefusalDelta";
+    readonly text: string;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "ToolCallStart";
+    readonly call_id: string;
+    readonly name: string;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "ToolCallArgsDelta";
+    readonly call_id: string;
+    readonly delta: string;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "UsageUpdate";
+    readonly usage: Usage;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "TurnComplete";
+    readonly turn: Turn;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends {
+      readonly TextDelta: (args: {
+        readonly _tag: "TextDelta";
+        readonly text: string;
+      }) => any;
+      readonly ReasoningDelta: (args: {
+        readonly _tag: "ReasoningDelta";
+        readonly text: string;
+        readonly kind: "trace" | "summary";
+      }) => any;
+      readonly RefusalDelta: (args: {
+        readonly _tag: "RefusalDelta";
+        readonly text: string;
+      }) => any;
+      readonly ToolCallStart: (args: {
+        readonly _tag: "ToolCallStart";
+        readonly call_id: string;
+        readonly name: string;
+      }) => any;
+      readonly ToolCallArgsDelta: (args: {
+        readonly _tag: "ToolCallArgsDelta";
+        readonly call_id: string;
+        readonly delta: string;
+      }) => any;
+      readonly UsageUpdate: (args: {
+        readonly _tag: "UsageUpdate";
+        readonly usage: Usage;
+      }) => any;
+      readonly TurnComplete: (args: {
+        readonly _tag: "TurnComplete";
+        readonly turn: Turn;
+      }) => any;
+    }>(cases: Cases): (value: {
+      readonly _tag: "TextDelta";
+      readonly text: string;
+    } | {
+      readonly _tag: "ReasoningDelta";
+      readonly text: string;
+      readonly kind: "trace" | "summary";
+    } | {
+      readonly _tag: "RefusalDelta";
+      readonly text: string;
+    } | {
+      readonly _tag: "ToolCallStart";
+      readonly call_id: string;
+      readonly name: string;
+    } | {
+      readonly _tag: "ToolCallArgsDelta";
+      readonly call_id: string;
+      readonly delta: string;
+    } | {
+      readonly _tag: "UsageUpdate";
+      readonly usage: Usage;
+    } | {
+      readonly _tag: "TurnComplete";
+      readonly turn: Turn;
+    }) => _$effect_Unify0.Unify<ReturnType<Cases["TextDelta" | "ReasoningDelta" | "RefusalDelta" | "ToolCallStart" | "ToolCallArgsDelta" | "UsageUpdate" | "TurnComplete"]>>;
+    <Cases extends {
+      readonly TextDelta: (args: {
+        readonly _tag: "TextDelta";
+        readonly text: string;
+      }) => any;
+      readonly ReasoningDelta: (args: {
+        readonly _tag: "ReasoningDelta";
+        readonly text: string;
+        readonly kind: "trace" | "summary";
+      }) => any;
+      readonly RefusalDelta: (args: {
+        readonly _tag: "RefusalDelta";
+        readonly text: string;
+      }) => any;
+      readonly ToolCallStart: (args: {
+        readonly _tag: "ToolCallStart";
+        readonly call_id: string;
+        readonly name: string;
+      }) => any;
+      readonly ToolCallArgsDelta: (args: {
+        readonly _tag: "ToolCallArgsDelta";
+        readonly call_id: string;
+        readonly delta: string;
+      }) => any;
+      readonly UsageUpdate: (args: {
+        readonly _tag: "UsageUpdate";
+        readonly usage: Usage;
+      }) => any;
+      readonly TurnComplete: (args: {
+        readonly _tag: "TurnComplete";
+        readonly turn: Turn;
+      }) => any;
+    }>(value: {
+      readonly _tag: "TextDelta";
+      readonly text: string;
+    } | {
+      readonly _tag: "ReasoningDelta";
+      readonly text: string;
+      readonly kind: "trace" | "summary";
+    } | {
+      readonly _tag: "RefusalDelta";
+      readonly text: string;
+    } | {
+      readonly _tag: "ToolCallStart";
+      readonly call_id: string;
+      readonly name: string;
+    } | {
+      readonly _tag: "ToolCallArgsDelta";
+      readonly call_id: string;
+      readonly delta: string;
+    } | {
+      readonly _tag: "UsageUpdate";
+      readonly usage: Usage;
+    } | {
+      readonly _tag: "TurnComplete";
+      readonly turn: Turn;
+    }, cases: Cases): _$effect_Unify0.Unify<ReturnType<Cases["TextDelta" | "ReasoningDelta" | "RefusalDelta" | "ToolCallStart" | "ToolCallArgsDelta" | "UsageUpdate" | "TurnComplete"]>>;
+  };
+};
+/**
+ * What flows out of an agent loop body to its consumer per turn: every
+ * `TurnEvent` the provider emits (including the terminal `TurnComplete`
+ * carrying the assembled `Turn`), plus the output of any tool the loop ran.
+ * Both variants carry a `_tag` discriminator.
+ */
+type InteractionEvent = TurnEvent | ToolCallOutput;
+declare const isTurnComplete: (u: unknown) => u is {
+  readonly _tag: "TurnComplete";
+  readonly turn: Turn;
+};
+declare const getToolCalls: (turn: Turn) => ReadonlyArray<ToolCall>;
+declare const reasonings: (turn: Turn) => ReadonlyArray<Reasoning>;
+declare const assistantMessages: (turn: Turn) => ReadonlyArray<Message>;
+/**
+ * Every `output_text` payload across every assistant message in the turn,
+ * preserving order. Refusals and other content blocks are dropped — use
+ * `assistantMessages` if you need to inspect them. The primitive for
+ * "give me the assistant's text"; callers decide how to combine
+ * (typically `.join("")` for prose or `.join(" ")` for log strings).
+ */
+declare const assistantTexts: (turn: Turn) => ReadonlyArray<string>;
+/**
+ * Sugar over `assistantTexts(turn).join("")` — the common case for
+ * summarizers, classifiers, judge calls, and structured-output backstops
+ * that want one concatenated string.
+ */
+declare const assistantText: (turn: Turn) => string;
+/**
+ * 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 `ToolCallOutput`s.
+ */
+declare const appendToHistory: <S extends {
+  readonly history: ReadonlyArray<HistoryItem>;
+}>(state: S, turn: Turn, items?: ReadonlyArray<HistoryItem>) => S;
+/**
+ * Project a `TurnEvent` stream onto its `TextDelta` payloads. Other
+ * variants are dropped. Composes with `Lines.lines` +
+ * `decodeJsonLines` for prompted-JSONL streaming.
+ */
+declare const textDeltas: <E, R>(self: Stream.Stream<TurnEvent, E, R>) => Stream.Stream<string, E, R>;
+declare const RefusalRejected_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
+  readonly _tag: "RefusalRejected";
+} & Readonly<A>;
+/**
+ * The assistant message on the just-completed turn was a refusal block,
+ * not an `output_text` payload. Returned by `decodeStructured` to short-circuit
+ * decoding before `JSON.parse` / schema validation runs.
+ */
+declare class RefusalRejected extends RefusalRejected_base<{
+  readonly turn: Turn;
+}> {}
+/**
+ * Validate a completed `Turn` against a `StructuredFormat`. Concatenates
+ * `output_text` blocks on the last assistant message, then runs
+ * `JSON.parse` + the format's schema validation.
+ *
+ * Three failure modes:
+ * - `RefusalRejected` — the assistant emitted a refusal block.
+ * - `JsonParseError` — the assembled text wasn't valid JSON.
+ * - `StructuredDecodeError` — the JSON didn't match the schema.
+ */
+declare const decodeStructured: <A>(turn: Turn, format: StructuredFormat<A>) => Effect.Effect<A, RefusalRejected | JsonParseError | StructuredDecodeError>;
+//#endregion
+export { InteractionEvent, RefusalRejected, Turn, TurnEvent, appendToHistory, assistantMessages, assistantText, assistantTexts, decodeStructured, getToolCalls, isTurnComplete, reasonings, Turn_d_exports as t, textDeltas };
+//# sourceMappingURL=Turn.d.mts.map

package/dist/domain/Turn.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Turn.d.mts","names":[],"sources":["../../src/domain/Turn.ts"],"mappings":";;;;;;;;;;;;;;;;;cAqBa,IAAA,EAAI,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAKL,IAAA,UAAc,IAAA,CAAK,IAAA;;;;;;;;;;;;;;;;;;;;KAqBnB,SAAA,GAAY,IAAA,CAAK,UAAA;EAC3B,SAAA;IAAA,SAAsB,IAAA;EAAA;EACtB,cAAA;IAAA,SAA2B,IAAA;IAAA,SAAuB,IAAA;EAAA;EAClD,YAAA;IAAA,SAAyB,IAAA;EAAA;EACzB,aAAA;IAAA,SAA0B,OAAA;IAAA,SAA0B,IAAA;EAAA;EACpD,iBAAA;IAAA,SAA8B,OAAA;IAAA,SAA0B,KAAA;EAAA;EACxD,WAAA;IAAA,SAAwB,KAAA,EAAO,KAAA;EAAA;EAC/B,YAAA;IAAA,SAAyB,IAAA,EAAM,IAAA;EAAA;AAAA;AAAA,cAGpB,SAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;oBAJoB,KAAA;EAAA;EAAA;;mBACA,IAAA;EAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBADA,KAAA;EAAA;IAAA;;;mBACA,IAAA;EAAA;IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBADA,KAAA;MAAA;MAAA;;uBACA,IAAA;MAAA;IAAA;;;;;;;;;;;;;;;;;;;;sBADA,KAAA;IAAA;MAAA;qBACA,IAAA;IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;wBADA,KAAA;MAAA;MAAA;;uBACA,IAAA;MAAA;IAAA;;;;;;;;;;;;;;;;;;;;sBADA,KAAA;IAAA;MAAA;qBACA,IAAA;IAAA;;;;;;;;;KAWrB,gBAAA,GAAmB,SAAA,GAAY,cAAA;AAAA,cAE9B,cAAA,GAAc,CAAA,cAAA,CAAA;EAAA;iBAbM,IAAA;AAAA;AAAA,cAepB,YAAA,GAAgB,IAAA,EAAM,IAAA,KAAO,aAAA,CAAc,QAAA;AAAA,cAE3C,UAAA,GAAc,IAAA,EAAM,IAAA,KAAO,aAAA,CAAc,SAAA;AAAA,cAEzC,iBAAA,GAAqB,IAAA,EAAM,IAAA,KAAO,aAAA,CAAc,OAAA;;;;;;;;cAUhD,cAAA,GAAkB,IAAA,EAAM,IAAA,KAAO,aAAA;;;;;;cAW/B,aAAA,GAAiB,IAAA,EAAM,IAAA;;;;;AA/CpC;cAsDa,eAAA;EAAA,SAAwC,OAAA,EAAS,aAAA,CAAc,WAAA;AAAA,GAC1E,KAAA,EAAO,CAAA,EACP,IAAA,EAAM,IAAA,EACN,KAAA,GAAO,aAAA,CAAc,WAAA,MACpB,CAAA;;;;;;cAcU,UAAA,SACX,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,CAAA,EAAG,CAAA,MACjC,MAAA,CAAO,MAAA,SAAe,CAAA,EAAG,CAAA;AAAA,cAGzB,oBAAA;;;;;;;;cAWU,eAAA,SAAwB,oBAAA;EAAA,SAC1B,IAAA,EAAM,IAAA;AAAA;;;;;;;;;;AA/EjB;cAwGa,gBAAA,MACX,IAAA,EAAM,IAAA,EACN,MAAA,EAAQ,gBAAA,CAAkC,CAAA,MACzC,MAAA,CAAO,MAAA,CACR,CAAA,EACA,eAAA,GAAkB,cAAA,GAAkC,qBAAA"}

package/dist/domain/Turn.mjs

@@ -1,5 +1,5 @@
 import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
-import { Item, StopReason, Usage, isOutputText, isRefusal } from "./Items.mjs";
+import { HistoryItem, StopReason, Usage, isOutputText, isReasoning, isRefusal, isToolCall } from "./Items.mjs";
 import { parseJson } from "../structured-format/StructuredFormat.mjs";
 import { Data, Effect, Result, Schema, Stream, pipe } from "effect";
 //#region src/domain/Turn.ts
@@ -7,15 +7,15 @@ var Turn_exports = /* @__PURE__ */ __exportAll({
 	RefusalRejected: () => RefusalRejected,
 	Turn: () => Turn,
 	TurnEvent: () => TurnEvent,
-	appendTurn: () => appendTurn,
+	appendToHistory: () => appendToHistory,
 	assistantMessages: () => assistantMessages,
 	assistantText: () => assistantText,
 	assistantTexts: () => assistantTexts,
-	functionCalls: () => functionCalls,
+	decodeStructured: () => decodeStructured,
+	getToolCalls: () => getToolCalls,
 	isTurnComplete: () => isTurnComplete,
 	reasonings: () => reasonings,
-	textDeltas: () => textDeltas,
-	toStructured: () => toStructured
+	textDeltas: () => textDeltas
 });
 /**
 * The result of a single LLM generation. A turn produces zero or more items
@@ -23,14 +23,14 @@ var Turn_exports = /* @__PURE__ */ __exportAll({
 * and reports usage + a stop reason.
 */
 const Turn = Schema.Struct({
-	items: Schema.Array(Item),
+	items: Schema.Array(HistoryItem),
 	usage: Usage,
 	stop_reason: StopReason
 });
 const TurnEvent = Data.taggedEnum();
 const isTurnComplete = TurnEvent.$is("TurnComplete");
-const functionCalls = (turn) => turn.items.filter((i) => i.type === "function_call");
-const reasonings = (turn) => turn.items.filter((i) => i.type === "reasoning");
+const getToolCalls = (turn) => turn.items.filter(isToolCall);
+const reasonings = (turn) => turn.items.filter(isReasoning);
 const assistantMessages = (turn) => turn.items.filter((i) => i.type === "message" && i.role === "assistant");
 /**
 * Every `output_text` payload across every assistant message in the turn,
@@ -49,9 +49,9 @@ const assistantText = (turn) => assistantTexts(turn).join("");
 /**
 * 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.
+* converted to model-facing `ToolCallOutput`s.
 */
-const appendTurn = (state, turn, items = []) => ({
+const appendToHistory = (state, turn, items = []) => ({
 	...state,
 	history: [
 		...state.history,
@@ -67,7 +67,7 @@ const appendTurn = (state, turn, items = []) => ({
 const textDeltas = (self) => self.pipe(Stream.filterMap((ev) => ev._tag === "TextDelta" ? Result.succeed(ev.text) : Result.failVoid));
 /**
 * The assistant message on the just-completed turn was a refusal block,
-* not an `output_text` payload. Returned by `toStructured` to short-circuit
+* not an `output_text` payload. Returned by `decodeStructured` to short-circuit
 * decoding before `JSON.parse` / schema validation runs.
 */
 var RefusalRejected = class extends Data.TaggedError("RefusalRejected") {};
@@ -97,8 +97,8 @@ const lastAssistantContent = (turn) => {
 * - `JsonParseError` — the assembled text wasn't valid JSON.
 * - `StructuredDecodeError` — the JSON didn't match the schema.
 */
-const toStructured = (turn, format) => pipe(lastAssistantContent(turn), ({ text, refused }) => refused ? Effect.fail(new RefusalRejected({ turn })) : parseJson(format)(text));
+const decodeStructured = (turn, format) => pipe(lastAssistantContent(turn), ({ text, refused }) => refused ? Effect.fail(new RefusalRejected({ turn })) : parseJson(format)(text));
 //#endregion
-export { RefusalRejected, Turn, TurnEvent, appendTurn, assistantMessages, assistantText, assistantTexts, functionCalls, isTurnComplete, reasonings, Turn_exports as t, textDeltas, toStructured };
+export { RefusalRejected, Turn, TurnEvent, appendToHistory, assistantMessages, assistantText, assistantTexts, decodeStructured, getToolCalls, isTurnComplete, reasonings, Turn_exports as t, textDeltas };
 
 //# 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 `TurnComplete` carries the assembled `Turn`. Lifecycle members\n * aren't deltas, hence the union name.\n *\n * `ReasoningDelta.kind`: `trace` is the model's raw chain-of-thought;\n * `summary` is a model-written summary intended for display. OpenAI\n * Responses emits both; Anthropic and Gemini only emit `trace`.\n *\n * `RefusalDelta`: the model declined to answer. OpenAI Responses emits\n * this as its own event; Anthropic surfaces refusals via `stop_reason`\n * and Gemini collapses them into `finishReason: SAFETY` — both go\n * without a `RefusalDelta`.\n *\n * `UsageUpdate`: mid-stream cumulative usage. Anthropic emits this on\n * `message_start` and `message_delta`; other providers may only deliver\n * usage via `TurnComplete.turn.usage`.\n */\nexport type TurnEvent = Data.TaggedEnum<{\n  TextDelta: { readonly text: string }\n  ReasoningDelta: { readonly text: string; readonly kind: \"trace\" | \"summary\" }\n  RefusalDelta: { readonly text: string }\n  ToolCallStart: { readonly call_id: string; readonly name: string }\n  ToolCallArgsDelta: { readonly call_id: string; readonly delta: string }\n  UsageUpdate: { readonly usage: Usage }\n  TurnComplete: { readonly turn: Turn }\n}>\n\nexport const TurnEvent = Data.taggedEnum<TurnEvent>()\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 `TurnComplete`\n * carrying the assembled `Turn`), plus the output of any tool the loop ran.\n * Both variants carry a `_tag` discriminator.\n */\nexport type InteractionEvent = TurnEvent | FunctionCallOutput\n\nexport const isTurnComplete = TurnEvent.$is(\"TurnComplete\")\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 * Every `output_text` payload across every assistant message in the turn,\n * preserving order. Refusals and other content blocks are dropped — use\n * `assistantMessages` if you need to inspect them. The primitive for\n * \"give me the assistant's text\"; callers decide how to combine\n * (typically `.join(\"\")` for prose or `.join(\" \")` for log strings).\n */\nexport const assistantTexts = (turn: Turn): ReadonlyArray<string> =>\n  assistantMessages(turn)\n    .flatMap((m) => m.content)\n    .filter(isOutputText)\n    .map((b) => b.text)\n\n/**\n * Sugar over `assistantTexts(turn).join(\"\")` — the common case for\n * summarizers, classifiers, judge calls, and structured-output backstops\n * that want one concatenated string.\n */\nexport const assistantText = (turn: Turn): string => assistantTexts(turn).join(\"\")\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 `TextDelta` 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) => (ev._tag === \"TextDelta\" ? Result.succeed(ev.text) : Result.failVoid)),\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;AAgCF,MAAa,YAAY,KAAK,YAAuB;AAUrD,MAAa,iBAAiB,UAAU,IAAI,eAAe;AAE3D,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;;;;;;;;AASxF,MAAa,kBAAkB,SAC7B,kBAAkB,KAAK,CACpB,SAAS,MAAM,EAAE,QAAQ,CACzB,OAAO,aAAa,CACpB,KAAK,MAAM,EAAE,KAAK;;;;;;AAOvB,MAAa,iBAAiB,SAAuB,eAAe,KAAK,CAAC,KAAK,GAAG;;;;;;AAOlF,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,OAAQ,GAAG,SAAS,cAAc,OAAO,QAAQ,GAAG,KAAK,GAAG,OAAO,SAAU,CAChG;;;;;;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  HistoryItem,\n  Message,\n  Reasoning,\n  StopReason,\n  ToolCall,\n  ToolCallOutput,\n  Usage,\n  isOutputText,\n  isReasoning,\n  isRefusal,\n  isToolCall,\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(HistoryItem),\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 `TurnComplete` carries the assembled `Turn`. Lifecycle members\n * aren't deltas, hence the union name.\n *\n * `ReasoningDelta.kind`: `trace` is the model's raw chain-of-thought;\n * `summary` is a model-written summary intended for display. OpenAI\n * Responses emits both; Anthropic and Gemini only emit `trace`.\n *\n * `RefusalDelta`: the model declined to answer. OpenAI Responses emits\n * this as its own event; Anthropic surfaces refusals via `stop_reason`\n * and Gemini collapses them into `finishReason: SAFETY` — both go\n * without a `RefusalDelta`.\n *\n * `UsageUpdate`: mid-stream cumulative usage. Anthropic emits this on\n * `message_start` and `message_delta`; other providers may only deliver\n * usage via `TurnComplete.turn.usage`.\n */\nexport type TurnEvent = Data.TaggedEnum<{\n  TextDelta: { readonly text: string }\n  ReasoningDelta: { readonly text: string; readonly kind: \"trace\" | \"summary\" }\n  RefusalDelta: { readonly text: string }\n  ToolCallStart: { readonly call_id: string; readonly name: string }\n  ToolCallArgsDelta: { readonly call_id: string; readonly delta: string }\n  UsageUpdate: { readonly usage: Usage }\n  TurnComplete: { readonly turn: Turn }\n}>\n\nexport const TurnEvent = Data.taggedEnum<TurnEvent>()\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 `TurnComplete`\n * carrying the assembled `Turn`), plus the output of any tool the loop ran.\n * Both variants carry a `_tag` discriminator.\n */\nexport type InteractionEvent = TurnEvent | ToolCallOutput\n\nexport const isTurnComplete = TurnEvent.$is(\"TurnComplete\")\n\nexport const getToolCalls = (turn: Turn): ReadonlyArray<ToolCall> => turn.items.filter(isToolCall)\n\nexport const reasonings = (turn: Turn): ReadonlyArray<Reasoning> => turn.items.filter(isReasoning)\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 * Every `output_text` payload across every assistant message in the turn,\n * preserving order. Refusals and other content blocks are dropped — use\n * `assistantMessages` if you need to inspect them. The primitive for\n * \"give me the assistant's text\"; callers decide how to combine\n * (typically `.join(\"\")` for prose or `.join(\" \")` for log strings).\n */\nexport const assistantTexts = (turn: Turn): ReadonlyArray<string> =>\n  assistantMessages(turn)\n    .flatMap((m) => m.content)\n    .filter(isOutputText)\n    .map((b) => b.text)\n\n/**\n * Sugar over `assistantTexts(turn).join(\"\")` — the common case for\n * summarizers, classifiers, judge calls, and structured-output backstops\n * that want one concatenated string.\n */\nexport const assistantText = (turn: Turn): string => assistantTexts(turn).join(\"\")\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 `ToolCallOutput`s.\n */\nexport const appendToHistory = <S extends { readonly history: ReadonlyArray<HistoryItem> }>(\n  state: S,\n  turn: Turn,\n  items: ReadonlyArray<HistoryItem> = [],\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 `TextDelta` 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) => (ev._tag === \"TextDelta\" ? Result.succeed(ev.text) : Result.failVoid)),\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 `decodeStructured` 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 decodeStructured = <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":";;;;;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,OAAO,OAAO,OAAO;CAChC,OAAO,OAAO,MAAM,YAAY;CAChC,OAAO;CACP,aAAa;CACd,CAAC;AAgCF,MAAa,YAAY,KAAK,YAAuB;AAUrD,MAAa,iBAAiB,UAAU,IAAI,eAAe;AAE3D,MAAa,gBAAgB,SAAwC,KAAK,MAAM,OAAO,WAAW;AAElG,MAAa,cAAc,SAAyC,KAAK,MAAM,OAAO,YAAY;AAElG,MAAa,qBAAqB,SAChC,KAAK,MAAM,QAAQ,MAAoB,EAAE,SAAS,aAAa,EAAE,SAAS,YAAY;;;;;;;;AASxF,MAAa,kBAAkB,SAC7B,kBAAkB,KAAK,CACpB,SAAS,MAAM,EAAE,QAAQ,CACzB,OAAO,aAAa,CACpB,KAAK,MAAM,EAAE,KAAK;;;;;;AAOvB,MAAa,iBAAiB,SAAuB,eAAe,KAAK,CAAC,KAAK,GAAG;;;;;;AAOlF,MAAa,mBACX,OACA,MACA,QAAoC,EAAE,MAC/B;CACP,GAAG;CACH,SAAS;EAAC,GAAG,MAAM;EAAS,GAAG,KAAK;EAAO,GAAG;EAAM;CACrD;;;;;;AAWD,MAAa,cACX,SAEA,KAAK,KACH,OAAO,WAAW,OAAQ,GAAG,SAAS,cAAc,OAAO,QAAQ,GAAG,KAAK,GAAG,OAAO,SAAU,CAChG;;;;;;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,oBACX,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

@@ -2,7 +2,7 @@ import { i as ImageSource } from "../Image-HNmMpMTh.mjs";
 
 //#region src/embedding-model/Embedding.d.ts
 declare namespace Embedding_d_exports {
-  export { BinaryEmbedding, EmbedContentPart, EmbedInput, Embedding, EmbeddingFor, Float32Embedding, Int8Embedding, MultivectorEmbedding, SparseEmbedding, Usage, isBinary, isFloat32, isInt8, isMultivector, isSparse };
+  export { BinaryEmbedding, EmbedContentPart, EmbedInput, Embedding, EmbeddingFor, Float32Embedding, Int8Embedding, MultivectorEmbedding, ResponseEncoding, SparseEmbedding, Usage, isBinary, isFloat32, isInt8, isMultivector, isSparse };
 }
 /**
  * One part of a mixed text+image input. Used inside `EmbedInput.content[]`
@@ -94,6 +94,16 @@ 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;
+/**
+ * Domain of `EmbeddingFor` and the response type parameter on
+ * `EmbedResponse` / `EmbedManyResponse`: every encoding a provider can
+ * *return*, including Jina's widened `sparse` / `multivector`. Distinct
+ * from `EmbedEncoding` (the cross-provider *request* set, which is dense
+ * quantization only). Providers whose typed request widens beyond the
+ * dense set (Jina) parameterize their responses with their own encoding
+ * union, which is a subset of this.
+ */
+type ResponseEncoding = "float32" | "int8" | "binary" | "sparse" | "multivector";
 /**
  * Maps an `encoding` request field to the corresponding response embedding
  * variant. `undefined` (no encoding requested) defaults to `Float32Embedding`,
@@ -115,5 +125,5 @@ type Usage = {
   readonly inputTokens?: number;
 };
 //#endregion
-export { BinaryEmbedding, EmbedContentPart, EmbedInput, Embedding, EmbeddingFor, Float32Embedding, Int8Embedding, MultivectorEmbedding, SparseEmbedding, Usage, isBinary, isFloat32, isInt8, isMultivector, isSparse, Embedding_d_exports as t };
+export { BinaryEmbedding, EmbedContentPart, EmbedInput, Embedding, EmbeddingFor, Float32Embedding, Int8Embedding, MultivectorEmbedding, ResponseEncoding, 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

@@ -1 +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;;;;;;;;;KAwBY,YAAA,OAAmB,CAAA,oCAC3B,gBAAA,IACC,CAAA,qBACC,aAAA,IACC,CAAA,uBACC,eAAA,IACC,CAAA,uBACC,eAAA,IACC,CAAA,4BACC,oBAAA,GACA,SAAA;;;;;;KAOA,KAAA;EAAA,SACD,WAAA;AAAA"}
+{"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;;;;;;KAsBY,gBAAA;;;;;;;;;;;AAfZ;KA4BY,YAAA,OAAmB,CAAA,oCAC3B,gBAAA,IACC,CAAA,qBACC,aAAA,IACC,CAAA,uBACC,eAAA,IACC,CAAA,uBACC,eAAA,IACC,CAAA,4BACC,oBAAA,GACA,SAAA;;;;;;KAOA,KAAA;EAAA,SACD,WAAA;AAAA"}

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

@@ -1 +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 * Maps an `encoding` request field to the corresponding response embedding\n * variant. `undefined` (no encoding requested) defaults to `Float32Embedding`,\n * which is what every provider returns when the caller doesn't ask for\n * anything else. Widened `E` falls back to the full `Embedding` union — the\n * caller has to narrow at use site, which honestly reflects what they know\n * at compile time.\n *\n * Used by `EmbedResponse<E>` / `EmbedManyResponse<E>` to give callers a\n * precise embedding type without a runtime narrowing helper.\n */\nexport type EmbeddingFor<E> = [E] extends [undefined | \"float32\"]\n  ? Float32Embedding\n  : [E] extends [\"int8\"]\n    ? Int8Embedding\n    : [E] extends [\"binary\"]\n      ? BinaryEmbedding\n      : [E] extends [\"sparse\"]\n        ? SparseEmbedding\n        : [E] extends [\"multivector\"]\n          ? MultivectorEmbedding\n          : Embedding\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"}
+{"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 * Domain of `EmbeddingFor` and the response type parameter on\n * `EmbedResponse` / `EmbedManyResponse`: every encoding a provider can\n * *return*, including Jina's widened `sparse` / `multivector`. Distinct\n * from `EmbedEncoding` (the cross-provider *request* set, which is dense\n * quantization only). Providers whose typed request widens beyond the\n * dense set (Jina) parameterize their responses with their own encoding\n * union, which is a subset of this.\n */\nexport type ResponseEncoding = \"float32\" | \"int8\" | \"binary\" | \"sparse\" | \"multivector\"\n\n/**\n * Maps an `encoding` request field to the corresponding response embedding\n * variant. `undefined` (no encoding requested) defaults to `Float32Embedding`,\n * which is what every provider returns when the caller doesn't ask for\n * anything else. Widened `E` falls back to the full `Embedding` union — the\n * caller has to narrow at use site, which honestly reflects what they know\n * at compile time.\n *\n * Used by `EmbedResponse<E>` / `EmbedManyResponse<E>` to give callers a\n * precise embedding type without a runtime narrowing helper.\n */\nexport type EmbeddingFor<E> = [E] extends [undefined | \"float32\"]\n  ? Float32Embedding\n  : [E] extends [\"int8\"]\n    ? Int8Embedding\n    : [E] extends [\"binary\"]\n      ? BinaryEmbedding\n      : [E] extends [\"sparse\"]\n        ? SparseEmbedding\n        : [E] extends [\"multivector\"]\n          ? MultivectorEmbedding\n          : Embedding\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"}