@effect-uai/core 0.2.0 → 0.4.0

package/dist/domain/Transcript.d.mts

@@ -0,0 +1,95 @@
+declare namespace Transcript_d_exports {
+  export { TranscriptEvent, TranscriptResult, WordTimestamp, isAudioEvent, isError, isFinal, isMetadata, isPartial, isSpeechStarted, isUtteranceEnded };
+}
+/**
+ * Per-word timing + metadata. `confidence` and `speakerId` are optional
+ * because providers vary widely in what they emit and when (some only on
+ * final, some only with diarization enabled, some not at all).
+ */
+type WordTimestamp = {
+  readonly text: string;
+  readonly startSeconds: number;
+  readonly endSeconds: number;
+  readonly confidence?: number;
+  readonly speakerId?: string;
+  readonly languageCode?: string;
+};
+/**
+ * Sync STT result. `raw` preserves the provider-specific response for
+ * consumers that need fields the common shape doesn't expose
+ * (alternatives, segments, NBest, audio events, etc.).
+ */
+type TranscriptResult = {
+  readonly text: string;
+  readonly languageCode?: string;
+  readonly durationSeconds?: number;
+  readonly words?: ReadonlyArray<WordTimestamp>;
+  readonly raw?: unknown;
+};
+/**
+ * Streaming STT event union. Collapses every provider's vocabulary into
+ * a small set; provider-specific shapes survive on `metadata.raw`.
+ *
+ * - `partial`: interim hypothesis. `stability` is Google-only.
+ * - `final`: committed transcript for the current utterance / segment.
+ * - `speech-started` / `utterance-ended`: VAD-derived boundaries. Not
+ *   all providers emit them (OpenAI Realtime, Google with
+ *   `voice_activity_events`, Deepgram with `vad_events`, AssemblyAI).
+ * - `audio-event`: non-speech label (`(laughter)`, `(music)`) — ElevenLabs only.
+ * - `metadata`: opaque server-side bookkeeping (request_id, model info).
+ * - `error`: non-fatal provider error mid-stream. Fatal errors surface
+ *   on the `Stream`'s error channel as `AiError.AiError`.
+ */
+type TranscriptEvent = {
+  readonly _tag: "partial";
+  readonly text: string;
+  readonly words?: ReadonlyArray<WordTimestamp>;
+  readonly stability?: number;
+} | {
+  readonly _tag: "final";
+  readonly text: string;
+  readonly words?: ReadonlyArray<WordTimestamp>;
+  readonly languageCode?: string;
+} | {
+  readonly _tag: "speech-started";
+  readonly atSeconds: number;
+} | {
+  readonly _tag: "utterance-ended";
+  readonly atSeconds: number;
+} | {
+  readonly _tag: "audio-event";
+  readonly label: string;
+  readonly startSeconds: number;
+  readonly endSeconds: number;
+} | {
+  readonly _tag: "metadata";
+  readonly raw: unknown;
+} | {
+  readonly _tag: "error";
+  readonly code?: string;
+  readonly message: string;
+};
+declare const isPartial: (e: TranscriptEvent) => e is Extract<TranscriptEvent, {
+  _tag: "partial";
+}>;
+declare const isFinal: (e: TranscriptEvent) => e is Extract<TranscriptEvent, {
+  _tag: "final";
+}>;
+declare const isSpeechStarted: (e: TranscriptEvent) => e is Extract<TranscriptEvent, {
+  _tag: "speech-started";
+}>;
+declare const isUtteranceEnded: (e: TranscriptEvent) => e is Extract<TranscriptEvent, {
+  _tag: "utterance-ended";
+}>;
+declare const isAudioEvent: (e: TranscriptEvent) => e is Extract<TranscriptEvent, {
+  _tag: "audio-event";
+}>;
+declare const isMetadata: (e: TranscriptEvent) => e is Extract<TranscriptEvent, {
+  _tag: "metadata";
+}>;
+declare const isError: (e: TranscriptEvent) => e is Extract<TranscriptEvent, {
+  _tag: "error";
+}>;
+//#endregion
+export { TranscriptEvent, TranscriptResult, WordTimestamp, isAudioEvent, isError, isFinal, isMetadata, isPartial, isSpeechStarted, isUtteranceEnded, Transcript_d_exports as t };
+//# sourceMappingURL=Transcript.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Transcript.d.mts","names":[],"sources":["../../src/domain/Transcript.ts"],"mappings":";;;;;;;;KAKY,aAAA;EAAA,SACD,IAAA;EAAA,SACA,YAAA;EAAA,SACA,UAAA;EAAA,SACA,UAAA;EAAA,SACA,SAAA;EAAA,SACA,YAAA;AAAA;;;AANX;;;KAcY,gBAAA;EAAA,SACD,IAAA;EAAA,SACA,YAAA;EAAA,SACA,eAAA;EAAA,SACA,KAAA,GAAQ,aAAA,CAAc,aAAA;EAAA,SACtB,GAAA;AAAA;;;AALX;;;;;;;;;;;;KAsBY,eAAA;EAAA,SAEG,IAAA;EAAA,SACA,IAAA;EAAA,SACA,KAAA,GAAQ,aAAA,CAAc,aAAA;EAAA,SACtB,SAAA;AAAA;EAAA,SAGA,IAAA;EAAA,SACA,IAAA;EAAA,SACA,KAAA,GAAQ,aAAA,CAAc,aAAA;EAAA,SACtB,YAAA;AAAA;EAAA,SAEA,IAAA;EAAA,SAAiC,SAAA;AAAA;EAAA,SACjC,IAAA;EAAA,SAAkC,SAAA;AAAA;EAAA,SAElC,IAAA;EAAA,SACA,KAAA;EAAA,SACA,YAAA;EAAA,SACA,UAAA;AAAA;EAAA,SAEA,IAAA;EAAA,SAA2B,GAAA;AAAA;EAAA,SAC3B,IAAA;EAAA,SAAwB,IAAA;EAAA,SAAwB,OAAA;AAAA;AAAA,cAElD,SAAA,GAAa,CAAA,EAAG,eAAA,KAAkB,CAAA,IAAK,OAAA,CAAQ,eAAA;EAAmB,IAAA;AAAA;AAAA,cAElE,OAAA,GAAW,CAAA,EAAG,eAAA,KAAkB,CAAA,IAAK,OAAA,CAAQ,eAAA;EAAmB,IAAA;AAAA;AAAA,cAEhE,eAAA,GACX,CAAA,EAAG,eAAA,KACF,CAAA,IAAK,OAAA,CAAQ,eAAA;EAAmB,IAAA;AAAA;AAAA,cACtB,gBAAA,GACX,CAAA,EAAG,eAAA,KACF,CAAA,IAAK,OAAA,CAAQ,eAAA;EAAmB,IAAA;AAAA;AAAA,cACtB,YAAA,GACX,CAAA,EAAG,eAAA,KACF,CAAA,IAAK,OAAA,CAAQ,eAAA;EAAmB,IAAA;AAAA;AAAA,cACtB,UAAA,GACX,CAAA,EAAG,eAAA,KACF,CAAA,IAAK,OAAA,CAAQ,eAAA;EAAmB,IAAA;AAAA;AAAA,cACtB,OAAA,GAAW,CAAA,EAAG,eAAA,KAAkB,CAAA,IAAK,OAAA,CAAQ,eAAA;EAAmB,IAAA;AAAA"}

package/dist/domain/Transcript.mjs

@@ -0,0 +1,22 @@
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+//#region src/domain/Transcript.ts
+var Transcript_exports = /* @__PURE__ */ __exportAll({
+	isAudioEvent: () => isAudioEvent,
+	isError: () => isError,
+	isFinal: () => isFinal,
+	isMetadata: () => isMetadata,
+	isPartial: () => isPartial,
+	isSpeechStarted: () => isSpeechStarted,
+	isUtteranceEnded: () => isUtteranceEnded
+});
+const isPartial = (e) => e._tag === "partial";
+const isFinal = (e) => e._tag === "final";
+const isSpeechStarted = (e) => e._tag === "speech-started";
+const isUtteranceEnded = (e) => e._tag === "utterance-ended";
+const isAudioEvent = (e) => e._tag === "audio-event";
+const isMetadata = (e) => e._tag === "metadata";
+const isError = (e) => e._tag === "error";
+//#endregion
+export { isAudioEvent, isError, isFinal, isMetadata, isPartial, isSpeechStarted, isUtteranceEnded, Transcript_exports as t };
+
+//# sourceMappingURL=Transcript.mjs.map

package/dist/domain/Transcript.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Transcript.mjs","names":[],"sources":["../../src/domain/Transcript.ts"],"sourcesContent":["/**\n * Per-word timing + metadata. `confidence` and `speakerId` are optional\n * because providers vary widely in what they emit and when (some only on\n * final, some only with diarization enabled, some not at all).\n */\nexport type WordTimestamp = {\n  readonly text: string\n  readonly startSeconds: number\n  readonly endSeconds: number\n  readonly confidence?: number\n  readonly speakerId?: string\n  readonly languageCode?: string\n}\n\n/**\n * Sync STT result. `raw` preserves the provider-specific response for\n * consumers that need fields the common shape doesn't expose\n * (alternatives, segments, NBest, audio events, etc.).\n */\nexport type TranscriptResult = {\n  readonly text: string\n  readonly languageCode?: string\n  readonly durationSeconds?: number\n  readonly words?: ReadonlyArray<WordTimestamp>\n  readonly raw?: unknown\n}\n\n/**\n * Streaming STT event union. Collapses every provider's vocabulary into\n * a small set; provider-specific shapes survive on `metadata.raw`.\n *\n * - `partial`: interim hypothesis. `stability` is Google-only.\n * - `final`: committed transcript for the current utterance / segment.\n * - `speech-started` / `utterance-ended`: VAD-derived boundaries. Not\n *   all providers emit them (OpenAI Realtime, Google with\n *   `voice_activity_events`, Deepgram with `vad_events`, AssemblyAI).\n * - `audio-event`: non-speech label (`(laughter)`, `(music)`) — ElevenLabs only.\n * - `metadata`: opaque server-side bookkeeping (request_id, model info).\n * - `error`: non-fatal provider error mid-stream. Fatal errors surface\n *   on the `Stream`'s error channel as `AiError.AiError`.\n */\nexport type TranscriptEvent =\n  | {\n      readonly _tag: \"partial\"\n      readonly text: string\n      readonly words?: ReadonlyArray<WordTimestamp>\n      readonly stability?: number\n    }\n  | {\n      readonly _tag: \"final\"\n      readonly text: string\n      readonly words?: ReadonlyArray<WordTimestamp>\n      readonly languageCode?: string\n    }\n  | { readonly _tag: \"speech-started\"; readonly atSeconds: number }\n  | { readonly _tag: \"utterance-ended\"; readonly atSeconds: number }\n  | {\n      readonly _tag: \"audio-event\"\n      readonly label: string\n      readonly startSeconds: number\n      readonly endSeconds: number\n    }\n  | { readonly _tag: \"metadata\"; readonly raw: unknown }\n  | { readonly _tag: \"error\"; readonly code?: string; readonly message: string }\n\nexport const isPartial = (e: TranscriptEvent): e is Extract<TranscriptEvent, { _tag: \"partial\" }> =>\n  e._tag === \"partial\"\nexport const isFinal = (e: TranscriptEvent): e is Extract<TranscriptEvent, { _tag: \"final\" }> =>\n  e._tag === \"final\"\nexport const isSpeechStarted = (\n  e: TranscriptEvent,\n): e is Extract<TranscriptEvent, { _tag: \"speech-started\" }> => e._tag === \"speech-started\"\nexport const isUtteranceEnded = (\n  e: TranscriptEvent,\n): e is Extract<TranscriptEvent, { _tag: \"utterance-ended\" }> => e._tag === \"utterance-ended\"\nexport const isAudioEvent = (\n  e: TranscriptEvent,\n): e is Extract<TranscriptEvent, { _tag: \"audio-event\" }> => e._tag === \"audio-event\"\nexport const isMetadata = (\n  e: TranscriptEvent,\n): e is Extract<TranscriptEvent, { _tag: \"metadata\" }> => e._tag === \"metadata\"\nexport const isError = (e: TranscriptEvent): e is Extract<TranscriptEvent, { _tag: \"error\" }> =>\n  e._tag === \"error\"\n"],"mappings":";;;;;;;;;;;AAiEA,MAAa,aAAa,MACxB,EAAE,SAAS;AACb,MAAa,WAAW,MACtB,EAAE,SAAS;AACb,MAAa,mBACX,MAC8D,EAAE,SAAS;AAC3E,MAAa,oBACX,MAC+D,EAAE,SAAS;AAC5E,MAAa,gBACX,MAC2D,EAAE,SAAS;AACxE,MAAa,cACX,MACwD,EAAE,SAAS;AACrE,MAAa,WAAW,MACtB,EAAE,SAAS"}

package/dist/domain/Turn.d.mts

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

package/dist/domain/Turn.mjs

@@ -1,4 +1,4 @@
-import { t as __exportAll } from "../chunk-CfYAbeIz.mjs";
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
 import { Item, StopReason, Usage, isOutputText, isRefusal } from "./Items.mjs";
 import { parseJson } from "../structured-format/StructuredFormat.mjs";
 import { Data, Effect, Result, Schema, Stream, pipe } from "effect";

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

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

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

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

package/dist/embedding-model/Embedding.mjs

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

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

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

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

@@ -0,0 +1,97 @@
+import { t as AiError } from "../AiError-csR8Bhxx.mjs";
+import { EmbedInput, Embedding, Usage } from "./Embedding.mjs";
+import { Context, Effect } from "effect";
+
+//#region src/embedding-model/EmbeddingModel.d.ts
+declare namespace EmbeddingModel_d_exports {
+  export { CommonEmbedManyRequest, CommonEmbedRequest, EmbedManyResponse, EmbedResponse, EmbeddingModel, EmbeddingModelService, Encoding, embed, embedMany };
+}
+/**
+ * Output representation requested from the provider.
+ *
+ * Dense quantizations - same vector at different storage cost:
+ * - `float32` — universal default.
+ * - `int8` — ~4x smaller; minimal recall loss on most benchmarks.
+ * - `binary` — ~32x smaller; meaningful recall loss but pairs well with
+ *   a float32 reranker pass over a small candidate set.
+ *
+ * Non-dense representations:
+ * - `sparse` — learned sparse vector for hybrid (dense + lexical) search.
+ *   Currently Jina ELSER only on hosted APIs.
+ * - `multivector` — one vector per token for late-interaction (ColBERT-
+ *   style) scoring via `Vector.maxSim`. Currently Jina v4 only.
+ *
+ * Each provider's typed request narrows this to its supported set at
+ * compile time (e.g. `JinaEncoding = "float32" | "binary" | "sparse" |
+ * "multivector"`). On the generic `EmbeddingModel` path, callers can
+ * pass any `Encoding` and the provider's API will reject mismatches at
+ * runtime.
+ */
+type Encoding = "float32" | "int8" | "binary" | "sparse" | "multivector";
+/**
+ * Cross-provider single-embed request. Mirrors the shape of
+ * `LanguageModel.CommonRequest`: cross-cutting fields here, vendor
+ * specifics in the provider's typed request.
+ *
+ * Provider-specific extensions (Cohere widened `task` enum, Jina LoRA
+ * tasks, Mixedbread free-form `prompt`, etc.) live in that provider's own
+ * request interface, which extends this and narrows `model` / widens
+ * `task`.
+ */
+type CommonEmbedRequest = {
+  readonly input: EmbedInput;
+  /**
+   * Model identifier. Each provider narrows this to its typed literal
+   * union, so code that yields a typed provider tag gets autocompletion.
+   */
+  readonly model: string;
+  /**
+   * Retrieval-task hint. Applies to the input. OpenAI ignores this;
+   * Mixedbread doesn't have it; Cohere v3+ requires it on the wire (typed
+   * as required in `CohereEmbedRequest`). Provider-specific task enums
+   * (classification, clustering, code retrieval, …) live on the
+   * provider's own request type.
+   */
+  readonly task?: "query" | "document";
+  /**
+   * Matryoshka truncation. Default: provider's native dimension.
+   * Discrete-value providers (Cohere, Vertex `multimodalembedding@001`)
+   * narrow this to a literal union in their typed request.
+   */
+  readonly dimensions?: number;
+  /**
+   * Output representation - see {@link Encoding}. Dense float32 is the
+   * default; provider layers reject unsupported values up front with
+   * `InvalidRequest`.
+   */
+  readonly encoding?: Encoding;
+};
+/**
+ * Cross-provider batch-embed request. One `task` for the whole batch -
+ * mixed-task batches aren't a real provider feature (rerankers exist for
+ * that).
+ */
+type CommonEmbedManyRequest = Omit<CommonEmbedRequest, "input"> & {
+  readonly inputs: ReadonlyArray<EmbedInput>;
+};
+type EmbedResponse = {
+  readonly embedding: Embedding;
+  readonly usage: Usage;
+};
+type EmbedManyResponse = {
+  readonly embeddings: ReadonlyArray<Embedding>;
+  readonly usage: Usage;
+};
+type EmbeddingModelService = {
+  readonly embed: (request: CommonEmbedRequest) => Effect.Effect<EmbedResponse, AiError>;
+  readonly embedMany: (request: CommonEmbedManyRequest) => Effect.Effect<EmbedManyResponse, AiError>;
+};
+declare const EmbeddingModel_base: Context.ServiceClass<EmbeddingModel, "@betalyra/effect-uai/EmbeddingModel", EmbeddingModelService>;
+declare class EmbeddingModel extends EmbeddingModel_base {}
+/** Embed a single input. */
+declare const embed: (request: CommonEmbedRequest) => Effect.Effect<EmbedResponse, AiError, EmbeddingModel>;
+/** Embed a batch in one provider call. Same `task` for every input. */
+declare const embedMany: (request: CommonEmbedManyRequest) => Effect.Effect<EmbedManyResponse, AiError, EmbeddingModel>;
+//#endregion
+export { CommonEmbedManyRequest, CommonEmbedRequest, EmbedManyResponse, EmbedResponse, EmbeddingModel, EmbeddingModelService, Encoding, embed, embedMany, EmbeddingModel_d_exports as t };
+//# sourceMappingURL=EmbeddingModel.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EmbeddingModel.d.mts","names":[],"sources":["../../src/embedding-model/EmbeddingModel.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAyBA;;;;;AAYA;;KAZY,QAAA;;;;;;;;;;;KAYA,kBAAA;EAAA,SACD,KAAA,EAAO,UAAA;;;;;WAKP,KAAA;EA6BqB;;;;;;;EAAA,SArBrB,IAAA;EAqBgC;AAG3C;;;;EAH2C,SAfhC,UAAA;EAmBW;;;;;EAAA,SAbX,QAAA,GAAW,QAAA;AAAA;;;;;;KAQV,sBAAA,GAAyB,IAAA,CAAK,kBAAA;EAAA,SAC/B,MAAA,EAAQ,aAAA,CAAc,UAAA;AAAA;AAAA,KAGrB,aAAA;EAAA,SACD,SAAA,EAAW,SAAA;EAAA,SACX,KAAA,EAAO,KAAA;AAAA;AAAA,KAGN,iBAAA;EAAA,SACD,UAAA,EAAY,aAAA,CAAc,SAAA;EAAA,SAC1B,KAAA,EAAO,KAAA;AAAA;AAAA,KAGN,qBAAA;EAAA,SACD,KAAA,GAAQ,OAAA,EAAS,kBAAA,KAAuB,MAAA,CAAO,MAAA,CAAO,aAAA,EAAe,OAAA;EAAA,SACrE,SAAA,GACP,OAAA,EAAS,sBAAA,KACN,MAAA,CAAO,MAAA,CAAO,iBAAA,EAAmB,OAAA;AAAA;AAAA,cACvC,mBAAA;cAEY,cAAA,SAAuB,mBAAA;;cAKvB,KAAA,GACX,OAAA,EAAS,kBAAA,KACR,MAAA,CAAO,MAAA,CAAO,aAAA,EAAe,OAAA,EAAiB,cAAA;;cAIpC,SAAA,GACX,OAAA,EAAS,sBAAA,KACR,MAAA,CAAO,MAAA,CAAO,iBAAA,EAAmB,OAAA,EAAiB,cAAA"}

package/dist/embedding-model/EmbeddingModel.mjs

@@ -0,0 +1,17 @@
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { Context, Effect } from "effect";
+//#region src/embedding-model/EmbeddingModel.ts
+var EmbeddingModel_exports = /* @__PURE__ */ __exportAll({
+	EmbeddingModel: () => EmbeddingModel,
+	embed: () => embed,
+	embedMany: () => embedMany
+});
+var EmbeddingModel = class extends Context.Service()("@betalyra/effect-uai/EmbeddingModel") {};
+/** Embed a single input. */
+const embed = (request) => Effect.flatMap(EmbeddingModel.asEffect(), (m) => m.embed(request));
+/** Embed a batch in one provider call. Same `task` for every input. */
+const embedMany = (request) => Effect.flatMap(EmbeddingModel.asEffect(), (m) => m.embedMany(request));
+//#endregion
+export { EmbeddingModel, embed, embedMany, EmbeddingModel_exports as t };
+
+//# sourceMappingURL=EmbeddingModel.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EmbeddingModel.mjs","names":[],"sources":["../../src/embedding-model/EmbeddingModel.ts"],"sourcesContent":["import { Context, Effect } from \"effect\"\nimport * as AiError from \"../domain/AiError.js\"\nimport type { Embedding, EmbedInput, Usage } from \"./Embedding.js\"\n\n/**\n * Output representation requested from the provider.\n *\n * Dense quantizations - same vector at different storage cost:\n * - `float32` — universal default.\n * - `int8` — ~4x smaller; minimal recall loss on most benchmarks.\n * - `binary` — ~32x smaller; meaningful recall loss but pairs well with\n *   a float32 reranker pass over a small candidate set.\n *\n * Non-dense representations:\n * - `sparse` — learned sparse vector for hybrid (dense + lexical) search.\n *   Currently Jina ELSER only on hosted APIs.\n * - `multivector` — one vector per token for late-interaction (ColBERT-\n *   style) scoring via `Vector.maxSim`. Currently Jina v4 only.\n *\n * Each provider's typed request narrows this to its supported set at\n * compile time (e.g. `JinaEncoding = \"float32\" | \"binary\" | \"sparse\" |\n * \"multivector\"`). On the generic `EmbeddingModel` path, callers can\n * pass any `Encoding` and the provider's API will reject mismatches at\n * runtime.\n */\nexport type Encoding = \"float32\" | \"int8\" | \"binary\" | \"sparse\" | \"multivector\"\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 Encoding}. Dense float32 is the\n   * default; provider layers reject unsupported values up front with\n   * `InvalidRequest`.\n   */\n  readonly encoding?: Encoding\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\nexport type EmbedResponse = {\n  readonly embedding: Embedding\n  readonly usage: Usage\n}\n\nexport type EmbedManyResponse = {\n  readonly embeddings: ReadonlyArray<Embedding>\n  readonly usage: Usage\n}\n\nexport type EmbeddingModelService = {\n  readonly embed: (request: CommonEmbedRequest) => Effect.Effect<EmbedResponse, AiError.AiError>\n  readonly embedMany: (\n    request: CommonEmbedManyRequest,\n  ) => Effect.Effect<EmbedManyResponse, 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 = (\n  request: CommonEmbedRequest,\n): Effect.Effect<EmbedResponse, AiError.AiError, EmbeddingModel> =>\n  Effect.flatMap(EmbeddingModel.asEffect(), (m) => m.embed(request))\n\n/** Embed a batch in one provider call. Same `task` for every input. */\nexport const embedMany = (\n  request: CommonEmbedManyRequest,\n): Effect.Effect<EmbedManyResponse, AiError.AiError, EmbeddingModel> =>\n  Effect.flatMap(EmbeddingModel.asEffect(), (m) => m.embedMany(request))\n"],"mappings":";;;;;;;;AA4FA,IAAa,iBAAb,cAAoC,QAAQ,SAAgD,CAC1F,sCACD,CAAC;;AAGF,MAAa,SACX,YAEA,OAAO,QAAQ,eAAe,UAAU,GAAG,MAAM,EAAE,MAAM,QAAQ,CAAC;;AAGpE,MAAa,aACX,YAEA,OAAO,QAAQ,eAAe,UAAU,GAAG,MAAM,EAAE,UAAU,QAAQ,CAAC"}

package/dist/index.d.mts

@@ -1,14 +1,28 @@
-import { n as AiError_d_exports } from "./AiError-CqmYjXyx.mjs";
-import { h as Items_d_exports } from "./Items-D1C2686t.mjs";
-import { a as StructuredFormat_d_exports } from "./StructuredFormat-B5ueioNr.mjs";
-import { a as Turn_d_exports } from "./Turn-Bi83du4I.mjs";
-import { l as Tool_d_exports } from "./Tool-5wxOCuOh.mjs";
+import { n as AiError_d_exports } from "./AiError-csR8Bhxx.mjs";
+import { a as Media_d_exports } from "./Media-D_CpcM1Z.mjs";
+import { o as Audio_d_exports } from "./Audio-BfCTGnH3.mjs";
+import { o as Image_d_exports } from "./Image-DxyXqzAM.mjs";
+import { f as Items_d_exports } from "./Items-Hg5AsYxl.mjs";
+import { t as Music_d_exports } from "./domain/Music.mjs";
+import { t as Transcript_d_exports } from "./domain/Transcript.mjs";
+import { a as StructuredFormat_d_exports } from "./StructuredFormat-Cl41C56K.mjs";
+import { a as Turn_d_exports } from "./Turn-7geUcKsf.mjs";
+import { t as Embedding_d_exports } from "./embedding-model/Embedding.mjs";
+import { t as EmbeddingModel_d_exports } from "./embedding-model/EmbeddingModel.mjs";
+import { l as Tool_d_exports } from "./Tool-B8B5qVEy.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 SpeechSynthesizer_d_exports } from "./speech-synthesizer/SpeechSynthesizer.mjs";
+import { t as Transcriber_d_exports } from "./transcriber/Transcriber.mjs";
+import { t as Vector_d_exports } from "./math/Vector.mjs";
 import { t as Loop_d_exports } from "./loop/Loop.mjs";
-import { t as Match_d_exports } from "./match/Match.mjs";
+import { t as Outcome_d_exports } from "./tool/Outcome.mjs";
+import { t as ToolEvent_d_exports } from "./tool/ToolEvent.mjs";
 import { t as Toolkit_d_exports } from "./tool/Toolkit.mjs";
+import { t as Resolvers_d_exports } from "./tool/Resolvers.mjs";
+import { t as HistoryCheck_d_exports } from "./tool/HistoryCheck.mjs";
 import { t as JSONL_d_exports } from "./streaming/JSONL.mjs";
 import { t as Lines_d_exports } from "./streaming/Lines.mjs";
 import { t as SSE_d_exports } from "./streaming/SSE.mjs";
 import { t as Metrics_d_exports } from "./observability/Metrics.mjs";
-export { AiError_d_exports as AiError, Items_d_exports as Items, JSONL_d_exports as JSONL, LanguageModel_d_exports as LanguageModel, Lines_d_exports as Lines, Loop_d_exports as Loop, Match_d_exports as Match, Metrics_d_exports as Metrics, SSE_d_exports as SSE, StructuredFormat_d_exports as StructuredFormat, Tool_d_exports as Tool, Toolkit_d_exports as Toolkit, Turn_d_exports as Turn };
+export { AiError_d_exports as AiError, Audio_d_exports as Audio, Embedding_d_exports as Embedding, EmbeddingModel_d_exports as EmbeddingModel, HistoryCheck_d_exports as HistoryCheck, Image_d_exports as Image, Items_d_exports as Items, JSONL_d_exports as JSONL, LanguageModel_d_exports as LanguageModel, Lines_d_exports as Lines, Loop_d_exports as Loop, Media_d_exports as Media, Metrics_d_exports as Metrics, Music_d_exports as Music, MusicGenerator_d_exports as MusicGenerator, Outcome_d_exports as Outcome, Resolvers_d_exports as Resolvers, SSE_d_exports as SSE, SpeechSynthesizer_d_exports as SpeechSynthesizer, StructuredFormat_d_exports as StructuredFormat, Tool_d_exports as Tool, ToolEvent_d_exports as ToolEvent, Toolkit_d_exports as Toolkit, Transcriber_d_exports as Transcriber, Transcript_d_exports as Transcript, Turn_d_exports as Turn, Vector_d_exports as Vector };

package/dist/index.mjs

@@ -1,14 +1,28 @@
 import { t as AiError_exports } from "./domain/AiError.mjs";
+import { t as Audio_exports } from "./domain/Audio.mjs";
+import { t as Image_exports } from "./domain/Image.mjs";
 import { t as Items_exports } from "./domain/Items.mjs";
+import { t as Media_exports } from "./domain/Media.mjs";
+import { t as Music_exports } from "./domain/Music.mjs";
+import { t as Transcript_exports } from "./domain/Transcript.mjs";
 import { t as StructuredFormat_exports } from "./structured-format/StructuredFormat.mjs";
 import { t as Turn_exports } from "./domain/Turn.mjs";
+import { t as Embedding_exports } from "./embedding-model/Embedding.mjs";
+import { t as EmbeddingModel_exports } from "./embedding-model/EmbeddingModel.mjs";
 import { t as LanguageModel_exports } from "./language-model/LanguageModel.mjs";
+import { t as MusicGenerator_exports } from "./music-generator/MusicGenerator.mjs";
+import { t as SpeechSynthesizer_exports } from "./speech-synthesizer/SpeechSynthesizer.mjs";
+import { t as Transcriber_exports } from "./transcriber/Transcriber.mjs";
+import { t as Vector_exports } from "./math/Vector.mjs";
 import { t as Loop_exports } from "./loop/Loop.mjs";
-import { t as Match_exports } from "./match/Match.mjs";
 import { t as Tool_exports } from "./tool/Tool.mjs";
+import { t as Outcome_exports } from "./tool/Outcome.mjs";
+import { t as ToolEvent_exports } from "./tool/ToolEvent.mjs";
 import { t as Toolkit_exports } from "./tool/Toolkit.mjs";
+import { t as Resolvers_exports } from "./tool/Resolvers.mjs";
+import { t as HistoryCheck_exports } from "./tool/HistoryCheck.mjs";
 import { t as JSONL_exports } from "./streaming/JSONL.mjs";
 import { t as Lines_exports } from "./streaming/Lines.mjs";
 import { t as SSE_exports } from "./streaming/SSE.mjs";
 import { t as Metrics_exports } from "./observability/Metrics.mjs";
-export { AiError_exports as AiError, Items_exports as Items, JSONL_exports as JSONL, LanguageModel_exports as LanguageModel, Lines_exports as Lines, Loop_exports as Loop, Match_exports as Match, Metrics_exports as Metrics, SSE_exports as SSE, StructuredFormat_exports as StructuredFormat, Tool_exports as Tool, Toolkit_exports as Toolkit, Turn_exports as Turn };
+export { AiError_exports as AiError, Audio_exports as Audio, Embedding_exports as Embedding, EmbeddingModel_exports as EmbeddingModel, HistoryCheck_exports as HistoryCheck, Image_exports as Image, Items_exports as Items, JSONL_exports as JSONL, LanguageModel_exports as LanguageModel, Lines_exports as Lines, Loop_exports as Loop, Media_exports as Media, Metrics_exports as Metrics, Music_exports as Music, MusicGenerator_exports as MusicGenerator, Outcome_exports as Outcome, Resolvers_exports as Resolvers, SSE_exports as SSE, SpeechSynthesizer_exports as SpeechSynthesizer, StructuredFormat_exports as StructuredFormat, Tool_exports as Tool, ToolEvent_exports as ToolEvent, Toolkit_exports as Toolkit, Transcriber_exports as Transcriber, Transcript_exports as Transcript, Turn_exports as Turn, Vector_exports as Vector };

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

@@ -1,13 +1,13 @@
-import { t as AiError } from "../AiError-CqmYjXyx.mjs";
-import { m as Item } from "../Items-D1C2686t.mjs";
-import { i as StructuredFormat } from "../StructuredFormat-B5ueioNr.mjs";
-import { i as TurnEvent, r as Turn } from "../Turn-Bi83du4I.mjs";
-import { o as ToolDescriptor } from "../Tool-5wxOCuOh.mjs";
-import { Context, Effect, Stream } from "effect";
+import { t as AiError } from "../AiError-csR8Bhxx.mjs";
+import { d as Item } from "../Items-Hg5AsYxl.mjs";
+import { i as StructuredFormat } from "../StructuredFormat-Cl41C56K.mjs";
+import { i as TurnEvent } from "../Turn-7geUcKsf.mjs";
+import { o as ToolDescriptor } from "../Tool-B8B5qVEy.mjs";
+import { Context, Stream } from "effect";
 
 //#region src/language-model/LanguageModel.d.ts
 declare namespace LanguageModel_d_exports {
-  export { CommonRequest, LanguageModel, LanguageModelService, streamTurn, turn };
+  export { CommonRequest, LanguageModel, LanguageModelService, streamTurn };
 }
 /**
  * Cross-provider request shape. Every call carries its own `history` and
@@ -15,7 +15,7 @@ declare namespace LanguageModel_d_exports {
  * to a single provider (reasoning effort, prompt caching, store flags,
  * ...) lives in that provider's own request interface, which extends this.
  */
-interface CommonRequest {
+type CommonRequest = {
   readonly history: ReadonlyArray<Item>;
   /**
    * Model identifier. Each provider narrows this to its typed literal union,
@@ -37,24 +37,16 @@ interface CommonRequest {
    * `output_config`, Gemini `responseJsonSchema`).
    */
   readonly structured?: StructuredFormat<unknown>;
-}
-interface LanguageModelService {
+};
+type LanguageModelService = {
   readonly streamTurn: (request: CommonRequest) => Stream.Stream<TurnEvent, AiError>;
-}
+};
 declare const LanguageModel_base: Context.ServiceClass<LanguageModel, "@betalyra/effect-uai/LanguageModel", LanguageModelService>;
 declare class LanguageModel extends LanguageModel_base {}
 /**
  * Stream the deltas of a single turn.
  */
 declare const streamTurn: (request: CommonRequest) => Stream.Stream<TurnEvent, AiError, LanguageModel>;
-/**
- * Run a single turn to completion and return the assembled `Turn`.
- *
- * Implementation: drain the delta stream and pluck the terminal
- * `turn_complete` event. The provider is contractually required to emit
- * exactly one such event as the last delta.
- */
-declare const turn: (request: CommonRequest) => Effect.Effect<Turn, AiError, LanguageModel>;
 //#endregion
-export { CommonRequest, LanguageModel, LanguageModelService, streamTurn, LanguageModel_d_exports as t, turn };
+export { CommonRequest, LanguageModel, LanguageModelService, streamTurn, LanguageModel_d_exports as t };
 //# sourceMappingURL=LanguageModel.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"LanguageModel.d.mts","names":[],"sources":["../../src/language-model/LanguageModel.ts"],"mappings":";;;;;;;;;;;;;;;;;UAaiB,aAAA;EAAA,SACN,OAAA,EAAS,aAAA,CAAc,IAAA;;;AADlC;;WAMW,KAAA;EAAA,SACA,KAAA,GAAQ,aAAA,CAAc,cAAA;EAAA,SACtB,UAAA;IAAA,SAIM,IAAA;IAAA,SAA2B,IAAA;EAAA;EAAA,SACjC,WAAA;EAAA,SACA,IAAA;EAAA,SACA,eAAA;EAdS;;;;;;EAAA,SAqBT,UAAA,GAAa,gBAAA;AAAA;AAAA,UAGP,oBAAA;EAAA,SACN,UAAA,GAAa,OAAA,EAAS,aAAA,KAAkB,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,OAAA;AAAA;AAAA,cAC3E,kBAAA;cAEY,aAAA,SAAsB,kBAAA;;;;cAOtB,UAAA,GACX,OAAA,EAAS,aAAA,KACR,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,OAAA,EAAiB,aAAA;;;;;;;;cAUhC,IAAA,GAAQ,OAAA,EAAS,aAAA,KAAgB,MAAA,CAAO,MAAA,CAAO,IAAA,EAAM,OAAA,EAAiB,aAAA"}
+{"version":3,"file":"LanguageModel.d.mts","names":[],"sources":["../../src/language-model/LanguageModel.ts"],"mappings":";;;;;;;;;;;;;;;;;KAaY,aAAA;EAAA,SACD,OAAA,EAAS,aAAA,CAAc,IAAA;;AADlC;;;WAMW,KAAA;EAAA,SACA,KAAA,GAAQ,aAAA,CAAc,cAAA;EAAA,SACtB,UAAA;IAAA,SAIM,IAAA;IAAA,SAA2B,IAAA;EAAA;EAAA,SACjC,WAAA;EAAA,SACA,IAAA;EAAA,SACA,eAAA;EAduB;;;;;;EAAA,SAqBvB,UAAA,GAAa,gBAAA;AAAA;AAAA,KAGZ,oBAAA;EAAA,SACD,UAAA,GAAa,OAAA,EAAS,aAAA,KAAkB,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,OAAA;AAAA;AAAA,cAC3E,kBAAA;cAEY,aAAA,SAAsB,kBAAA;;;AAJnC;cAWa,UAAA,GACX,OAAA,EAAS,aAAA,KACR,MAAA,CAAO,MAAA,CAAO,SAAA,EAAW,OAAA,EAAiB,aAAA"}

package/dist/language-model/LanguageModel.mjs

@@ -1,33 +1,16 @@
-import { t as __exportAll } from "../chunk-CfYAbeIz.mjs";
-import { Unavailable } from "../domain/AiError.mjs";
-import { isTurnComplete } from "../domain/Turn.mjs";
+import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
 import { Context, Effect, Stream } from "effect";
 //#region src/language-model/LanguageModel.ts
 var LanguageModel_exports = /* @__PURE__ */ __exportAll({
 	LanguageModel: () => LanguageModel,
-	streamTurn: () => streamTurn,
-	turn: () => turn
+	streamTurn: () => streamTurn
 });
 var LanguageModel = class extends Context.Service()("@betalyra/effect-uai/LanguageModel") {};
 /**
 * Stream the deltas of a single turn.
 */
 const streamTurn = (request) => Stream.unwrap(Effect.map(LanguageModel.asEffect(), (m) => m.streamTurn(request)));
-/**
-* Run a single turn to completion and return the assembled `Turn`.
-*
-* Implementation: drain the delta stream and pluck the terminal
-* `turn_complete` event. The provider is contractually required to emit
-* exactly one such event as the last delta.
-*/
-const turn = (request) => Effect.flatMap(Stream.runCollect(streamTurn(request)), (deltas) => {
-	const last = deltas[deltas.length - 1];
-	return last !== void 0 && isTurnComplete(last) ? Effect.succeed(last.turn) : Effect.fail(new Unavailable({
-		provider: "unknown",
-		raw: "Provider stream ended without a turn_complete event"
-	}));
-});
 //#endregion
-export { LanguageModel, streamTurn, LanguageModel_exports as t, turn };
+export { LanguageModel, streamTurn, LanguageModel_exports as t };
 
 //# sourceMappingURL=LanguageModel.mjs.map

package/dist/language-model/LanguageModel.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"LanguageModel.mjs","names":["AiError.Unavailable"],"sources":["../../src/language-model/LanguageModel.ts"],"sourcesContent":["import { Context, Effect, Stream } from \"effect\"\nimport * as AiError from \"../domain/AiError.js\"\nimport type { Item } from \"../domain/Items.js\"\nimport type * as StructuredFormat from \"../structured-format/StructuredFormat.js\"\nimport type { ToolDescriptor } from \"../tool/Tool.js\"\nimport { isTurnComplete, type Turn, type TurnEvent } from \"../domain/Turn.js\"\n\n/**\n * Cross-provider request shape. Every call carries its own `history` and\n * `model` - models are not bound at layer construction. Anything specific\n * to a single provider (reasoning effort, prompt caching, store flags,\n * ...) lives in that provider's own request interface, which extends this.\n */\nexport interface CommonRequest {\n  readonly history: ReadonlyArray<Item>\n  /**\n   * Model identifier. Each provider narrows this to its typed literal union,\n   * so code that yields a typed provider tag gets autocompletion.\n   */\n  readonly model: string\n  readonly tools?: ReadonlyArray<ToolDescriptor>\n  readonly toolChoice?:\n    | \"auto\"\n    | \"required\"\n    | \"none\"\n    | { readonly type: \"function\"; readonly name: string }\n  readonly temperature?: number\n  readonly topP?: number\n  readonly maxOutputTokens?: number\n  /**\n   * Schema-bound JSON output. The provider constrains the wire to match the\n   * schema; pair with `Turn.toStructured` for runtime validation. Supported\n   * across all current providers (OpenAI Responses json_schema, Anthropic\n   * `output_config`, Gemini `responseJsonSchema`).\n   */\n  readonly structured?: StructuredFormat.StructuredFormat<unknown>\n}\n\nexport interface LanguageModelService {\n  readonly streamTurn: (request: CommonRequest) => Stream.Stream<TurnEvent, AiError.AiError>\n}\n\nexport class LanguageModel extends Context.Service<LanguageModel, LanguageModelService>()(\n  \"@betalyra/effect-uai/LanguageModel\",\n) {}\n\n/**\n * Stream the deltas of a single turn.\n */\nexport const streamTurn = (\n  request: CommonRequest,\n): Stream.Stream<TurnEvent, AiError.AiError, LanguageModel> =>\n  Stream.unwrap(Effect.map(LanguageModel.asEffect(), (m) => m.streamTurn(request)))\n\n/**\n * Run a single turn to completion and return the assembled `Turn`.\n *\n * Implementation: drain the delta stream and pluck the terminal\n * `turn_complete` event. The provider is contractually required to emit\n * exactly one such event as the last delta.\n */\nexport const turn = (request: CommonRequest): Effect.Effect<Turn, AiError.AiError, LanguageModel> =>\n  Effect.flatMap(Stream.runCollect(streamTurn(request)), (deltas) => {\n    const last = deltas[deltas.length - 1]\n    return last !== undefined && isTurnComplete(last)\n      ? Effect.succeed(last.turn)\n      : Effect.fail(\n          new AiError.Unavailable({\n            provider: \"unknown\",\n            raw: \"Provider stream ended without a turn_complete event\",\n          }),\n        )\n  })\n"],"mappings":";;;;;;;;;;AA0CA,IAAa,gBAAb,cAAmC,QAAQ,SAA8C,CACvF,qCACD,CAAC;;;;AAKF,MAAa,cACX,YAEA,OAAO,OAAO,OAAO,IAAI,cAAc,UAAU,GAAG,MAAM,EAAE,WAAW,QAAQ,CAAC,CAAC;;;;;;;;AASnF,MAAa,QAAQ,YACnB,OAAO,QAAQ,OAAO,WAAW,WAAW,QAAQ,CAAC,GAAG,WAAW;CACjE,MAAM,OAAO,OAAO,OAAO,SAAS;AACpC,QAAO,SAAS,KAAA,KAAa,eAAe,KAAK,GAC7C,OAAO,QAAQ,KAAK,KAAK,GACzB,OAAO,KACL,IAAIA,YAAoB;EACtB,UAAU;EACV,KAAK;EACN,CAAC,CACH;EACL"}
+{"version":3,"file":"LanguageModel.mjs","names":[],"sources":["../../src/language-model/LanguageModel.ts"],"sourcesContent":["import { Context, Effect, Stream } from \"effect\"\nimport * as AiError from \"../domain/AiError.js\"\nimport type { Item } from \"../domain/Items.js\"\nimport type * as StructuredFormat from \"../structured-format/StructuredFormat.js\"\nimport type { ToolDescriptor } from \"../tool/Tool.js\"\nimport { isTurnComplete, type Turn, type TurnEvent } from \"../domain/Turn.js\"\n\n/**\n * Cross-provider request shape. Every call carries its own `history` and\n * `model` - models are not bound at layer construction. Anything specific\n * to a single provider (reasoning effort, prompt caching, store flags,\n * ...) lives in that provider's own request interface, which extends this.\n */\nexport type CommonRequest = {\n  readonly history: ReadonlyArray<Item>\n  /**\n   * Model identifier. Each provider narrows this to its typed literal union,\n   * so code that yields a typed provider tag gets autocompletion.\n   */\n  readonly model: string\n  readonly tools?: ReadonlyArray<ToolDescriptor>\n  readonly toolChoice?:\n    | \"auto\"\n    | \"required\"\n    | \"none\"\n    | { readonly type: \"function\"; readonly name: string }\n  readonly temperature?: number\n  readonly topP?: number\n  readonly maxOutputTokens?: number\n  /**\n   * Schema-bound JSON output. The provider constrains the wire to match the\n   * schema; pair with `Turn.toStructured` for runtime validation. Supported\n   * across all current providers (OpenAI Responses json_schema, Anthropic\n   * `output_config`, Gemini `responseJsonSchema`).\n   */\n  readonly structured?: StructuredFormat.StructuredFormat<unknown>\n}\n\nexport type LanguageModelService = {\n  readonly streamTurn: (request: CommonRequest) => Stream.Stream<TurnEvent, AiError.AiError>\n}\n\nexport class LanguageModel extends Context.Service<LanguageModel, LanguageModelService>()(\n  \"@betalyra/effect-uai/LanguageModel\",\n) {}\n\n/**\n * Stream the deltas of a single turn.\n */\nexport const streamTurn = (\n  request: CommonRequest,\n): Stream.Stream<TurnEvent, AiError.AiError, LanguageModel> =>\n  Stream.unwrap(Effect.map(LanguageModel.asEffect(), (m) => m.streamTurn(request)))\n"],"mappings":";;;;;;;AA0CA,IAAa,gBAAb,cAAmC,QAAQ,SAA8C,CACvF,qCACD,CAAC;;;;AAKF,MAAa,cACX,YAEA,OAAO,OAAO,OAAO,IAAI,cAAc,UAAU,GAAG,MAAM,EAAE,WAAW,QAAQ,CAAC,CAAC"}