@effect-uai/core 0.11.0 → 0.12.1

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  type Annotation,\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 *\n * `WebSearchCall`: lifecycle of a provider-executed web search within the\n * turn. Fires only when the turn grounds against search; absent otherwise.\n *\n * `CitationAdded`: a citation attached to the answer, emitted incrementally\n * where the provider streams citations. Providers that bundle citations emit\n * none of these; their citations still arrive on `TurnComplete.turn`\n * (`OutputText.annotations`). Either way the final set is on the assembled turn.\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  WebSearchCall: {\n    readonly status: \"started\" | \"searching\" | \"completed\"\n    readonly query?: string\n    readonly action?: \"search\" | \"open_page\" | \"find_in_page\"\n  }\n  CitationAdded: { readonly annotation: Annotation }\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 * Every citation annotation attached to the turn's assistant `output_text`\n * blocks, in order. The flat view of a grounded turn's sources, whether the\n * turn came from a normal generation with native search or a deep-research job.\n */\nexport const citations = (turn: Turn): ReadonlyArray<Annotation> =>\n  assistantMessages(turn)\n    .flatMap((m) => m.content)\n    .filter(isOutputText)\n    .flatMap((b) => b.annotations ?? [])\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":";;;;;;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,OAAO,OAAO,OAAO;CAChC,OAAO,OAAO,MAAM,YAAY;CAChC,OAAO;CACP,aAAa;CACd,CAAC;AA8CF,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,aAAa,SACxB,kBAAkB,KAAK,CACpB,SAAS,MAAM,EAAE,QAAQ,CACzB,OAAO,aAAa,CACpB,SAAS,MAAM,EAAE,eAAe,EAAE,CAAC;;;;;;AAOxC,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"}
+{"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  type Annotation,\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 *\n * `WebSearchCall`: lifecycle of a provider-executed web search within the\n * turn. Fires only when the turn grounds against search; absent otherwise.\n *\n * `CitationAdded`: a citation attached to the answer, emitted incrementally\n * where the provider streams citations. Providers that bundle citations emit\n * none of these; their citations still arrive on `TurnComplete.turn`\n * (`OutputText.annotations`). Either way the final set is on the assembled turn.\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  WebSearchCall: {\n    readonly status: \"started\" | \"searching\" | \"completed\"\n    readonly query?: string\n    readonly action?: \"search\" | \"open_page\" | \"find_in_page\"\n  }\n  CitationAdded: { readonly annotation: Annotation }\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 * Every citation annotation attached to the turn's assistant `output_text`\n * blocks, in order. The flat view of a grounded turn's sources, whether the\n * turn came from a normal generation with native search or a deep-research job.\n */\nexport const citations = (turn: Turn): ReadonlyArray<Annotation> =>\n  assistantMessages(turn)\n    .flatMap((m) => m.content)\n    .filter(isOutputText)\n    .flatMap((b) => b.annotations ?? [])\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":";;;;;;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,OAAO,OAAO,OAAO;CAChC,OAAO,OAAO,MAAM,WAAW;CAC/B,OAAO;CACP,aAAa;AACf,CAAC;AA8CD,MAAa,YAAY,KAAK,WAAsB;AAUpD,MAAa,iBAAiB,UAAU,IAAI,cAAc;AAE1D,MAAa,gBAAgB,SAAwC,KAAK,MAAM,OAAO,UAAU;AAEjG,MAAa,cAAc,SAAyC,KAAK,MAAM,OAAO,WAAW;AAEjG,MAAa,qBAAqB,SAChC,KAAK,MAAM,QAAQ,MAAoB,EAAE,SAAS,aAAa,EAAE,SAAS,WAAW;;;;;;;;AASvF,MAAa,kBAAkB,SAC7B,kBAAkB,IAAI,CAAC,CACpB,SAAS,MAAM,EAAE,OAAO,CAAC,CACzB,OAAO,YAAY,CAAC,CACpB,KAAK,MAAM,EAAE,IAAI;;;;;;AAOtB,MAAa,iBAAiB,SAAuB,eAAe,IAAI,CAAC,CAAC,KAAK,EAAE;;;;;;AAOjF,MAAa,aAAa,SACxB,kBAAkB,IAAI,CAAC,CACpB,SAAS,MAAM,EAAE,OAAO,CAAC,CACzB,OAAO,YAAY,CAAC,CACpB,SAAS,MAAM,EAAE,eAAe,CAAC,CAAC;;;;;;AAOvC,MAAa,mBACX,OACA,MACA,QAAoC,CAAC,OAC9B;CACP,GAAG;CACH,SAAS;EAAC,GAAG,MAAM;EAAS,GAAG,KAAK;EAAO,GAAG;CAAK;AACrD;;;;;;AAWA,MAAa,cACX,SAEA,KAAK,KACH,OAAO,WAAW,OAAQ,GAAG,SAAS,cAAc,OAAO,QAAQ,GAAG,IAAI,IAAI,OAAO,QAAS,CAChG;;;;;;AAWF,IAAa,kBAAb,cAAqC,KAAK,YAAY,iBAAiB,CAAC,CAErE,CAAC;AAEJ,MAAM,wBAAwB,SAAqE;CACjG,MAAM,aAAa,kBAAkB,IAAI;CACzC,MAAM,OAAO,WAAW,WAAW,SAAS;CAC5C,IAAI,SAAS,KAAA,GAAW,OAAO;EAAE,MAAM;EAAI,SAAS;CAAM;CAC1D,IAAI,KAAK,QAAQ,KAAK,SAAS,GAAG,OAAO;EAAE,MAAM;EAAI,SAAS;CAAK;CAKnE,OAAO;EAAE,MAJI,KAAK,QACf,OAAO,YAAY,CAAC,CACpB,KAAK,MAAM,EAAE,IAAI,CAAC,CAClB,KAAK,EACI;EAAG,SAAS;CAAM;AAChC;;;;;;;;;;;AAYA,MAAa,oBACX,MACA,WAKA,KAAK,qBAAqB,IAAI,IAAI,EAAE,MAAM,cACxC,UAAU,OAAO,KAAK,IAAI,gBAAgB,EAAE,KAAK,CAAC,CAAC,IAAIA,UAA2B,MAAM,CAAC,CAAC,IAAI,CAChG"}

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

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

package/dist/domain/Turn.test.mjs

@@ -1,6 +1,7 @@
 import { assistantText, systemText, userText } from "./Items.mjs";
 import { assistantText as assistantText$1, assistantTexts } from "./Turn.mjs";
-import { c as it, n as globalExpect, o as describe } from "../dist-CcRV3-A5.mjs";
+import { m as it, o as describe } from "../utils-CiH_DjFW.mjs";
+import { n as globalExpect } from "../test.DNmyFkvJ-YPzDR0Co.mjs";
 //#region src/domain/Turn.test.ts
 const turnOf = (items) => ({
 	items,
@@ -12,7 +13,7 @@ const turnOf = (items) => ({
 });
 describe("Turn.assistantTexts", () => {
 	it("returns each output_text block in order across a single assistant message", () => {
-		globalExpect(assistantTexts(turnOf([{
+		const turn = turnOf([{
 			type: "message",
 			role: "assistant",
 			content: [{
@@ -22,21 +23,23 @@ describe("Turn.assistantTexts", () => {
 				type: "output_text",
 				text: "second"
 			}]
-		}]))).toEqual(["first", "second"]);
+		}]);
+		globalExpect(assistantTexts(turn)).toEqual(["first", "second"]);
 	});
 	it("preserves order across multiple assistant messages", () => {
-		globalExpect(assistantTexts(turnOf([
+		const turn = turnOf([
 			assistantText("alpha"),
 			assistantText("beta"),
 			assistantText("gamma")
-		]))).toEqual([
+		]);
+		globalExpect(assistantTexts(turn)).toEqual([
 			"alpha",
 			"beta",
 			"gamma"
 		]);
 	});
 	it("drops refusal blocks and non-assistant messages", () => {
-		globalExpect(assistantTexts(turnOf([userText("ignored"), {
+		const turn = turnOf([userText("ignored"), {
 			type: "message",
 			role: "assistant",
 			content: [{
@@ -46,7 +49,8 @@ describe("Turn.assistantTexts", () => {
 				type: "refusal",
 				text: "I can't help with that."
 			}]
-		}]))).toEqual(["kept"]);
+		}]);
+		globalExpect(assistantTexts(turn)).toEqual(["kept"]);
 	});
 	it("returns an empty array when there's nothing to extract", () => {
 		globalExpect(assistantTexts(turnOf([]))).toEqual([]);
@@ -61,7 +65,7 @@ describe("Turn.assistantTexts", () => {
 });
 describe("Turn.assistantText", () => {
 	it("concatenates output_text across a single assistant message's content blocks", () => {
-		globalExpect(assistantText$1(turnOf([{
+		const turn = turnOf([{
 			type: "message",
 			role: "assistant",
 			content: [{
@@ -71,20 +75,23 @@ describe("Turn.assistantText", () => {
 				type: "output_text",
 				text: "world"
 			}]
-		}]))).toBe("hello world");
+		}]);
+		globalExpect(assistantText$1(turn)).toBe("hello world");
 	});
 	it("concatenates output_text across multiple assistant messages", () => {
-		globalExpect(assistantText$1(turnOf([assistantText("first "), assistantText("second")]))).toBe("first second");
+		const turn = turnOf([assistantText("first "), assistantText("second")]);
+		globalExpect(assistantText$1(turn)).toBe("first second");
 	});
 	it("ignores non-assistant messages", () => {
-		globalExpect(assistantText$1(turnOf([
+		const turn = turnOf([
 			userText("ignored"),
 			systemText("also ignored"),
 			assistantText("kept")
-		]))).toBe("kept");
+		]);
+		globalExpect(assistantText$1(turn)).toBe("kept");
 	});
 	it("ignores non-output_text content blocks (refusals, etc.)", () => {
-		globalExpect(assistantText$1(turnOf([{
+		const turn = turnOf([{
 			type: "message",
 			role: "assistant",
 			content: [
@@ -101,10 +108,11 @@ describe("Turn.assistantText", () => {
 					text: "after"
 				}
 			]
-		}]))).toBe("before after");
+		}]);
+		globalExpect(assistantText$1(turn)).toBe("before after");
 	});
 	it("ignores function_call items even when interleaved with messages", () => {
-		globalExpect(assistantText$1(turnOf([
+		const turn = turnOf([
 			assistantText("text "),
 			{
 				type: "function_call",
@@ -113,21 +121,23 @@ describe("Turn.assistantText", () => {
 				arguments: "{}"
 			},
 			assistantText("more text")
-		]))).toBe("text more text");
+		]);
+		globalExpect(assistantText$1(turn)).toBe("text more text");
 	});
 	it("returns the empty string when no assistant messages exist", () => {
 		globalExpect(assistantText$1(turnOf([]))).toBe("");
 		globalExpect(assistantText$1(turnOf([userText("only user")]))).toBe("");
 	});
 	it("returns the empty string when the assistant message has no output_text blocks", () => {
-		globalExpect(assistantText$1(turnOf([{
+		const turn = turnOf([{
 			type: "message",
 			role: "assistant",
 			content: [{
 				type: "refusal",
 				text: "I can't help."
 			}]
-		}]))).toBe("");
+		}]);
+		globalExpect(assistantText$1(turn)).toBe("");
 	});
 });
 //#endregion

package/dist/domain/Turn.test.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Turn.test.mjs","names":["Turn.assistantTexts","Items.assistantText","Items.userText","Turn.assistantText","Items.systemText"],"sources":["../../src/domain/Turn.test.ts"],"sourcesContent":["import { describe, expect, it } from \"vitest\"\nimport * as Items from \"./Items.js\"\nimport * as Turn from \"./Turn.js\"\n\nconst turnOf = (items: Turn.Turn[\"items\"]): Turn.Turn => ({\n  items,\n  usage: { input_tokens: 0, output_tokens: 0 },\n  stop_reason: \"stop\",\n})\n\ndescribe(\"Turn.assistantTexts\", () => {\n  it(\"returns each output_text block in order across a single assistant message\", () => {\n    const turn = turnOf([\n      {\n        type: \"message\",\n        role: \"assistant\",\n        content: [\n          { type: \"output_text\", text: \"first\" },\n          { type: \"output_text\", text: \"second\" },\n        ],\n      },\n    ])\n\n    expect(Turn.assistantTexts(turn)).toEqual([\"first\", \"second\"])\n  })\n\n  it(\"preserves order across multiple assistant messages\", () => {\n    const turn = turnOf([\n      Items.assistantText(\"alpha\"),\n      Items.assistantText(\"beta\"),\n      Items.assistantText(\"gamma\"),\n    ])\n\n    expect(Turn.assistantTexts(turn)).toEqual([\"alpha\", \"beta\", \"gamma\"])\n  })\n\n  it(\"drops refusal blocks and non-assistant messages\", () => {\n    const turn = turnOf([\n      Items.userText(\"ignored\"),\n      {\n        type: \"message\",\n        role: \"assistant\",\n        content: [\n          { type: \"output_text\", text: \"kept\" },\n          { type: \"refusal\", text: \"I can't help with that.\" },\n        ],\n      },\n    ])\n\n    expect(Turn.assistantTexts(turn)).toEqual([\"kept\"])\n  })\n\n  it(\"returns an empty array when there's nothing to extract\", () => {\n    expect(Turn.assistantTexts(turnOf([]))).toEqual([])\n    expect(Turn.assistantTexts(turnOf([Items.userText(\"only user\")]))).toEqual([])\n  })\n\n  it(\"composes with caller-chosen separators\", () => {\n    const turn = turnOf([Items.assistantText(\"hello\"), Items.assistantText(\"world\")])\n\n    expect(Turn.assistantTexts(turn).join(\"\")).toBe(\"helloworld\")\n    expect(Turn.assistantTexts(turn).join(\" \")).toBe(\"hello world\")\n    expect(Turn.assistantTexts(turn).join(\"\\n\")).toBe(\"hello\\nworld\")\n  })\n})\n\ndescribe(\"Turn.assistantText\", () => {\n  it(\"concatenates output_text across a single assistant message's content blocks\", () => {\n    const turn = turnOf([\n      {\n        type: \"message\",\n        role: \"assistant\",\n        content: [\n          { type: \"output_text\", text: \"hello \" },\n          { type: \"output_text\", text: \"world\" },\n        ],\n      },\n    ])\n\n    expect(Turn.assistantText(turn)).toBe(\"hello world\")\n  })\n\n  it(\"concatenates output_text across multiple assistant messages\", () => {\n    const turn = turnOf([Items.assistantText(\"first \"), Items.assistantText(\"second\")])\n\n    expect(Turn.assistantText(turn)).toBe(\"first second\")\n  })\n\n  it(\"ignores non-assistant messages\", () => {\n    const turn = turnOf([\n      Items.userText(\"ignored\"),\n      Items.systemText(\"also ignored\"),\n      Items.assistantText(\"kept\"),\n    ])\n\n    expect(Turn.assistantText(turn)).toBe(\"kept\")\n  })\n\n  it(\"ignores non-output_text content blocks (refusals, etc.)\", () => {\n    const turn = turnOf([\n      {\n        type: \"message\",\n        role: \"assistant\",\n        content: [\n          { type: \"output_text\", text: \"before \" },\n          { type: \"refusal\", text: \"I can't help with that.\" },\n          { type: \"output_text\", text: \"after\" },\n        ],\n      },\n    ])\n\n    expect(Turn.assistantText(turn)).toBe(\"before after\")\n  })\n\n  it(\"ignores function_call items even when interleaved with messages\", () => {\n    const turn = turnOf([\n      Items.assistantText(\"text \"),\n      { type: \"function_call\", call_id: \"c1\", name: \"search\", arguments: \"{}\" },\n      Items.assistantText(\"more text\"),\n    ])\n\n    expect(Turn.assistantText(turn)).toBe(\"text more text\")\n  })\n\n  it(\"returns the empty string when no assistant messages exist\", () => {\n    expect(Turn.assistantText(turnOf([]))).toBe(\"\")\n    expect(Turn.assistantText(turnOf([Items.userText(\"only user\")]))).toBe(\"\")\n  })\n\n  it(\"returns the empty string when the assistant message has no output_text blocks\", () => {\n    const turn = turnOf([\n      {\n        type: \"message\",\n        role: \"assistant\",\n        content: [{ type: \"refusal\", text: \"I can't help.\" }],\n      },\n    ])\n\n    expect(Turn.assistantText(turn)).toBe(\"\")\n  })\n})\n"],"mappings":"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"}
+{"version":3,"file":"Turn.test.mjs","names":["Turn.assistantTexts","Items.assistantText","Items.userText","Turn.assistantText","Items.systemText"],"sources":["../../src/domain/Turn.test.ts"],"sourcesContent":["import { describe, expect, it } from \"vitest\"\nimport * as Items from \"./Items.js\"\nimport * as Turn from \"./Turn.js\"\n\nconst turnOf = (items: Turn.Turn[\"items\"]): Turn.Turn => ({\n  items,\n  usage: { input_tokens: 0, output_tokens: 0 },\n  stop_reason: \"stop\",\n})\n\ndescribe(\"Turn.assistantTexts\", () => {\n  it(\"returns each output_text block in order across a single assistant message\", () => {\n    const turn = turnOf([\n      {\n        type: \"message\",\n        role: \"assistant\",\n        content: [\n          { type: \"output_text\", text: \"first\" },\n          { type: \"output_text\", text: \"second\" },\n        ],\n      },\n    ])\n\n    expect(Turn.assistantTexts(turn)).toEqual([\"first\", \"second\"])\n  })\n\n  it(\"preserves order across multiple assistant messages\", () => {\n    const turn = turnOf([\n      Items.assistantText(\"alpha\"),\n      Items.assistantText(\"beta\"),\n      Items.assistantText(\"gamma\"),\n    ])\n\n    expect(Turn.assistantTexts(turn)).toEqual([\"alpha\", \"beta\", \"gamma\"])\n  })\n\n  it(\"drops refusal blocks and non-assistant messages\", () => {\n    const turn = turnOf([\n      Items.userText(\"ignored\"),\n      {\n        type: \"message\",\n        role: \"assistant\",\n        content: [\n          { type: \"output_text\", text: \"kept\" },\n          { type: \"refusal\", text: \"I can't help with that.\" },\n        ],\n      },\n    ])\n\n    expect(Turn.assistantTexts(turn)).toEqual([\"kept\"])\n  })\n\n  it(\"returns an empty array when there's nothing to extract\", () => {\n    expect(Turn.assistantTexts(turnOf([]))).toEqual([])\n    expect(Turn.assistantTexts(turnOf([Items.userText(\"only user\")]))).toEqual([])\n  })\n\n  it(\"composes with caller-chosen separators\", () => {\n    const turn = turnOf([Items.assistantText(\"hello\"), Items.assistantText(\"world\")])\n\n    expect(Turn.assistantTexts(turn).join(\"\")).toBe(\"helloworld\")\n    expect(Turn.assistantTexts(turn).join(\" \")).toBe(\"hello world\")\n    expect(Turn.assistantTexts(turn).join(\"\\n\")).toBe(\"hello\\nworld\")\n  })\n})\n\ndescribe(\"Turn.assistantText\", () => {\n  it(\"concatenates output_text across a single assistant message's content blocks\", () => {\n    const turn = turnOf([\n      {\n        type: \"message\",\n        role: \"assistant\",\n        content: [\n          { type: \"output_text\", text: \"hello \" },\n          { type: \"output_text\", text: \"world\" },\n        ],\n      },\n    ])\n\n    expect(Turn.assistantText(turn)).toBe(\"hello world\")\n  })\n\n  it(\"concatenates output_text across multiple assistant messages\", () => {\n    const turn = turnOf([Items.assistantText(\"first \"), Items.assistantText(\"second\")])\n\n    expect(Turn.assistantText(turn)).toBe(\"first second\")\n  })\n\n  it(\"ignores non-assistant messages\", () => {\n    const turn = turnOf([\n      Items.userText(\"ignored\"),\n      Items.systemText(\"also ignored\"),\n      Items.assistantText(\"kept\"),\n    ])\n\n    expect(Turn.assistantText(turn)).toBe(\"kept\")\n  })\n\n  it(\"ignores non-output_text content blocks (refusals, etc.)\", () => {\n    const turn = turnOf([\n      {\n        type: \"message\",\n        role: \"assistant\",\n        content: [\n          { type: \"output_text\", text: \"before \" },\n          { type: \"refusal\", text: \"I can't help with that.\" },\n          { type: \"output_text\", text: \"after\" },\n        ],\n      },\n    ])\n\n    expect(Turn.assistantText(turn)).toBe(\"before after\")\n  })\n\n  it(\"ignores function_call items even when interleaved with messages\", () => {\n    const turn = turnOf([\n      Items.assistantText(\"text \"),\n      { type: \"function_call\", call_id: \"c1\", name: \"search\", arguments: \"{}\" },\n      Items.assistantText(\"more text\"),\n    ])\n\n    expect(Turn.assistantText(turn)).toBe(\"text more text\")\n  })\n\n  it(\"returns the empty string when no assistant messages exist\", () => {\n    expect(Turn.assistantText(turnOf([]))).toBe(\"\")\n    expect(Turn.assistantText(turnOf([Items.userText(\"only user\")]))).toBe(\"\")\n  })\n\n  it(\"returns the empty string when the assistant message has no output_text blocks\", () => {\n    const turn = turnOf([\n      {\n        type: \"message\",\n        role: \"assistant\",\n        content: [{ type: \"refusal\", text: \"I can't help.\" }],\n      },\n    ])\n\n    expect(Turn.assistantText(turn)).toBe(\"\")\n  })\n})\n"],"mappings":"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"}

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

@@ -1,6 +1,4 @@
-import { i as ImageSource } from "../Image-C4vuBmu0.mjs";
-
-//#region src/embedding-model/Embedding.d.ts
+import { i as ImageSource } from "../Image-BK8-4H6s.mjs";
 declare namespace Embedding_d_exports {
   export { BinaryEmbedding, EmbedContentPart, EmbedInput, Embedding, EmbeddingFor, Float32Embedding, Int8Embedding, MultivectorEmbedding, ResponseEncoding, SparseEmbedding, Usage, isBinary, isFloat32, isInt8, isMultivector, isSparse };
 }

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;;;;;;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"}
+{"version":3,"file":"Embedding.d.mts","names":[],"sources":["../../src/embedding-model/Embedding.ts"],"mappings":";;;;;;;;;KAOY;WAA8B;;WAA4B,OAAO;;;;;;;;;;;KAWjE;WAEG;;WACA,OAAO;;WACP,SAAS,cAAc;;;KAY1B;WACD;WACA,QAAQ;;;;;;KAOP;WACD;WACA,QAAQ;;;;;;;KAQP;WACD;WACA,QAAQ;;;;;;;;;;;;;;;;;;;;KAqBP;WACD;WACA,SAAS,SAAS;;;;;;;;;;;;KAajB;WACD;WACA,SAAS,cAAc;;KAGtB,YACR,mBACA,gBACA,kBACA,kBACA;cAES,YAAS,GAAO,cAAY,KAAK;cACjC,SAAM,GAAO,cAAY,KAAK;cAC9B,WAAQ,GAAO,cAAY,KAAK;cAChC,WAAQ,GAAO,cAAY,KAAK;cAChC,gBAAa,GAAO,cAAY,KAAK;;;;;;;;;;KAWtC;;;;;;;;;;;;KAaA,aAAa,MAAM,qCAC3B,oBACC,sBACC,iBACC,wBACC,mBACC,wBACC,mBACC,6BACC,uBACA;;;;;;KAOA;WACD"}

package/dist/embedding-model/Embedding.mjs

@@ -1,4 +1,4 @@
-import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { n as __exportAll } from "../rolldown-runtime-EAsCxrDo.mjs";
 //#region src/embedding-model/Embedding.ts
 var Embedding_exports = /* @__PURE__ */ __exportAll({
 	isBinary: () => isBinary,

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

@@ -1,8 +1,6 @@
-import { t as AiError } from "../AiError-Bf1pq4BB.mjs";
+import { t as AiError } from "../AiError-eLV9t1lU.mjs";
 import { EmbedInput, EmbeddingFor, ResponseEncoding, Usage } from "./Embedding.mjs";
 import { Context, Effect } from "effect";
-
-//#region src/embedding-model/EmbeddingModel.d.ts
 declare namespace EmbeddingModel_d_exports {
   export { CommonEmbedManyRequest, CommonEmbedRequest, EmbedEncoding, EmbedManyResponse, EmbedResponse, EmbeddingModel, EmbeddingModelService, assertEncoding, embed, embedMany };
 }

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

@@ -1 +1 @@
-{"version":3,"file":"EmbeddingModel.d.mts","names":[],"sources":["../../src/embedding-model/EmbeddingModel.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAyBA;;;;;AAYA;KAZY,aAAA;;;;;;;;;;;KAYA,kBAAA;EAAA,SACD,KAAA,EAAO,UAAA;EAiCgB;;;;EAAA,SA5BvB,KAAA;EA6BQ;;;;;;;EAAA,SArBR,IAAA;EAqBgC;;AAU3C;;;EAV2C,SAfhC,UAAA;EA0BwB;;;;;EAAA,SApBxB,QAAA,GAAW,aAAA;AAAA;;;;;;KAQV,sBAAA,GAAyB,IAAA,CAAK,kBAAA;EAAA,SAC/B,MAAA,EAAQ,aAAA,CAAc,UAAA;AAAA;;;;;;;;KAUrB,aAAA,WAAwB,gBAAA;EAAA,SACzB,SAAA,EAAW,YAAA,CAAa,CAAA;EAAA,SACxB,KAAA,EAAO,KAAA;AAAA;;KAIN,iBAAA,WAA4B,gBAAA;EAAA,SAC7B,UAAA,EAAY,aAAA,CAAc,YAAA,CAAa,CAAA;EAAA,SACvC,KAAA,EAAO,KAAA;AAAA;AAAA,KAGN,qBAAA;EAAA,SACD,KAAA,aAAkB,aAAA,0BACzB,OAAA,EAAS,IAAA,CAAK,kBAAA;IAAA,SAA6C,QAAA,GAAW,CAAA;EAAA,MACnE,MAAA,CAAO,MAAA,CAAO,aAAA,CAAc,CAAA,GAAI,OAAA;EAAA,SAC5B,SAAA,aAAsB,aAAA,0BAC7B,OAAA,EAAS,IAAA,CAAK,sBAAA;IAAA,SAAiD,QAAA,GAAW,CAAA;EAAA,MACvE,MAAA,CAAO,MAAA,CAAO,iBAAA,CAAkB,CAAA,GAAI,OAAA;AAAA;AAAA,cAC1C,mBAAA;cAEY,cAAA,SAAuB,mBAAA;;cAKvB,KAAA,aAAmB,aAAA,0BAC9B,OAAA,EAAS,IAAA,CAAK,kBAAA;EAAA,SAA6C,QAAA,GAAW,CAAA;AAAA,MACrE,MAAA,CAAO,MAAA,CAAO,aAAA,CAAc,CAAA,GAAI,OAAA,EAAiB,cAAA;;cAIvC,SAAA,aAAuB,aAAA,0BAClC,OAAA,EAAS,IAAA,CAAK,sBAAA;EAAA,SAAiD,QAAA,GAAW,CAAA;AAAA,MACzE,MAAA,CAAO,MAAA,CAAO,iBAAA,CAAkB,CAAA,GAAI,OAAA,EAAiB,cAAA;;;;;;;;;;;;;cAe3C,cAAA,GACX,QAAA,EAAU,aAAA,cACV,SAAA,EAAW,aAAA,CAAc,aAAA,GACzB,QAAA,aACC,MAAA,CAAO,MAAA,OAAa,OAAA"}
+{"version":3,"file":"EmbeddingModel.d.mts","names":[],"sources":["../../src/embedding-model/EmbeddingModel.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;KAyBY;;;;;;;;;;;KAYA;WACD,OAAO;;;;;WAKP;;;;;;;;WAQA;;;;;;WAMA;;;;;;WAMA,WAAW;;;;;;;KAQV,yBAAyB,KAAK;WAC/B,QAAQ,cAAc;;;;;;;;;KAUrB,cAAc,UAAU;WACzB,WAAW,aAAa;WACxB,OAAO;;;KAIN,kBAAkB,UAAU;WAC7B,YAAY,cAAc,aAAa;WACvC,OAAO;;KAGN;WACD,QAAQ,UAAU,uCACzB,SAAS,KAAK;aAA6C,WAAW;QACnE,OAAO,OAAO,cAAc,IAAI;WAC5B,YAAY,UAAU,uCAC7B,SAAS,KAAK;aAAiD,WAAW;QACvE,OAAO,OAAO,kBAAkB,IAAI;;;cAG9B,uBAAuB;;cAKvB,QAAS,UAAU,uCAAqC,SAC1D,KAAK;WAA6C,WAAW;MACrE,OAAO,OAAO,cAAc,IAAI,SAAiB;;cAIvC,YAAa,UAAU,uCAAqC,SAC9D,KAAK;WAAiD,WAAW;MACzE,OAAO,OAAO,kBAAkB,IAAI,SAAiB;;;;;;;;;;;;;cAe3C,iBAAc,UACf,2BAAyB,WACxB,cAAc,gBAAc,qBAEtC,OAAO,aAAa"}

package/dist/embedding-model/EmbeddingModel.mjs

@@ -1,4 +1,4 @@
-import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { n as __exportAll } from "../rolldown-runtime-EAsCxrDo.mjs";
 import { Unsupported } from "../domain/AiError.mjs";
 import { Context, Effect } from "effect";
 //#region src/embedding-model/EmbeddingModel.ts

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

@@ -1 +1 @@
-{"version":3,"file":"EmbeddingModel.mjs","names":["AiError.Unsupported"],"sources":["../../src/embedding-model/EmbeddingModel.ts"],"sourcesContent":["import { Context, Effect } from \"effect\"\nimport * as AiError from \"../domain/AiError.js\"\nimport type { EmbeddingFor, EmbedInput, ResponseEncoding, Usage } from \"./Embedding.js\"\n\n/**\n * Output representation requested from the provider. Cross-provider dense\n * quantization only, the same vector at different storage cost:\n * - `float32`: universal default.\n * - `int8`: ~4x smaller, minimal recall loss on most benchmarks. Supported\n *   by Cohere, Voyage, Jina (binary only), Mixedbread.\n * - `binary`: ~32x smaller, meaningful recall loss but pairs well with a\n *   float32 reranker pass over a small candidate set.\n *\n * Non-dense representations (`sparse`, `multivector`) are a different vector\n * *structure*, not a storage option, and are produced by Jina only. They\n * live on `JinaEncoding`, not here (the same widening pattern `task` uses).\n * The response `Embedding` union still carries all arms, see\n * {@link ResponseEncoding}.\n *\n * Each provider's typed request narrows this to its supported set. On the\n * generic `EmbeddingModel` path, a provider that emits float32 only (OpenAI,\n * Gemini) rejects a non-float32 encoding with `AiError.Unsupported`\n * (bucket 1) via {@link assertEncoding}, rather than silently returning a\n * mislabeled float32 vector.\n */\nexport type EmbedEncoding = \"float32\" | \"int8\" | \"binary\"\n\n/**\n * Cross-provider single-embed request. Mirrors the shape of\n * `LanguageModel.CommonRequest`: cross-cutting fields here, vendor\n * specifics in the provider's typed request.\n *\n * Provider-specific extensions (Cohere widened `task` enum, Jina LoRA\n * tasks, Mixedbread free-form `prompt`, etc.) live in that provider's own\n * request interface, which extends this and narrows `model` / widens\n * `task`.\n */\nexport type CommonEmbedRequest = {\n  readonly input: EmbedInput\n  /**\n   * Model identifier. Each provider narrows this to its typed literal\n   * union, so code that yields a typed provider tag gets autocompletion.\n   */\n  readonly model: string\n  /**\n   * Retrieval-task hint. Applies to the input. OpenAI ignores this;\n   * Mixedbread doesn't have it; Cohere v3+ requires it on the wire (typed\n   * as required in `CohereEmbedRequest`). Provider-specific task enums\n   * (classification, clustering, code retrieval, …) live on the\n   * provider's own request type.\n   */\n  readonly task?: \"query\" | \"document\"\n  /**\n   * Matryoshka truncation. Default: provider's native dimension.\n   * Discrete-value providers (Cohere, Vertex `multimodalembedding@001`)\n   * narrow this to a literal union in their typed request.\n   */\n  readonly dimensions?: number\n  /**\n   * Output representation - see {@link EmbedEncoding}. Dense float32 is the\n   * default; provider layers reject unsupported values up front with\n   * `InvalidRequest`.\n   */\n  readonly encoding?: EmbedEncoding\n}\n\n/**\n * Cross-provider batch-embed request. One `task` for the whole batch -\n * mixed-task batches aren't a real provider feature (rerankers exist for\n * that).\n */\nexport type CommonEmbedManyRequest = Omit<CommonEmbedRequest, \"input\"> & {\n  readonly inputs: ReadonlyArray<EmbedInput>\n}\n\n/**\n * Single-embed response. The `embedding` type is determined by the\n * request's `encoding` field via `EmbeddingFor<E>` — callers that don't\n * specify an encoding get a `Float32Embedding` directly with no runtime\n * narrowing. Defaults to `undefined` for back-compat with consumers that\n * use the bare `EmbedResponse` name.\n */\nexport type EmbedResponse<E extends ResponseEncoding | undefined = undefined> = {\n  readonly embedding: EmbeddingFor<E>\n  readonly usage: Usage\n}\n\n/** Batch-embed response. Same encoding rule as {@link EmbedResponse}. */\nexport type EmbedManyResponse<E extends ResponseEncoding | undefined = undefined> = {\n  readonly embeddings: ReadonlyArray<EmbeddingFor<E>>\n  readonly usage: Usage\n}\n\nexport type EmbeddingModelService = {\n  readonly embed: <E extends EmbedEncoding | undefined = undefined>(\n    request: Omit<CommonEmbedRequest, \"encoding\"> & { readonly encoding?: E },\n  ) => Effect.Effect<EmbedResponse<E>, AiError.AiError>\n  readonly embedMany: <E extends EmbedEncoding | undefined = undefined>(\n    request: Omit<CommonEmbedManyRequest, \"encoding\"> & { readonly encoding?: E },\n  ) => Effect.Effect<EmbedManyResponse<E>, AiError.AiError>\n}\n\nexport class EmbeddingModel extends Context.Service<EmbeddingModel, EmbeddingModelService>()(\n  \"@betalyra/effect-uai/EmbeddingModel\",\n) {}\n\n/** Embed a single input. */\nexport const embed = <E extends EmbedEncoding | undefined = undefined>(\n  request: Omit<CommonEmbedRequest, \"encoding\"> & { readonly encoding?: E },\n): Effect.Effect<EmbedResponse<E>, AiError.AiError, EmbeddingModel> =>\n  Effect.flatMap(EmbeddingModel, (m) => m.embed(request))\n\n/** Embed a batch in one provider call. Same `task` for every input. */\nexport const embedMany = <E extends EmbedEncoding | undefined = undefined>(\n  request: Omit<CommonEmbedManyRequest, \"encoding\"> & { readonly encoding?: E },\n): Effect.Effect<EmbedManyResponse<E>, AiError.AiError, EmbeddingModel> =>\n  Effect.flatMap(EmbeddingModel, (m) => m.embedMany(request))\n\n/**\n * Guard a requested `encoding` against a provider's supported set. Returns\n * `void` when the encoding is unset or supported, and fails\n * `AiError.Unsupported` (bucket 1) otherwise.\n *\n * Used by the generic-tag registration of providers that emit a strict\n * subset of `EmbedEncoding`: OpenAI / Gemini pass `[\"float32\"]`, Jina passes\n * `[\"float32\", \"binary\"]`. Without this guard, a non-supported encoding on\n * the generic path silently returns a float32 vector mislabeled as the\n * requested type (the `as`-cast lie), which breaks downstream storage and\n * vector math.\n */\nexport const assertEncoding = (\n  encoding: EmbedEncoding | undefined,\n  supported: ReadonlyArray<EmbedEncoding>,\n  provider: string,\n): Effect.Effect<void, AiError.AiError> =>\n  encoding === undefined || supported.includes(encoding)\n    ? Effect.void\n    : Effect.fail(\n        new AiError.Unsupported({\n          provider,\n          capability: \"encoding\",\n          reason: `${provider} emits ${supported.join(\" / \")} only; encoding=\"${encoding}\" is unavailable.`,\n        }),\n      )\n"],"mappings":";;;;;;;;;;AAsGA,IAAa,iBAAb,cAAoC,QAAQ,SAAgD,CAC1F,sCACD,CAAC;;AAGF,MAAa,SACX,YAEA,OAAO,QAAQ,iBAAiB,MAAM,EAAE,MAAM,QAAQ,CAAC;;AAGzD,MAAa,aACX,YAEA,OAAO,QAAQ,iBAAiB,MAAM,EAAE,UAAU,QAAQ,CAAC;;;;;;;;;;;;;AAc7D,MAAa,kBACX,UACA,WACA,aAEA,aAAa,KAAA,KAAa,UAAU,SAAS,SAAS,GAClD,OAAO,OACP,OAAO,KACL,IAAIA,YAAoB;CACtB;CACA,YAAY;CACZ,QAAQ,GAAG,SAAS,SAAS,UAAU,KAAK,MAAM,CAAC,mBAAmB,SAAS;CAChF,CAAC,CACH"}
+{"version":3,"file":"EmbeddingModel.mjs","names":["AiError.Unsupported"],"sources":["../../src/embedding-model/EmbeddingModel.ts"],"sourcesContent":["import { Context, Effect } from \"effect\"\nimport * as AiError from \"../domain/AiError.js\"\nimport type { EmbeddingFor, EmbedInput, ResponseEncoding, Usage } from \"./Embedding.js\"\n\n/**\n * Output representation requested from the provider. Cross-provider dense\n * quantization only, the same vector at different storage cost:\n * - `float32`: universal default.\n * - `int8`: ~4x smaller, minimal recall loss on most benchmarks. Supported\n *   by Cohere, Voyage, Jina (binary only), Mixedbread.\n * - `binary`: ~32x smaller, meaningful recall loss but pairs well with a\n *   float32 reranker pass over a small candidate set.\n *\n * Non-dense representations (`sparse`, `multivector`) are a different vector\n * *structure*, not a storage option, and are produced by Jina only. They\n * live on `JinaEncoding`, not here (the same widening pattern `task` uses).\n * The response `Embedding` union still carries all arms, see\n * {@link ResponseEncoding}.\n *\n * Each provider's typed request narrows this to its supported set. On the\n * generic `EmbeddingModel` path, a provider that emits float32 only (OpenAI,\n * Gemini) rejects a non-float32 encoding with `AiError.Unsupported`\n * (bucket 1) via {@link assertEncoding}, rather than silently returning a\n * mislabeled float32 vector.\n */\nexport type EmbedEncoding = \"float32\" | \"int8\" | \"binary\"\n\n/**\n * Cross-provider single-embed request. Mirrors the shape of\n * `LanguageModel.CommonRequest`: cross-cutting fields here, vendor\n * specifics in the provider's typed request.\n *\n * Provider-specific extensions (Cohere widened `task` enum, Jina LoRA\n * tasks, Mixedbread free-form `prompt`, etc.) live in that provider's own\n * request interface, which extends this and narrows `model` / widens\n * `task`.\n */\nexport type CommonEmbedRequest = {\n  readonly input: EmbedInput\n  /**\n   * Model identifier. Each provider narrows this to its typed literal\n   * union, so code that yields a typed provider tag gets autocompletion.\n   */\n  readonly model: string\n  /**\n   * Retrieval-task hint. Applies to the input. OpenAI ignores this;\n   * Mixedbread doesn't have it; Cohere v3+ requires it on the wire (typed\n   * as required in `CohereEmbedRequest`). Provider-specific task enums\n   * (classification, clustering, code retrieval, …) live on the\n   * provider's own request type.\n   */\n  readonly task?: \"query\" | \"document\"\n  /**\n   * Matryoshka truncation. Default: provider's native dimension.\n   * Discrete-value providers (Cohere, Vertex `multimodalembedding@001`)\n   * narrow this to a literal union in their typed request.\n   */\n  readonly dimensions?: number\n  /**\n   * Output representation - see {@link EmbedEncoding}. Dense float32 is the\n   * default; provider layers reject unsupported values up front with\n   * `InvalidRequest`.\n   */\n  readonly encoding?: EmbedEncoding\n}\n\n/**\n * Cross-provider batch-embed request. One `task` for the whole batch -\n * mixed-task batches aren't a real provider feature (rerankers exist for\n * that).\n */\nexport type CommonEmbedManyRequest = Omit<CommonEmbedRequest, \"input\"> & {\n  readonly inputs: ReadonlyArray<EmbedInput>\n}\n\n/**\n * Single-embed response. The `embedding` type is determined by the\n * request's `encoding` field via `EmbeddingFor<E>` — callers that don't\n * specify an encoding get a `Float32Embedding` directly with no runtime\n * narrowing. Defaults to `undefined` for back-compat with consumers that\n * use the bare `EmbedResponse` name.\n */\nexport type EmbedResponse<E extends ResponseEncoding | undefined = undefined> = {\n  readonly embedding: EmbeddingFor<E>\n  readonly usage: Usage\n}\n\n/** Batch-embed response. Same encoding rule as {@link EmbedResponse}. */\nexport type EmbedManyResponse<E extends ResponseEncoding | undefined = undefined> = {\n  readonly embeddings: ReadonlyArray<EmbeddingFor<E>>\n  readonly usage: Usage\n}\n\nexport type EmbeddingModelService = {\n  readonly embed: <E extends EmbedEncoding | undefined = undefined>(\n    request: Omit<CommonEmbedRequest, \"encoding\"> & { readonly encoding?: E },\n  ) => Effect.Effect<EmbedResponse<E>, AiError.AiError>\n  readonly embedMany: <E extends EmbedEncoding | undefined = undefined>(\n    request: Omit<CommonEmbedManyRequest, \"encoding\"> & { readonly encoding?: E },\n  ) => Effect.Effect<EmbedManyResponse<E>, AiError.AiError>\n}\n\nexport class EmbeddingModel extends Context.Service<EmbeddingModel, EmbeddingModelService>()(\n  \"@betalyra/effect-uai/EmbeddingModel\",\n) {}\n\n/** Embed a single input. */\nexport const embed = <E extends EmbedEncoding | undefined = undefined>(\n  request: Omit<CommonEmbedRequest, \"encoding\"> & { readonly encoding?: E },\n): Effect.Effect<EmbedResponse<E>, AiError.AiError, EmbeddingModel> =>\n  Effect.flatMap(EmbeddingModel, (m) => m.embed(request))\n\n/** Embed a batch in one provider call. Same `task` for every input. */\nexport const embedMany = <E extends EmbedEncoding | undefined = undefined>(\n  request: Omit<CommonEmbedManyRequest, \"encoding\"> & { readonly encoding?: E },\n): Effect.Effect<EmbedManyResponse<E>, AiError.AiError, EmbeddingModel> =>\n  Effect.flatMap(EmbeddingModel, (m) => m.embedMany(request))\n\n/**\n * Guard a requested `encoding` against a provider's supported set. Returns\n * `void` when the encoding is unset or supported, and fails\n * `AiError.Unsupported` (bucket 1) otherwise.\n *\n * Used by the generic-tag registration of providers that emit a strict\n * subset of `EmbedEncoding`: OpenAI / Gemini pass `[\"float32\"]`, Jina passes\n * `[\"float32\", \"binary\"]`. Without this guard, a non-supported encoding on\n * the generic path silently returns a float32 vector mislabeled as the\n * requested type (the `as`-cast lie), which breaks downstream storage and\n * vector math.\n */\nexport const assertEncoding = (\n  encoding: EmbedEncoding | undefined,\n  supported: ReadonlyArray<EmbedEncoding>,\n  provider: string,\n): Effect.Effect<void, AiError.AiError> =>\n  encoding === undefined || supported.includes(encoding)\n    ? Effect.void\n    : Effect.fail(\n        new AiError.Unsupported({\n          provider,\n          capability: \"encoding\",\n          reason: `${provider} emits ${supported.join(\" / \")} only; encoding=\"${encoding}\" is unavailable.`,\n        }),\n      )\n"],"mappings":";;;;;;;;;;AAsGA,IAAa,iBAAb,cAAoC,QAAQ,QAA+C,CAAC,CAC1F,qCACF,CAAC,CAAC,CAAC;;AAGH,MAAa,SACX,YAEA,OAAO,QAAQ,iBAAiB,MAAM,EAAE,MAAM,OAAO,CAAC;;AAGxD,MAAa,aACX,YAEA,OAAO,QAAQ,iBAAiB,MAAM,EAAE,UAAU,OAAO,CAAC;;;;;;;;;;;;;AAc5D,MAAa,kBACX,UACA,WACA,aAEA,aAAa,KAAA,KAAa,UAAU,SAAS,QAAQ,IACjD,OAAO,OACP,OAAO,KACL,IAAIA,YAAoB;CACtB;CACA,YAAY;CACZ,QAAQ,GAAG,SAAS,SAAS,UAAU,KAAK,KAAK,EAAE,mBAAmB,SAAS;AACjF,CAAC,CACH"}

package/dist/embedding-model/EmbeddingModel.test.d.mts

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

package/dist/embedding-model/EmbeddingModel.test.mjs

@@ -1,5 +1,6 @@
 import { embed, embedMany } from "./EmbeddingModel.mjs";
-import { c as it, o as describe, t as import_dist } from "../dist-CcRV3-A5.mjs";
+import { m as it, o as describe } from "../utils-CiH_DjFW.mjs";
+import { t as import_dist } from "../dist-BaenoU1A.mjs";
 //#region src/embedding-model/EmbeddingModel.test.ts
 describe("EmbedResponse<E> conditional narrowing", () => {
 	it("defaults to Float32Embedding when E is undefined", () => {
@@ -26,24 +27,27 @@ describe("EmbedManyResponse<E> mirrors EmbedResponse<E>", () => {
 });
 describe("embed / embedMany free exports preserve E in their return type", () => {
 	it("embed with no encoding returns EmbedResponse<undefined> = Float32", () => {
-		(0, import_dist.expectTypeOf)(embed({
+		const result = embed({
 			input: "x",
 			model: "m"
-		})).toEqualTypeOf();
+		});
+		(0, import_dist.expectTypeOf)(result).toEqualTypeOf();
 	});
 	it("embed with encoding: int8 returns EmbedResponse<int8>", () => {
-		(0, import_dist.expectTypeOf)(embed({
+		const result = embed({
 			input: "x",
 			model: "m",
 			encoding: "int8"
-		})).toEqualTypeOf();
+		});
+		(0, import_dist.expectTypeOf)(result).toEqualTypeOf();
 	});
 	it("embedMany with encoding: binary returns EmbedManyResponse<binary>", () => {
-		(0, import_dist.expectTypeOf)(embedMany({
+		const result = embedMany({
 			inputs: ["x"],
 			model: "m",
 			encoding: "binary"
-		})).toEqualTypeOf();
+		});
+		(0, import_dist.expectTypeOf)(result).toEqualTypeOf();
 	});
 	it("rejects non-dense encodings on the generic path (trimmed EmbedEncoding)", () => {
 		embedMany({
@@ -58,11 +62,12 @@ describe("embed / embedMany free exports preserve E in their return type", () =>
 		});
 	});
 	it("when the request is widened to CommonEmbedRequest, the response is the open union", () => {
-		(0, import_dist.expectTypeOf)(embed({
+		const result = embed({
 			input: "x",
 			model: "m",
 			encoding: "int8"
-		})).toEqualTypeOf();
+		});
+		(0, import_dist.expectTypeOf)(result).toEqualTypeOf();
 	});
 });
 //#endregion

package/dist/embedding-model/EmbeddingModel.test.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"EmbeddingModel.test.mjs","names":[],"sources":["../../src/embedding-model/EmbeddingModel.test.ts"],"sourcesContent":["import { Effect } from \"effect\"\nimport { describe, expectTypeOf, it } from \"vitest\"\nimport type * as AiError from \"../domain/AiError.js\"\nimport type {\n  BinaryEmbedding,\n  Float32Embedding,\n  Int8Embedding,\n  MultivectorEmbedding,\n  SparseEmbedding,\n} from \"./Embedding.js\"\nimport {\n  type EmbedEncoding,\n  embed,\n  embedMany,\n  type EmbedManyResponse,\n  type EmbedResponse,\n  EmbeddingModel,\n} from \"./EmbeddingModel.js\"\n\n// Type-level tests only. The actual narrowing happens at the type system\n// boundary — the runtime impl is exercised in provider-specific test files.\ndescribe(\"EmbedResponse<E> conditional narrowing\", () => {\n  it(\"defaults to Float32Embedding when E is undefined\", () => {\n    expectTypeOf<EmbedResponse>().toEqualTypeOf<{\n      readonly embedding: Float32Embedding\n      readonly usage: import(\"./Embedding.js\").Usage\n    }>()\n  })\n\n  it(\"maps each encoding literal to the matching Embedding variant\", () => {\n    expectTypeOf<EmbedResponse<\"float32\">[\"embedding\"]>().toEqualTypeOf<Float32Embedding>()\n    expectTypeOf<EmbedResponse<\"int8\">[\"embedding\"]>().toEqualTypeOf<Int8Embedding>()\n    expectTypeOf<EmbedResponse<\"binary\">[\"embedding\"]>().toEqualTypeOf<BinaryEmbedding>()\n    expectTypeOf<EmbedResponse<\"sparse\">[\"embedding\"]>().toEqualTypeOf<SparseEmbedding>()\n    expectTypeOf<EmbedResponse<\"multivector\">[\"embedding\"]>().toEqualTypeOf<MultivectorEmbedding>()\n  })\n\n  it(\"falls back to the open Embedding union when E is the full EmbedEncoding\", () => {\n    expectTypeOf<EmbedResponse<EmbedEncoding>[\"embedding\"]>().toEqualTypeOf<\n      Float32Embedding | Int8Embedding | BinaryEmbedding | SparseEmbedding | MultivectorEmbedding\n    >()\n  })\n})\n\ndescribe(\"EmbedManyResponse<E> mirrors EmbedResponse<E>\", () => {\n  it(\"defaults to ReadonlyArray<Float32Embedding>\", () => {\n    expectTypeOf<EmbedManyResponse[\"embeddings\"]>().toEqualTypeOf<ReadonlyArray<Float32Embedding>>()\n  })\n\n  it(\"narrows per encoding\", () => {\n    expectTypeOf<EmbedManyResponse<\"int8\">[\"embeddings\"]>().toEqualTypeOf<\n      ReadonlyArray<Int8Embedding>\n    >()\n  })\n})\n\ndescribe(\"embed / embedMany free exports preserve E in their return type\", () => {\n  it(\"embed with no encoding returns EmbedResponse<undefined> = Float32\", () => {\n    const result = embed({ input: \"x\", model: \"m\" })\n    expectTypeOf(result).toEqualTypeOf<\n      Effect.Effect<EmbedResponse<undefined>, AiError.AiError, EmbeddingModel>\n    >()\n  })\n\n  it(\"embed with encoding: int8 returns EmbedResponse<int8>\", () => {\n    const result = embed({ input: \"x\", model: \"m\", encoding: \"int8\" })\n    expectTypeOf(result).toEqualTypeOf<\n      Effect.Effect<EmbedResponse<\"int8\">, AiError.AiError, EmbeddingModel>\n    >()\n  })\n\n  it(\"embedMany with encoding: binary returns EmbedManyResponse<binary>\", () => {\n    const result = embedMany({ inputs: [\"x\"], model: \"m\", encoding: \"binary\" })\n    expectTypeOf(result).toEqualTypeOf<\n      Effect.Effect<EmbedManyResponse<\"binary\">, AiError.AiError, EmbeddingModel>\n    >()\n  })\n\n  it(\"rejects non-dense encodings on the generic path (trimmed EmbedEncoding)\", () => {\n    // `sparse` / `multivector` are Jina-only representation kinds, not part\n    // of the cross-provider request set. Requesting them on the generic\n    // helper is a compile error; they're reachable only via the typed\n    // `JinaEmbedding` tag.\n    // These calls exist only to assert the encoding is a compile error; they\n    // are intentionally never run, so the floating-effect check is off here.\n    // @effect-diagnostics effect/floatingEffect:off\n    // @ts-expect-error \"multivector\" is not an EmbedEncoding\n    embedMany({ inputs: [\"x\"], model: \"m\", encoding: \"multivector\" })\n    // @ts-expect-error \"sparse\" is not an EmbedEncoding\n    embed({ input: \"x\", model: \"m\", encoding: \"sparse\" })\n    // @effect-diagnostics effect/floatingEffect:error\n  })\n\n  it(\"when the request is widened to CommonEmbedRequest, the response is the open union\", () => {\n    // Demonstrates the documented case: annotating the request type erases\n    // the literal `encoding` and the response falls back to `Embedding`.\n    const req: { input: string; model: string; encoding?: EmbedEncoding } = {\n      input: \"x\",\n      model: \"m\",\n      encoding: \"int8\",\n    }\n    const result = embed(req)\n    expectTypeOf(result).toEqualTypeOf<\n      Effect.Effect<EmbedResponse<EmbedEncoding>, AiError.AiError, EmbeddingModel>\n    >()\n  })\n})\n"],"mappings":";;;AAqBA,SAAS,gDAAgD;AACvD,IAAG,0DAA0D;AAC3D,GAAA,GAAA,YAAA,eAA6B,CAAC,eAG1B;GACJ;AAEF,IAAG,sEAAsE;AACvE,GAAA,GAAA,YAAA,eAAqD,CAAC,eAAiC;AACvF,GAAA,GAAA,YAAA,eAAkD,CAAC,eAA8B;AACjF,GAAA,GAAA,YAAA,eAAoD,CAAC,eAAgC;AACrF,GAAA,GAAA,YAAA,eAAoD,CAAC,eAAgC;AACrF,GAAA,GAAA,YAAA,eAAyD,CAAC,eAAqC;GAC/F;AAEF,IAAG,iFAAiF;AAClF,GAAA,GAAA,YAAA,eAAyD,CAAC,eAEvD;GACH;EACF;AAEF,SAAS,uDAAuD;AAC9D,IAAG,qDAAqD;AACtD,GAAA,GAAA,YAAA,eAA+C,CAAC,eAAgD;GAChG;AAEF,IAAG,8BAA8B;AAC/B,GAAA,GAAA,YAAA,eAAuD,CAAC,eAErD;GACH;EACF;AAEF,SAAS,wEAAwE;AAC/E,IAAG,2EAA2E;AAE5E,GAAA,GAAA,YAAA,cADe,MAAM;GAAE,OAAO;GAAK,OAAO;GAAK,CAC5B,CAAC,CAAC,eAElB;GACH;AAEF,IAAG,+DAA+D;AAEhE,GAAA,GAAA,YAAA,cADe,MAAM;GAAE,OAAO;GAAK,OAAO;GAAK,UAAU;GAAQ,CAC9C,CAAC,CAAC,eAElB;GACH;AAEF,IAAG,2EAA2E;AAE5E,GAAA,GAAA,YAAA,cADe,UAAU;GAAE,QAAQ,CAAC,IAAI;GAAE,OAAO;GAAK,UAAU;GAAU,CACvD,CAAC,CAAC,eAElB;GACH;AAEF,IAAG,iFAAiF;AASlF,YAAU;GAAE,QAAQ,CAAC,IAAI;GAAE,OAAO;GAAK,UAAU;GAAe,CAAC;AAEjE,QAAM;GAAE,OAAO;GAAK,OAAO;GAAK,UAAU;GAAU,CAAC;GAErD;AAEF,IAAG,2FAA2F;AAS5F,GAAA,GAAA,YAAA,cADe,MAAM;GAJnB,OAAO;GACP,OAAO;GACP,UAAU;GAEY,CACL,CAAC,CAAC,eAElB;GACH;EACF"}
+{"version":3,"file":"EmbeddingModel.test.mjs","names":[],"sources":["../../src/embedding-model/EmbeddingModel.test.ts"],"sourcesContent":["import { Effect } from \"effect\"\nimport { describe, expectTypeOf, it } from \"vitest\"\nimport type * as AiError from \"../domain/AiError.js\"\nimport type {\n  BinaryEmbedding,\n  Float32Embedding,\n  Int8Embedding,\n  MultivectorEmbedding,\n  SparseEmbedding,\n} from \"./Embedding.js\"\nimport {\n  type EmbedEncoding,\n  embed,\n  embedMany,\n  type EmbedManyResponse,\n  type EmbedResponse,\n  EmbeddingModel,\n} from \"./EmbeddingModel.js\"\n\n// Type-level tests only. The actual narrowing happens at the type system\n// boundary — the runtime impl is exercised in provider-specific test files.\ndescribe(\"EmbedResponse<E> conditional narrowing\", () => {\n  it(\"defaults to Float32Embedding when E is undefined\", () => {\n    expectTypeOf<EmbedResponse>().toEqualTypeOf<{\n      readonly embedding: Float32Embedding\n      readonly usage: import(\"./Embedding.js\").Usage\n    }>()\n  })\n\n  it(\"maps each encoding literal to the matching Embedding variant\", () => {\n    expectTypeOf<EmbedResponse<\"float32\">[\"embedding\"]>().toEqualTypeOf<Float32Embedding>()\n    expectTypeOf<EmbedResponse<\"int8\">[\"embedding\"]>().toEqualTypeOf<Int8Embedding>()\n    expectTypeOf<EmbedResponse<\"binary\">[\"embedding\"]>().toEqualTypeOf<BinaryEmbedding>()\n    expectTypeOf<EmbedResponse<\"sparse\">[\"embedding\"]>().toEqualTypeOf<SparseEmbedding>()\n    expectTypeOf<EmbedResponse<\"multivector\">[\"embedding\"]>().toEqualTypeOf<MultivectorEmbedding>()\n  })\n\n  it(\"falls back to the open Embedding union when E is the full EmbedEncoding\", () => {\n    expectTypeOf<EmbedResponse<EmbedEncoding>[\"embedding\"]>().toEqualTypeOf<\n      Float32Embedding | Int8Embedding | BinaryEmbedding | SparseEmbedding | MultivectorEmbedding\n    >()\n  })\n})\n\ndescribe(\"EmbedManyResponse<E> mirrors EmbedResponse<E>\", () => {\n  it(\"defaults to ReadonlyArray<Float32Embedding>\", () => {\n    expectTypeOf<EmbedManyResponse[\"embeddings\"]>().toEqualTypeOf<ReadonlyArray<Float32Embedding>>()\n  })\n\n  it(\"narrows per encoding\", () => {\n    expectTypeOf<EmbedManyResponse<\"int8\">[\"embeddings\"]>().toEqualTypeOf<\n      ReadonlyArray<Int8Embedding>\n    >()\n  })\n})\n\ndescribe(\"embed / embedMany free exports preserve E in their return type\", () => {\n  it(\"embed with no encoding returns EmbedResponse<undefined> = Float32\", () => {\n    const result = embed({ input: \"x\", model: \"m\" })\n    expectTypeOf(result).toEqualTypeOf<\n      Effect.Effect<EmbedResponse<undefined>, AiError.AiError, EmbeddingModel>\n    >()\n  })\n\n  it(\"embed with encoding: int8 returns EmbedResponse<int8>\", () => {\n    const result = embed({ input: \"x\", model: \"m\", encoding: \"int8\" })\n    expectTypeOf(result).toEqualTypeOf<\n      Effect.Effect<EmbedResponse<\"int8\">, AiError.AiError, EmbeddingModel>\n    >()\n  })\n\n  it(\"embedMany with encoding: binary returns EmbedManyResponse<binary>\", () => {\n    const result = embedMany({ inputs: [\"x\"], model: \"m\", encoding: \"binary\" })\n    expectTypeOf(result).toEqualTypeOf<\n      Effect.Effect<EmbedManyResponse<\"binary\">, AiError.AiError, EmbeddingModel>\n    >()\n  })\n\n  it(\"rejects non-dense encodings on the generic path (trimmed EmbedEncoding)\", () => {\n    // `sparse` / `multivector` are Jina-only representation kinds, not part\n    // of the cross-provider request set. Requesting them on the generic\n    // helper is a compile error; they're reachable only via the typed\n    // `JinaEmbedding` tag.\n    // These calls exist only to assert the encoding is a compile error; they\n    // are intentionally never run, so the floating-effect check is off here.\n    // @effect-diagnostics effect/floatingEffect:off\n    // @ts-expect-error \"multivector\" is not an EmbedEncoding\n    embedMany({ inputs: [\"x\"], model: \"m\", encoding: \"multivector\" })\n    // @ts-expect-error \"sparse\" is not an EmbedEncoding\n    embed({ input: \"x\", model: \"m\", encoding: \"sparse\" })\n    // @effect-diagnostics effect/floatingEffect:error\n  })\n\n  it(\"when the request is widened to CommonEmbedRequest, the response is the open union\", () => {\n    // Demonstrates the documented case: annotating the request type erases\n    // the literal `encoding` and the response falls back to `Embedding`.\n    const req: { input: string; model: string; encoding?: EmbedEncoding } = {\n      input: \"x\",\n      model: \"m\",\n      encoding: \"int8\",\n    }\n    const result = embed(req)\n    expectTypeOf(result).toEqualTypeOf<\n      Effect.Effect<EmbedResponse<EmbedEncoding>, AiError.AiError, EmbeddingModel>\n    >()\n  })\n})\n"],"mappings":";;;;AAqBA,SAAS,gDAAgD;CACvD,GAAG,0DAA0D;EAC3D,CAAA,GAAA,YAAA,aAAA,CAA4B,CAAC,CAAC,cAG3B;CACL,CAAC;CAED,GAAG,sEAAsE;EACvE,CAAA,GAAA,YAAA,aAAA,CAAoD,CAAC,CAAC,cAAgC;EACtF,CAAA,GAAA,YAAA,aAAA,CAAiD,CAAC,CAAC,cAA6B;EAChF,CAAA,GAAA,YAAA,aAAA,CAAmD,CAAC,CAAC,cAA+B;EACpF,CAAA,GAAA,YAAA,aAAA,CAAmD,CAAC,CAAC,cAA+B;EACpF,CAAA,GAAA,YAAA,aAAA,CAAwD,CAAC,CAAC,cAAoC;CAChG,CAAC;CAED,GAAG,iFAAiF;EAClF,CAAA,GAAA,YAAA,aAAA,CAAwD,CAAC,CAAC,cAExD;CACJ,CAAC;AACH,CAAC;AAED,SAAS,uDAAuD;CAC9D,GAAG,qDAAqD;EACtD,CAAA,GAAA,YAAA,aAAA,CAA8C,CAAC,CAAC,cAA+C;CACjG,CAAC;CAED,GAAG,8BAA8B;EAC/B,CAAA,GAAA,YAAA,aAAA,CAAsD,CAAC,CAAC,cAEtD;CACJ,CAAC;AACH,CAAC;AAED,SAAS,wEAAwE;CAC/E,GAAG,2EAA2E;EAC5E,MAAM,SAAS,MAAM;GAAE,OAAO;GAAK,OAAO;EAAI,CAAC;EAC/C,CAAA,GAAA,YAAA,aAAA,CAAa,MAAM,CAAC,CAAC,cAEnB;CACJ,CAAC;CAED,GAAG,+DAA+D;EAChE,MAAM,SAAS,MAAM;GAAE,OAAO;GAAK,OAAO;GAAK,UAAU;EAAO,CAAC;EACjE,CAAA,GAAA,YAAA,aAAA,CAAa,MAAM,CAAC,CAAC,cAEnB;CACJ,CAAC;CAED,GAAG,2EAA2E;EAC5E,MAAM,SAAS,UAAU;GAAE,QAAQ,CAAC,GAAG;GAAG,OAAO;GAAK,UAAU;EAAS,CAAC;EAC1E,CAAA,GAAA,YAAA,aAAA,CAAa,MAAM,CAAC,CAAC,cAEnB;CACJ,CAAC;CAED,GAAG,iFAAiF;EASlF,UAAU;GAAE,QAAQ,CAAC,GAAG;GAAG,OAAO;GAAK,UAAU;EAAc,CAAC;EAEhE,MAAM;GAAE,OAAO;GAAK,OAAO;GAAK,UAAU;EAAS,CAAC;CAEtD,CAAC;CAED,GAAG,2FAA2F;EAQ5F,MAAM,SAAS,MAAM;GAJnB,OAAO;GACP,OAAO;GACP,UAAU;EAEW,CAAC;EACxB,CAAA,GAAA,YAAA,aAAA,CAAa,MAAM,CAAC,CAAC,cAEnB;CACJ,CAAC;AACH,CAAC"}

package/dist/index.d.mts

@@ -1,31 +1,31 @@
 import { t as BrowserError_d_exports } from "./browser/BrowserError.mjs";
 import { t as Browser_d_exports } from "./browser/Browser.mjs";
-import { a as Media_d_exports } from "./Media-D_CpcM1Z.mjs";
-import { o as Image_d_exports } from "./Image-C4vuBmu0.mjs";
-import { u as Items_d_exports } from "./Items-BWNu6VGp.mjs";
-import { _ as Tool_d_exports } from "./Tool-CXFHCQrT.mjs";
+import { a as Media_d_exports } from "./Media-DwgpifPD.mjs";
+import { o as Image_d_exports } from "./Image-BK8-4H6s.mjs";
+import { u as Items_d_exports } from "./Items-SfUabNuB.mjs";
+import { _ as Tool_d_exports } from "./Tool-DE-rnvkw.mjs";
 import { t as BrowserTool_d_exports } from "./browser/BrowserTool.mjs";
 import { t as Capabilities_d_exports } from "./capabilities/Capabilities.mjs";
-import { n as AiError_d_exports } from "./AiError-Bf1pq4BB.mjs";
-import { o as Audio_d_exports } from "./Audio-CR7CSljJ.mjs";
+import { n as AiError_d_exports } from "./AiError-eLV9t1lU.mjs";
+import { o as Audio_d_exports } from "./Audio-60lKKHxS.mjs";
 import { t as Citation_d_exports } from "./domain/Citation.mjs";
 import { t as Music_d_exports } from "./domain/Music.mjs";
 import { t as Job_d_exports } from "./job/Job.mjs";
-import { a as StructuredFormat_d_exports } from "./StructuredFormat-DHaUJBdd.mjs";
+import { a as StructuredFormat_d_exports } from "./StructuredFormat-BlZhyOsi.mjs";
 import { t as Turn_d_exports } from "./domain/Turn.mjs";
 import { t as Research_d_exports } from "./domain/Research.mjs";
 import { t as Transcript_d_exports } from "./domain/Transcript.mjs";
 import { t as Embedding_d_exports } from "./embedding-model/Embedding.mjs";
 import { t as EmbeddingModel_d_exports } from "./embedding-model/EmbeddingModel.mjs";
 import { t as DeepResearch_d_exports } from "./research/DeepResearch.mjs";
-import { t as Loop_d_exports } from "./Loop-D8nWpowc.mjs";
-import { n as ToolResult_d_exports } from "./ToolResult-CQqKkcDa.mjs";
-import { n as ToolEvent_d_exports } from "./ToolEvent-nVijCrvm.mjs";
-import { l as Toolkit_d_exports } from "./Toolkit-BYPwwu-j.mjs";
+import { t as Loop_d_exports } from "./Loop-B54AB1ME.mjs";
+import { n as ToolResult_d_exports } from "./ToolResult-Cj8ChodL.mjs";
+import { n as ToolEvent_d_exports } from "./ToolEvent-D99MGQYH.mjs";
+import { l as Toolkit_d_exports } from "./Toolkit-BEZrNPTI.mjs";
 import { t as LanguageModel_d_exports } from "./language-model/LanguageModel.mjs";
 import { t as MusicGenerator_d_exports } from "./music-generator/MusicGenerator.mjs";
 import { t as Memory_d_exports } from "./sandbox/Memory.mjs";
-import { o as SandboxError_d_exports } from "./SandboxError-CIrVDOMV.mjs";
+import { o as SandboxError_d_exports } from "./SandboxError-BN8b28Bh.mjs";
 import { t as Sandbox_d_exports } from "./sandbox/Sandbox.mjs";
 import { t as SandboxImage_d_exports } from "./sandbox/SandboxImage.mjs";
 import { t as SandboxNetwork_d_exports } from "./sandbox/SandboxNetwork.mjs";

package/dist/job/Job.d.mts

@@ -1,7 +1,5 @@
-import { t as AiError } from "../AiError-Bf1pq4BB.mjs";
+import { t as AiError } from "../AiError-eLV9t1lU.mjs";
 import { Duration, Effect } from "effect";
-
-//#region src/job/Job.d.ts
 declare namespace Job_d_exports {
   export { JobConfig, JobOps, JobRef, JobState, collect, isSettled, jobRef, run };
 }
@@ -59,7 +57,9 @@ type JobOps<Result> = {
   readonly cancel: (ref: JobRef<Result>) => Effect.Effect<void, AiError>;
 };
 type JobConfig = {
-  /** Cadence between status fetches. Default 10 seconds, jittered. */readonly pollInterval?: Duration.Input; /** Overall wait cap; exceeding it fails `Timeout`. Default 45 minutes. */
+  /** Cadence between status fetches. Default 10 seconds, jittered. */
+  readonly pollInterval?: Duration.Input;
+  /** Overall wait cap; exceeding it fails `Timeout`. Default 45 minutes. */
   readonly timeout?: Duration.Input;
 };
 /**

package/dist/job/Job.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"Job.d.mts","names":[],"sources":["../../src/job/Job.ts"],"mappings":";;;;;;;;;;;;;;KAcY,QAAA;EAAA,SACG,IAAA;AAAA;EAAA,SACA,IAAA;AAAA;EAAA,SACA,IAAA;EAAA,SAA4B,MAAA,EAAQ,CAAA;AAAA;EAAA,SACpC,IAAA;EAAA,SAAyB,MAAA;EAAA,SAA0B,GAAA;AAAA;;cAGrD,SAAA,MACX,KAAA,EAAO,QAAA,CAAS,CAAA,MACf,KAAA,IAAS,OAAA,CAAQ,QAAA,CAAS,CAAA;EAAM,IAAA;AAAA;AAAA,cAGrB,UAAA;;;;;AALd;;;;;;KAiBY,MAAA;EAAA,SACD,IAAA;EAAA,SACA,QAAA;EAAA,SACA,EAAA;EAAA,UACC,UAAA,IAAc,CAAA;AAAA;AAAA,cAGb,MAAA,gBAAuB,QAAA,UAAkB,EAAA,aAAa,MAAA,CAAO,CAAA;;;;;;;;KAiB9D,MAAA;EAAA,SACD,MAAA,EAAQ,MAAA,CAAO,MAAA,CAAO,MAAA,CAAO,MAAA,GAAS,OAAA;EAAA,SACtC,IAAA,GAAO,GAAA,EAAK,MAAA,CAAO,MAAA,MAAY,MAAA,CAAO,MAAA,CAAO,QAAA,CAAS,MAAA,GAAS,OAAA;EAAA,SAC/D,MAAA,GAAS,GAAA,EAAK,MAAA,CAAO,MAAA,MAAY,MAAA,CAAO,MAAA,OAAa,OAAA;AAAA;AAAA,KAGpD,SAAA;EA9BA,6EAgCD,YAAA,GAAe,QAAA,CAAS,KAAA,EAhCjB;EAAA,SAkCP,OAAA,GAAU,QAAA,CAAS,KAAA;AAAA;;;;;;;cAYjB,OAAA,WACX,IAAA,GAAO,GAAA,EAAK,MAAA,CAAO,MAAA,MAAY,MAAA,CAAO,MAAA,CAAO,QAAA,CAAS,MAAA,GAAS,OAAA,GAC/D,GAAA,EAAK,MAAA,CAAO,MAAA,GACZ,MAAA,GAAS,SAAA,KACR,MAAA,CAAO,MAAA,CAAO,MAAA,EAAQ,OAAA;AA3CzB;;;;;AAAA,cAuEa,GAAA,WACX,GAAA,EAAK,MAAA,CAAO,MAAA,GACZ,MAAA,GAAS,SAAA,KACR,MAAA,CAAO,MAAA,CAAO,MAAA,EAAQ,OAAA"}
+{"version":3,"file":"Job.d.mts","names":[],"sources":["../../src/job/Job.ts"],"mappings":";;;;;;;;;;;;KAcY,SAAS;WACN;;WACA;;WACA;WAA4B,QAAQ;;WACpC;WAAyB;WAA0B;;;cAGrD,YAAa,GAAC,OAClB,SAAS,OACf,SAAS,QAAQ,SAAS;EAAM;;cAGrB;;;;;;;;;;;KAYF,OAAO;WACR;WACA;WACA;YACC,cAAc;;cAGb,SAAU,aAAW,kBAAkB,eAAe,OAAO;;;;;;;;KAiB9D,OAAO;WACR,QAAQ,OAAO,OAAO,OAAO,SAAS;WACtC,OAAO,KAAK,OAAO,YAAY,OAAO,OAAO,SAAS,SAAS;WAC/D,SAAS,KAAK,OAAO,YAAY,OAAO,aAAa;;KAGpD;;WAED,eAAe,SAAS;;WAExB,UAAU,SAAS;;;;;;;;cAYjB,UAAW,QAAM,OACrB,KAAK,OAAO,YAAY,OAAO,OAAO,SAAS,SAAS,UAAgB,KAC1E,OAAO,SAAO,SACV,cACR,OAAO,OAAO,QAAQ;;;;;;cA4BZ,MAAO,QAAM,KACnB,OAAO,SAAO,SACV,cACR,OAAO,OAAO,QAAQ"}

package/dist/job/Job.mjs

@@ -1,4 +1,4 @@
-import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { n as __exportAll } from "../rolldown-runtime-EAsCxrDo.mjs";
 import { GenerationFailed, Timeout } from "../domain/AiError.mjs";
 import { Effect, Schedule } from "effect";
 //#region src/job/Job.ts

package/dist/job/Job.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Job.mjs","names":["AiError.GenerationFailed","AiError.Timeout"],"sources":["../../src/job/Job.ts"],"sourcesContent":["import { Duration, Effect, Schedule } from \"effect\"\nimport * as AiError from \"../domain/AiError.js\"\n\n// ---------------------------------------------------------------------------\n// Status + handle\n// ---------------------------------------------------------------------------\n\n/**\n * Normalized state of a provider-hosted background job. Implementors map their\n * provider's status vocabulary onto these four states. The terminal states\n * carry their payload: `Succeeded` the collected result, `Failed` an optional\n * reason and the raw provider error. This mirrors the wire, where a single\n * poll response returns both status and (when done) the result.\n */\nexport type JobState<A> =\n  | { readonly _tag: \"Pending\" }\n  | { readonly _tag: \"Running\" }\n  | { readonly _tag: \"Succeeded\"; readonly result: A }\n  | { readonly _tag: \"Failed\"; readonly reason?: string; readonly raw?: unknown }\n\n/** The two states that end a poll loop. */\nexport const isSettled = <A>(\n  state: JobState<A>,\n): state is Extract<JobState<A>, { _tag: \"Succeeded\" | \"Failed\" }> =>\n  state._tag === \"Succeeded\" || state._tag === \"Failed\"\n\ndeclare const ResultType: unique symbol\n\n/**\n * Opaque, provider-tagged handle to a running background job. Jobs can run for\n * minutes and outlive a single process, so the handle is detachable: submit\n * now, collect later. `provider` tags who owns `id`.\n *\n * Parameterized by the result type `A` it collects to, so a ref cannot be\n * crossed between capabilities (a `JobRef<Turn>` is not a `JobRef<VideoResult>`).\n * The brand is phantom: the runtime value is just `{ _tag, provider, id }`, so\n * a ref stays plain serializable data for persistence across restarts.\n */\nexport type JobRef<A = unknown> = {\n  readonly _tag: \"JobRef\"\n  readonly provider: string\n  readonly id: string\n  readonly [ResultType]?: A\n}\n\nexport const jobRef = <A = unknown>(provider: string, id: string): JobRef<A> => ({\n  _tag: \"JobRef\",\n  provider,\n  id,\n})\n\n// ---------------------------------------------------------------------------\n// Poll driver\n// ---------------------------------------------------------------------------\n\n/**\n * The three wire operations a poll-based async job supplies. `run` / `collect`\n * drive the submit -> poll -> settle cadence around them, so an implementor\n * states only its provider calls, not the loop. `poll` returns the current\n * `JobState`, carrying the result in `Succeeded`. Generic over the collected\n * `Result`.\n */\nexport type JobOps<Result> = {\n  readonly submit: Effect.Effect<JobRef<Result>, AiError.AiError>\n  readonly poll: (ref: JobRef<Result>) => Effect.Effect<JobState<Result>, AiError.AiError>\n  readonly cancel: (ref: JobRef<Result>) => Effect.Effect<void, AiError.AiError>\n}\n\nexport type JobConfig = {\n  /** Cadence between status fetches. Default 10 seconds, jittered. */\n  readonly pollInterval?: Duration.Input\n  /** Overall wait cap; exceeding it fails `Timeout`. Default 45 minutes. */\n  readonly timeout?: Duration.Input\n}\n\nconst DEFAULT_POLL_INTERVAL: Duration.Input = \"10 seconds\"\nconst DEFAULT_TIMEOUT: Duration.Input = \"45 minutes\"\n\n/**\n * Poll `poll(ref)` on a jittered fixed cadence until the job settles, then\n * return the result or fail `GenerationFailed`. Bounded by `timeout`, which\n * fails `Timeout` if the job never settles. Takes the poll op alone (not the\n * full `JobOps`) so a detached `collect(ref)` needs no submit-bound request.\n */\nexport const collect = <Result>(\n  poll: (ref: JobRef<Result>) => Effect.Effect<JobState<Result>, AiError.AiError>,\n  ref: JobRef<Result>,\n  config?: JobConfig,\n): Effect.Effect<Result, AiError.AiError> =>\n  poll(ref).pipe(\n    Effect.repeat({\n      schedule: Schedule.jittered(Schedule.spaced(config?.pollInterval ?? DEFAULT_POLL_INTERVAL)),\n      until: isSettled,\n    }),\n    Effect.flatMap((state) =>\n      state._tag === \"Succeeded\"\n        ? Effect.succeed(state.result)\n        : Effect.fail(\n            new AiError.GenerationFailed({\n              provider: ref.provider,\n              message: state._tag === \"Failed\" ? (state.reason ?? \"job failed\") : \"job failed\",\n              raw: state._tag === \"Failed\" ? (state.raw ?? ref) : ref,\n            }),\n          ),\n    ),\n    Effect.timeoutOrElse({\n      duration: config?.timeout ?? DEFAULT_TIMEOUT,\n      orElse: () => Effect.fail(new AiError.Timeout({ provider: ref.provider, raw: ref })),\n    }),\n  )\n\n/**\n * Submit, then poll to completion. Best-effort cancels the server job if the\n * caller interrupts (where the provider supports it). The one-call path; use\n * `ops.submit` + `collect` directly for the detached case.\n */\nexport const run = <Result>(\n  ops: JobOps<Result>,\n  config?: JobConfig,\n): Effect.Effect<Result, AiError.AiError> =>\n  ops.submit.pipe(\n    Effect.flatMap((ref) =>\n      collect(ops.poll, ref, config).pipe(Effect.onInterrupt(() => Effect.ignore(ops.cancel(ref)))),\n    ),\n  )\n"],"mappings":";;;;;;;;;;;AAqBA,MAAa,aACX,UAEA,MAAM,SAAS,eAAe,MAAM,SAAS;AAqB/C,MAAa,UAAuB,UAAkB,QAA2B;CAC/E,MAAM;CACN;CACA;CACD;AA0BD,MAAM,wBAAwC;AAC9C,MAAM,kBAAkC;;;;;;;AAQxC,MAAa,WACX,MACA,KACA,WAEA,KAAK,IAAI,CAAC,KACR,OAAO,OAAO;CACZ,UAAU,SAAS,SAAS,SAAS,OAAO,QAAQ,gBAAgB,sBAAsB,CAAC;CAC3F,OAAO;CACR,CAAC,EACF,OAAO,SAAS,UACd,MAAM,SAAS,cACX,OAAO,QAAQ,MAAM,OAAO,GAC5B,OAAO,KACL,IAAIA,iBAAyB;CAC3B,UAAU,IAAI;CACd,SAAS,MAAM,SAAS,WAAY,MAAM,UAAU,eAAgB;CACpE,KAAK,MAAM,SAAS,WAAY,MAAM,OAAO,MAAO;CACrD,CAAC,CACH,CACN,EACD,OAAO,cAAc;CACnB,UAAU,QAAQ,WAAW;CAC7B,cAAc,OAAO,KAAK,IAAIC,QAAgB;EAAE,UAAU,IAAI;EAAU,KAAK;EAAK,CAAC,CAAC;CACrF,CAAC,CACH;;;;;;AAOH,MAAa,OACX,KACA,WAEA,IAAI,OAAO,KACT,OAAO,SAAS,QACd,QAAQ,IAAI,MAAM,KAAK,OAAO,CAAC,KAAK,OAAO,kBAAkB,OAAO,OAAO,IAAI,OAAO,IAAI,CAAC,CAAC,CAAC,CAC9F,CACF"}
+{"version":3,"file":"Job.mjs","names":["AiError.GenerationFailed","AiError.Timeout"],"sources":["../../src/job/Job.ts"],"sourcesContent":["import { Duration, Effect, Schedule } from \"effect\"\nimport * as AiError from \"../domain/AiError.js\"\n\n// ---------------------------------------------------------------------------\n// Status + handle\n// ---------------------------------------------------------------------------\n\n/**\n * Normalized state of a provider-hosted background job. Implementors map their\n * provider's status vocabulary onto these four states. The terminal states\n * carry their payload: `Succeeded` the collected result, `Failed` an optional\n * reason and the raw provider error. This mirrors the wire, where a single\n * poll response returns both status and (when done) the result.\n */\nexport type JobState<A> =\n  | { readonly _tag: \"Pending\" }\n  | { readonly _tag: \"Running\" }\n  | { readonly _tag: \"Succeeded\"; readonly result: A }\n  | { readonly _tag: \"Failed\"; readonly reason?: string; readonly raw?: unknown }\n\n/** The two states that end a poll loop. */\nexport const isSettled = <A>(\n  state: JobState<A>,\n): state is Extract<JobState<A>, { _tag: \"Succeeded\" | \"Failed\" }> =>\n  state._tag === \"Succeeded\" || state._tag === \"Failed\"\n\ndeclare const ResultType: unique symbol\n\n/**\n * Opaque, provider-tagged handle to a running background job. Jobs can run for\n * minutes and outlive a single process, so the handle is detachable: submit\n * now, collect later. `provider` tags who owns `id`.\n *\n * Parameterized by the result type `A` it collects to, so a ref cannot be\n * crossed between capabilities (a `JobRef<Turn>` is not a `JobRef<VideoResult>`).\n * The brand is phantom: the runtime value is just `{ _tag, provider, id }`, so\n * a ref stays plain serializable data for persistence across restarts.\n */\nexport type JobRef<A = unknown> = {\n  readonly _tag: \"JobRef\"\n  readonly provider: string\n  readonly id: string\n  readonly [ResultType]?: A\n}\n\nexport const jobRef = <A = unknown>(provider: string, id: string): JobRef<A> => ({\n  _tag: \"JobRef\",\n  provider,\n  id,\n})\n\n// ---------------------------------------------------------------------------\n// Poll driver\n// ---------------------------------------------------------------------------\n\n/**\n * The three wire operations a poll-based async job supplies. `run` / `collect`\n * drive the submit -> poll -> settle cadence around them, so an implementor\n * states only its provider calls, not the loop. `poll` returns the current\n * `JobState`, carrying the result in `Succeeded`. Generic over the collected\n * `Result`.\n */\nexport type JobOps<Result> = {\n  readonly submit: Effect.Effect<JobRef<Result>, AiError.AiError>\n  readonly poll: (ref: JobRef<Result>) => Effect.Effect<JobState<Result>, AiError.AiError>\n  readonly cancel: (ref: JobRef<Result>) => Effect.Effect<void, AiError.AiError>\n}\n\nexport type JobConfig = {\n  /** Cadence between status fetches. Default 10 seconds, jittered. */\n  readonly pollInterval?: Duration.Input\n  /** Overall wait cap; exceeding it fails `Timeout`. Default 45 minutes. */\n  readonly timeout?: Duration.Input\n}\n\nconst DEFAULT_POLL_INTERVAL: Duration.Input = \"10 seconds\"\nconst DEFAULT_TIMEOUT: Duration.Input = \"45 minutes\"\n\n/**\n * Poll `poll(ref)` on a jittered fixed cadence until the job settles, then\n * return the result or fail `GenerationFailed`. Bounded by `timeout`, which\n * fails `Timeout` if the job never settles. Takes the poll op alone (not the\n * full `JobOps`) so a detached `collect(ref)` needs no submit-bound request.\n */\nexport const collect = <Result>(\n  poll: (ref: JobRef<Result>) => Effect.Effect<JobState<Result>, AiError.AiError>,\n  ref: JobRef<Result>,\n  config?: JobConfig,\n): Effect.Effect<Result, AiError.AiError> =>\n  poll(ref).pipe(\n    Effect.repeat({\n      schedule: Schedule.jittered(Schedule.spaced(config?.pollInterval ?? DEFAULT_POLL_INTERVAL)),\n      until: isSettled,\n    }),\n    Effect.flatMap((state) =>\n      state._tag === \"Succeeded\"\n        ? Effect.succeed(state.result)\n        : Effect.fail(\n            new AiError.GenerationFailed({\n              provider: ref.provider,\n              message: state._tag === \"Failed\" ? (state.reason ?? \"job failed\") : \"job failed\",\n              raw: state._tag === \"Failed\" ? (state.raw ?? ref) : ref,\n            }),\n          ),\n    ),\n    Effect.timeoutOrElse({\n      duration: config?.timeout ?? DEFAULT_TIMEOUT,\n      orElse: () => Effect.fail(new AiError.Timeout({ provider: ref.provider, raw: ref })),\n    }),\n  )\n\n/**\n * Submit, then poll to completion. Best-effort cancels the server job if the\n * caller interrupts (where the provider supports it). The one-call path; use\n * `ops.submit` + `collect` directly for the detached case.\n */\nexport const run = <Result>(\n  ops: JobOps<Result>,\n  config?: JobConfig,\n): Effect.Effect<Result, AiError.AiError> =>\n  ops.submit.pipe(\n    Effect.flatMap((ref) =>\n      collect(ops.poll, ref, config).pipe(Effect.onInterrupt(() => Effect.ignore(ops.cancel(ref)))),\n    ),\n  )\n"],"mappings":";;;;;;;;;;;AAqBA,MAAa,aACX,UAEA,MAAM,SAAS,eAAe,MAAM,SAAS;AAqB/C,MAAa,UAAuB,UAAkB,QAA2B;CAC/E,MAAM;CACN;CACA;AACF;AA0BA,MAAM,wBAAwC;AAC9C,MAAM,kBAAkC;;;;;;;AAQxC,MAAa,WACX,MACA,KACA,WAEA,KAAK,GAAG,CAAC,CAAC,KACR,OAAO,OAAO;CACZ,UAAU,SAAS,SAAS,SAAS,OAAO,QAAQ,gBAAgB,qBAAqB,CAAC;CAC1F,OAAO;AACT,CAAC,GACD,OAAO,SAAS,UACd,MAAM,SAAS,cACX,OAAO,QAAQ,MAAM,MAAM,IAC3B,OAAO,KACL,IAAIA,iBAAyB;CAC3B,UAAU,IAAI;CACd,SAAS,MAAM,SAAS,WAAY,MAAM,UAAU,eAAgB;CACpE,KAAK,MAAM,SAAS,WAAY,MAAM,OAAO,MAAO;AACtD,CAAC,CACH,CACN,GACA,OAAO,cAAc;CACnB,UAAU,QAAQ,WAAW;CAC7B,cAAc,OAAO,KAAK,IAAIC,QAAgB;EAAE,UAAU,IAAI;EAAU,KAAK;CAAI,CAAC,CAAC;AACrF,CAAC,CACH;;;;;;AAOF,MAAa,OACX,KACA,WAEA,IAAI,OAAO,KACT,OAAO,SAAS,QACd,QAAQ,IAAI,MAAM,KAAK,MAAM,CAAC,CAAC,KAAK,OAAO,kBAAkB,OAAO,OAAO,IAAI,OAAO,GAAG,CAAC,CAAC,CAAC,CAC9F,CACF"}

package/dist/language-model/LanguageModel.d.mts

@@ -1,11 +1,9 @@
-import { o as HistoryItem } from "../Items-BWNu6VGp.mjs";
-import { t as AiError } from "../AiError-Bf1pq4BB.mjs";
-import { i as StructuredFormat } from "../StructuredFormat-DHaUJBdd.mjs";
+import { o as HistoryItem } from "../Items-SfUabNuB.mjs";
+import { t as AiError } from "../AiError-eLV9t1lU.mjs";
+import { i as StructuredFormat } from "../StructuredFormat-BlZhyOsi.mjs";
 import { Turn, TurnEvent } from "../domain/Turn.mjs";
-import { o as Toolkit } from "../Toolkit-BYPwwu-j.mjs";
+import { o as Toolkit } from "../Toolkit-BEZrNPTI.mjs";
 import { Context, Effect, Stream } from "effect";
-
-//#region src/language-model/LanguageModel.d.ts
 declare namespace LanguageModel_d_exports {
   export { CommonRequest, LanguageModel, LanguageModelService, streamTurn, turn, turnFromStream };
 }

package/dist/language-model/LanguageModel.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"LanguageModel.d.mts","names":[],"sources":["../../src/language-model/LanguageModel.ts"],"mappings":";;;;;;;;;;;;;;;;;KAaY,aAAA;EAAA,SACD,OAAA,EAAS,aAAA,CAAc,WAAA;;;;AADlC;WAMW,KAAA;;;;;;WAMA,KAAA,GAAQ,OAAA;EAAA,SACR,UAAA;IAAA,SAIM,IAAA;IAAA,SAA2B,IAAA;EAAA;EAAA,SACjC,WAAA;EAAA,SACA,IAAA;EAAA,SACA,eAAA;EAPA;;;;;;EAAA,SAcA,UAAA,GAAa,gBAAA;AAAA;AAAA,KAGZ,oBAAA;EAAA,SACD,UAAA,GAAa,OAAA,EAAS,aAAA,KAAkB,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,OAAA;EAJnB;AAGzD;;;;;;;;EAHyD,SAc9C,IAAA,GAAO,OAAA,EAAS,aAAA,KAAkB,MAAA,CAAO,MAAA,CAAO,IAAA,EAAM,OAAA;AAAA;AAAA,cAChE,kBAAA;cAEY,aAAA,SAAsB,kBAAA;;;;cAOtB,UAAA,GACX,OAAA,EAAS,aAAA,KACR,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,OAAA,EAAiB,aAAA;;;;;;;cAShC,IAAA,GAAQ,OAAA,EAAS,aAAA,KAAgB,MAAA,CAAO,MAAA,CAAO,IAAA,EAAM,OAAA,EAAiB,aAAA;;;;;;;cAStE,cAAA,QACL,UAAA,GAAa,OAAA,EAAS,GAAA,KAAQ,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,OAAA,OAC5D,OAAA,EAAS,GAAA,KAAM,MAAA,CAAO,MAAA,CAAO,IAAA,EAAM,OAAA"}
+{"version":3,"file":"LanguageModel.d.mts","names":[],"sources":["../../src/language-model/LanguageModel.ts"],"mappings":";;;;;;;;;;;;;;;KAaY;WACD,SAAS,cAAc;;;;;WAKvB;;;;;;WAMA,QAAQ;WACR;aAIM;aAA2B;;WACjC;WACA;WACA;;;;;;;WAOA,aAAa;;KAGZ;WACD,aAAa,SAAS,kBAAkB,OAAO,OAAO,WAAW;;;;;;;;;;WAUjE,OAAO,SAAS,kBAAkB,OAAO,OAAO,MAAM;;;cAGpD,sBAAsB;;;;cAOtB,aAAU,SACZ,kBACR,OAAO,OAAO,WAAW,SAAiB;;;;;;;cAShC,OAAI,SAAa,kBAAgB,OAAO,OAAO,MAAM,SAAiB;;;;;;;cAStE,iBACV,KAAG,aAAe,SAAS,QAAQ,OAAO,OAAO,WAAW,cAAgB,SACnE,QAAM,OAAO,OAAO,MAAM"}

package/dist/language-model/LanguageModel.mjs

@@ -1,4 +1,4 @@
-import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { n as __exportAll } from "../rolldown-runtime-EAsCxrDo.mjs";
 import { IncompleteTurn } from "../domain/AiError.mjs";
 import { isTurnComplete } from "../domain/Turn.mjs";
 import { Array, Context, Effect, Option, Stream } from "effect";