@effect-uai/core 0.6.0 → 0.7.0

package/dist/domain/Music.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Music.mjs","names":[],"sources":["../../src/domain/Music.ts"],"sourcesContent":["import type { AudioBlob, AudioFormat } from \"./Audio.js\"\n\n/**\n * Prompt fragment with a relative weight. Native to Lyria RealTime\n * (`{ text, weight }` pairs blended in the model). Single-prompt\n * providers (Suno, Mureka, MiniMax) flatten to text at the adapter\n * layer.\n */\nexport type WeightedPrompt = {\n  readonly text: string\n  /** Default `1.0`. Range typically `[0, 1]`; provider-dependent. */\n  readonly weight?: number\n}\n\n/**\n * Cross-provider music-generation request. Provider-specific extras\n * (Lyria `mode`, ElevenLabs `composition_plan`, Suno custom-mode `title`,\n * MiniMax `lyrics_optimizer`) live on each provider's typed request\n * which extends this and narrows `model`.\n */\nexport type CommonGenerateMusicRequest = {\n  /** Model identifier. Each provider narrows. */\n  readonly model: string\n  /** Single prompt string or weighted-prompt list (blended where supported). */\n  readonly prompts: string | ReadonlyArray<WeightedPrompt>\n  /**\n   * Lyrics text, optionally with section tags like `[Verse]` / `[Chorus]` /\n   * `[Bridge]` / `[Outro]`. Ignored for instrumental-only providers or\n   * when `instrumental: true`.\n   */\n  readonly lyrics?: string\n  /** Target duration in seconds. Provider may treat as a hint or hard limit. */\n  readonly durationSeconds?: number\n  /** Beats per minute (60–200 typical). */\n  readonly bpm?: number\n  /**\n   * Musical key/mode hint. Provider-specific vocabulary (e.g. Lyria\n   * RealTime uses enum values like `\"C_MAJOR\"`, `\"A_MINOR\"`).\n   */\n  readonly scale?: string\n  /** Skip vocals / lyrics. */\n  readonly instrumental?: boolean\n  /** Preferred output format. Provider may override. */\n  readonly outputFormat?: AudioFormat\n}\n\n/**\n * Streamed-output request. Same shape as the sync request — the\n * streaming variant only differs in how the response is delivered.\n */\nexport type CommonStreamGenerateMusicRequest = CommonGenerateMusicRequest\n\n/**\n * Bidirectional-session input. The user pushes one of these per\n * change: a new prompt blend, a config delta, or a playback control.\n * Lyria RealTime is the only provider currently surfacing these.\n */\nexport type MusicSessionInput =\n  | { readonly _tag: \"prompts\"; readonly prompts: ReadonlyArray<WeightedPrompt> }\n  | {\n      readonly _tag: \"config\"\n      readonly config: {\n        readonly bpm?: number\n        readonly scale?: string\n        readonly density?: number\n        readonly brightness?: number\n        readonly guidance?: number\n        readonly temperature?: number\n        readonly topK?: number\n        readonly seed?: number\n        readonly muteBass?: boolean\n        readonly muteDrums?: boolean\n        readonly onlyBassAndDrums?: boolean\n      }\n    }\n  | { readonly _tag: \"control\"; readonly action: \"play\" | \"pause\" | \"stop\" | \"reset_context\" }\n\nexport const promptsInput = (prompts: ReadonlyArray<WeightedPrompt>): MusicSessionInput => ({\n  _tag: \"prompts\",\n  prompts,\n})\n\nexport const configInput = (\n  config: (MusicSessionInput & { _tag: \"config\" })[\"config\"],\n): MusicSessionInput => ({ _tag: \"config\", config })\n\nexport const controlInput = (\n  action: (MusicSessionInput & { _tag: \"control\" })[\"action\"],\n): MusicSessionInput => ({ _tag: \"control\", action })\n\n/**\n * Sync-generation result. Extends `AudioBlob` with provider-side\n * metadata that's common across music providers:\n *\n * - `songId` — Suno task id, ElevenLabs `song_id`, etc. Used for\n *   back-reference (re-download, stem export, follow-up edits).\n * - `lyrics` — generated lyrics when the model returned them (Lyria\n *   text part, Mureka, Suno).\n * - `sections` — structured section markers (Lyria optional JSON\n *   structure response).\n * - `watermark` — presence marker (Lyria SynthID is always set).\n */\nexport type MusicResult = AudioBlob & {\n  readonly songId?: string\n  readonly lyrics?: string\n  readonly sections?: ReadonlyArray<{\n    readonly label: string\n    readonly startSeconds: number\n    readonly endSeconds: number\n  }>\n  readonly watermark?: { readonly kind: string }\n}\n\nexport const isPromptsInput = (\n  i: MusicSessionInput,\n): i is MusicSessionInput & { _tag: \"prompts\" } => i._tag === \"prompts\"\nexport const isConfigInput = (i: MusicSessionInput): i is MusicSessionInput & { _tag: \"config\" } =>\n  i._tag === \"config\"\nexport const isControlInput = (\n  i: MusicSessionInput,\n): i is MusicSessionInput & { _tag: \"control\" } => i._tag === \"control\"\n"],"mappings":";;;;;;;;;;AA6EA,MAAa,gBAAgB,aAA+D;CAC1F,MAAM;CACN;CACD;AAED,MAAa,eACX,YACuB;CAAE,MAAM;CAAU;CAAQ;AAEnD,MAAa,gBACX,YACuB;CAAE,MAAM;CAAW;CAAQ;AAyBpD,MAAa,kBACX,MACiD,EAAE,SAAS;AAC9D,MAAa,iBAAiB,MAC5B,EAAE,SAAS;AACb,MAAa,kBACX,MACiD,EAAE,SAAS"}
+{"version":3,"file":"Music.mjs","names":[],"sources":["../../src/domain/Music.ts"],"sourcesContent":["import type { Duration } from \"effect\"\nimport type { AudioBlob, AudioChunk, AudioFormat } from \"./Audio.js\"\n\n/**\n * Prompt fragment with a relative weight. Native to Lyria RealTime\n * (`{ text, weight }` pairs blended in the model) and Riffusion compose.\n * Single-prompt providers (the majority) treat a 1-element array with\n * `weight: 1` as a plain prompt.\n */\nexport type WeightedPrompt = {\n  readonly text: string\n  /** Default `1.0`. Range typically `[0, 1]`; provider-dependent. */\n  readonly weight?: number\n}\n\n/**\n * Cross-provider music-generation request. Trimmed to fields the\n * majority of music providers honor structurally; provider-specific\n * extras (Lyria `bpm` / `scale`, ElevenLabs `compositionPlan` /\n * `signWithC2pa`, Suno `style` / `personaId`, MiniMax `lyricsOptimizer`,\n * `instrumental` on providers that ship a wire toggle) live on each\n * provider's typed request which extends this and narrows `model`.\n *\n * Music providers are one-shot text-to-audio, not conversational. No\n * `messages[]` shape applies.\n */\nexport type CommonGenerateMusicRequest = {\n  /** Model identifier. Each provider narrows. */\n  readonly model: string\n  /** Single prompt string. Weighted blends are provider-typed extras. */\n  readonly prompt: string\n  /**\n   * Lyrics text, optionally with section tags like `[Verse]` /\n   * `[Chorus]` / `[Bridge]` / `[Outro]`. Routed to a structured wire\n   * field on providers that have one (ElevenLabs `lines`, MiniMax\n   * `lyrics`, Mureka `lyrics`, Suno custom-mode `prompt`); embedded in\n   * the prompt with a warning on providers without one (Lyria 3,\n   * Riffusion).\n   */\n  readonly lyrics?: string\n  /** Target duration. Provider may treat as a hint or hard limit. */\n  readonly duration?: Duration.Duration\n  /**\n   * Reproducibility seed. Tuning hint (bucket 3): honored where the\n   * provider takes one (Lyria 2 Vertex, Lyria RealTime, ElevenLabs\n   * with `compositionPlan`, Stable Audio, MusicGen); silently ignored\n   * elsewhere.\n   */\n  readonly seed?: number\n  /** Preferred output format. Provider may override. */\n  readonly outputFormat?: AudioFormat\n}\n\n/**\n * Streamed-output request. Same shape as the sync request: the\n * streaming variant only differs in how the response is delivered.\n */\nexport type CommonStreamGenerateMusicRequest = CommonGenerateMusicRequest\n\n/**\n * Playback-control vocabulary that converges across interactive-media\n * protocols (Web Audio, MIDI sequencer control, music SDK surfaces).\n * Provider-specific control actions (Lyria's `reset_context` and any\n * future provider's extras) live on the provider-typed session-input\n * union.\n */\nexport type MusicSessionControl = \"play\" | \"pause\" | \"stop\" | \"reset\"\n\n/**\n * Bidirectional-session input on the cross-provider surface. Two\n * load-bearing actions every interactive music session needs:\n *\n * - `prompts` — steer the active generation with a (single or\n *   weighted) prompt blend.\n * - `control` — play / pause / stop / reset.\n *\n * Provider-typed services extend this union with their own `config`\n * variant for model-specific knobs (Lyria RealTime exposes density /\n * brightness / mute-stems / BPM / scale / etc. via its own\n * `LyriaRealtimeSessionInput`).\n */\nexport type MusicSessionInput =\n  | { readonly _tag: \"prompts\"; readonly prompts: ReadonlyArray<WeightedPrompt> }\n  | { readonly _tag: \"control\"; readonly action: MusicSessionControl }\n\nexport const promptsInput = (prompts: ReadonlyArray<WeightedPrompt>): MusicSessionInput => ({\n  _tag: \"prompts\",\n  prompts,\n})\n\nexport const controlInput = (action: MusicSessionControl): MusicSessionInput => ({\n  _tag: \"control\",\n  action,\n})\n\n/**\n * Watermark kind on the response. SynthID is mandatory on Lyria; C2PA\n * is opt-in on ElevenLabs. No provider exposes additional metadata\n * about the watermark itself, so a bare literal-union is enough.\n */\nexport type Watermark = \"synthid\" | \"c2pa\" | (string & {})\n\n/**\n * Labelled section with absolute timing. Populated when the provider\n * returns structured section metadata (Lyria text part, ElevenLabs\n * `/v1/music/detailed` with `with_timestamps`).\n */\nexport type MusicSection = {\n  readonly label: string\n  readonly startSeconds: number\n  readonly endSeconds: number\n}\n\n/**\n * Single generated track. Composes `AudioBlob` rather than extending\n * it — `result.audio` is the raw blob, `result.songId` / `lyrics` /\n * `sections` / `watermark` are provider-side metadata when returned.\n */\nexport type MusicResult = {\n  readonly audio: AudioBlob\n  /**\n   * Provider identifier, useful when routing through multiple\n   * providers in a single pipeline (`\"lyria\"`, `\"elevenlabs-music\"`,\n   * etc.).\n   */\n  readonly provider?: string\n  /** Provider-side ID for back-reference (re-download, extension, stems). */\n  readonly songId?: string\n  /** Generated or transcribed lyrics when the provider returned them. */\n  readonly lyrics?: string\n  /** Structured section markers when the provider returned them. */\n  readonly sections?: ReadonlyArray<MusicSection>\n  /** Watermark presence indicator when the provider applied one. */\n  readonly watermark?: Watermark\n}\n\n/**\n * Result of a `generate` call. Suno and Mureka always return 2 tracks\n * per request; every other provider returns 1. `primary` is the\n * caller-friendly convenience; `variants` carries every track the\n * provider produced (length ≥ 1; `primary === variants[0]`).\n */\nexport type GenerateResult = {\n  readonly primary: MusicResult\n  readonly variants: ReadonlyArray<MusicResult>\n}\n\n/**\n * In-band event on the bidirectional `streamGenerationFrom` output\n * stream. Audio chunks flow as `audio`; server-side warnings\n * (`warning`) and prompt-filter rejections (`filteredPrompt`) flow\n * alongside rather than going to a side-channel log.\n */\nexport type MusicStreamEvent =\n  | { readonly _tag: \"audio\"; readonly chunk: AudioChunk }\n  | { readonly _tag: \"warning\"; readonly message: string }\n  | { readonly _tag: \"filteredPrompt\"; readonly prompt: string; readonly reason: string }\n\nexport const isPromptsInput = (\n  i: MusicSessionInput,\n): i is MusicSessionInput & { _tag: \"prompts\" } => i._tag === \"prompts\"\nexport const isControlInput = (\n  i: MusicSessionInput,\n): i is MusicSessionInput & { _tag: \"control\" } => i._tag === \"control\"\n\nexport const audioEvent = (chunk: AudioChunk): MusicStreamEvent => ({ _tag: \"audio\", chunk })\nexport const warningEvent = (message: string): MusicStreamEvent => ({\n  _tag: \"warning\",\n  message,\n})\nexport const filteredPromptEvent = (prompt: string, reason: string): MusicStreamEvent => ({\n  _tag: \"filteredPrompt\",\n  prompt,\n  reason,\n})\n\nexport const isAudioEvent = (e: MusicStreamEvent): e is MusicStreamEvent & { _tag: \"audio\" } =>\n  e._tag === \"audio\"\nexport const isWarningEvent = (e: MusicStreamEvent): e is MusicStreamEvent & { _tag: \"warning\" } =>\n  e._tag === \"warning\"\nexport const isFilteredPromptEvent = (\n  e: MusicStreamEvent,\n): e is MusicStreamEvent & { _tag: \"filteredPrompt\" } => e._tag === \"filteredPrompt\"\n\n/**\n * Build a single-variant `GenerateResult` from a `MusicResult`.\n * Convenience for providers that always return exactly one track\n * (Lyria, ElevenLabs, MiniMax, Stable Audio, MusicGen, Riffusion,\n * Tencent). Providers that return multiple tracks (Suno, Mureka)\n * construct the `GenerateResult` directly.\n */\nexport const singleVariant = (result: MusicResult): GenerateResult => ({\n  primary: result,\n  variants: [result],\n})\n"],"mappings":";;;;;;;;;;;;;;;AAqFA,MAAa,gBAAgB,aAA+D;CAC1F,MAAM;CACN;CACD;AAED,MAAa,gBAAgB,YAAoD;CAC/E,MAAM;CACN;CACD;AAiED,MAAa,kBACX,MACiD,EAAE,SAAS;AAC9D,MAAa,kBACX,MACiD,EAAE,SAAS;AAE9D,MAAa,cAAc,WAAyC;CAAE,MAAM;CAAS;CAAO;AAC5F,MAAa,gBAAgB,aAAuC;CAClE,MAAM;CACN;CACD;AACD,MAAa,uBAAuB,QAAgB,YAAsC;CACxF,MAAM;CACN;CACA;CACD;AAED,MAAa,gBAAgB,MAC3B,EAAE,SAAS;AACb,MAAa,kBAAkB,MAC7B,EAAE,SAAS;AACb,MAAa,yBACX,MACuD,EAAE,SAAS;;;;;;;;AASpE,MAAa,iBAAiB,YAAyC;CACrE,SAAS;CACT,UAAU,CAAC,OAAO;CACnB"}

package/dist/domain/Transcript.d.mts

@@ -1,3 +1,6 @@
+import { Duration } from "effect";
+
+//#region src/domain/Transcript.d.ts
 declare namespace Transcript_d_exports {
   export { TranscriptEvent, TranscriptResult, WordTimestamp, isAudioEvent, isError, isFinal, isMetadata, isPartial, isSpeechStarted, isUtteranceEnded };
 }
@@ -5,6 +8,9 @@ declare namespace Transcript_d_exports {
  * 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).
+ *
+ * `startSeconds` / `endSeconds` stay raw `number` offsets (not `Duration`)
+ * — they're positions in the audio, not durations.
  */
 type WordTimestamp = {
   readonly text: string;
@@ -21,8 +27,8 @@ type WordTimestamp = {
  */
 type TranscriptResult = {
   readonly text: string;
-  readonly languageCode?: string;
-  readonly durationSeconds?: number;
+  readonly languageCode?: string; /** Total audio duration. (Word offsets stay raw seconds on `WordTimestamp`.) */
+  readonly duration?: Duration.Duration;
   readonly words?: ReadonlyArray<WordTimestamp>;
   readonly raw?: unknown;
 };

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

@@ -1 +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"}
+{"version":3,"file":"Transcript.d.mts","names":[],"sources":["../../src/domain/Transcript.ts"],"mappings":";;;;;;;;;;;;;;KAUY,aAAA;EAAA,SACD,IAAA;EAAA,SACA,YAAA;EAAA,SACA,UAAA;EAAA,SACA,UAAA;EAAA,SACA,SAAA;EAAA,SACA,YAAA;AAAA;;;;;;KAQC,gBAAA;EAAA,SACD,IAAA;EAAA,SACA,YAAA,WAVA;EAAA,SAYA,QAAA,GAAW,QAAA,CAAS,QAAA;EAAA,SACpB,KAAA,GAAQ,aAAA,CAAc,aAAA;EAAA,SACtB,GAAA;AAAA;;;;;;;;;;;;;;;KAiBC,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.map

@@ -1 +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"}
+{"version":3,"file":"Transcript.mjs","names":[],"sources":["../../src/domain/Transcript.ts"],"sourcesContent":["import type { Duration } from \"effect\"\n\n/**\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 *\n * `startSeconds` / `endSeconds` stay raw `number` offsets (not `Duration`)\n * — they're positions in the audio, not durations.\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  /** Total audio duration. (Word offsets stay raw seconds on `WordTimestamp`.) */\n  readonly duration?: Duration.Duration\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":";;;;;;;;;;;AAuEA,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,5 +1,5 @@
 import { i as ImageSource } from "../Image-HNmMpMTh.mjs";
-import { d as Message, m as Reasoning, o as HistoryItem, v as ToolCall, x as Usage, y as ToolCallOutput } from "../Items-pXR5BAgW.mjs";
+import { d as Message, m as Reasoning, o as HistoryItem, v as ToolCall, x as Usage, y as ToolCallOutput } from "../Items-D8UaXQx_.mjs";
 import { i as StructuredFormat, n as JsonParseError, r as StructuredDecodeError } from "../StructuredFormat-BbN4dosH.mjs";
 import { Data, Effect, Schema, Stream } from "effect";
 import * as _$effect_Types0 from "effect/Types";

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

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

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

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

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

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

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

@@ -1,33 +1,33 @@
 import { t as AiError } from "../AiError-CAX_48RU.mjs";
-import { EmbedInput, EmbeddingFor, Usage } from "./Embedding.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, embed, embedMany };
+  export { CommonEmbedManyRequest, CommonEmbedRequest, EmbedEncoding, EmbedManyResponse, EmbedResponse, EmbeddingModel, EmbeddingModelService, assertEncoding, embed, embedMany };
 }
 /**
- * Output representation requested from the provider.
+ * Output representation requested from the provider. Cross-provider dense
+ * quantization only, the same vector at different storage cost:
+ * - `float32`: universal default.
+ * - `int8`: ~4x smaller, minimal recall loss on most benchmarks. Supported
+ *   by Cohere, Voyage, Jina (binary only), Mixedbread.
+ * - `binary`: ~32x smaller, meaningful recall loss but pairs well with a
+ *   float32 reranker pass over a small candidate set.
  *
- * 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`, `multivector`) are a different vector
+ * *structure*, not a storage option, and are produced by Jina only. They
+ * live on `JinaEncoding`, not here (the same widening pattern `task` uses).
+ * The response `Embedding` union still carries all arms, see
+ * {@link ResponseEncoding}.
  *
- * 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. `JinaEmbedEncoding = "float32" | "binary" | "sparse" |
- * "multivector"`). On the generic `EmbeddingModel` path, callers can
- * pass any `EmbedEncoding` and the provider's API will reject mismatches at
- * runtime.
+ * Each provider's typed request narrows this to its supported set. On the
+ * generic `EmbeddingModel` path, a provider that emits float32 only (OpenAI,
+ * Gemini) rejects a non-float32 encoding with `AiError.Unsupported`
+ * (bucket 1) via {@link assertEncoding}, rather than silently returning a
+ * mislabeled float32 vector.
  */
-type EmbedEncoding = "float32" | "int8" | "binary" | "sparse" | "multivector";
+type EmbedEncoding = "float32" | "int8" | "binary";
 /**
  * Cross-provider single-embed request. Mirrors the shape of
  * `LanguageModel.CommonRequest`: cross-cutting fields here, vendor
@@ -81,12 +81,12 @@ type CommonEmbedManyRequest = Omit<CommonEmbedRequest, "input"> & {
  * narrowing. Defaults to `undefined` for back-compat with consumers that
  * use the bare `EmbedResponse` name.
  */
-type EmbedResponse<E extends EmbedEncoding | undefined = undefined> = {
+type EmbedResponse<E extends ResponseEncoding | undefined = undefined> = {
   readonly embedding: EmbeddingFor<E>;
   readonly usage: Usage;
 };
 /** Batch-embed response. Same encoding rule as {@link EmbedResponse}. */
-type EmbedManyResponse<E extends EmbedEncoding | undefined = undefined> = {
+type EmbedManyResponse<E extends ResponseEncoding | undefined = undefined> = {
   readonly embeddings: ReadonlyArray<EmbeddingFor<E>>;
   readonly usage: Usage;
 };
@@ -108,6 +108,19 @@ declare const embed: <E extends EmbedEncoding | undefined = undefined>(request:
 declare const embedMany: <E extends EmbedEncoding | undefined = undefined>(request: Omit<CommonEmbedManyRequest, "encoding"> & {
   readonly encoding?: E;
 }) => Effect.Effect<EmbedManyResponse<E>, AiError, EmbeddingModel>;
+/**
+ * Guard a requested `encoding` against a provider's supported set. Returns
+ * `void` when the encoding is unset or supported, and fails
+ * `AiError.Unsupported` (bucket 1) otherwise.
+ *
+ * Used by the generic-tag registration of providers that emit a strict
+ * subset of `EmbedEncoding`: OpenAI / Gemini pass `["float32"]`, Jina passes
+ * `["float32", "binary"]`. Without this guard, a non-supported encoding on
+ * the generic path silently returns a float32 vector mislabeled as the
+ * requested type (the `as`-cast lie), which breaks downstream storage and
+ * vector math.
+ */
+declare const assertEncoding: (encoding: EmbedEncoding | undefined, supported: ReadonlyArray<EmbedEncoding>, provider: string) => Effect.Effect<void, AiError>;
 //#endregion
-export { CommonEmbedManyRequest, CommonEmbedRequest, EmbedEncoding, EmbedManyResponse, EmbedResponse, EmbeddingModel, EmbeddingModelService, embed, embedMany, EmbeddingModel_d_exports as t };
+export { CommonEmbedManyRequest, CommonEmbedRequest, EmbedEncoding, EmbedManyResponse, EmbedResponse, EmbeddingModel, EmbeddingModelService, assertEncoding, embed, embedMany, EmbeddingModel_d_exports as t };
 //# sourceMappingURL=EmbeddingModel.d.mts.map

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;;;;;WAKP,KAAA;EA6BqB;;;;;;;EAAA,SArBrB,IAAA;EAqBgC;AAU3C;;;;EAV2C,SAfhC,UAAA;EA0BW;;;;;EAAA,SApBX,QAAA,GAAW,aAAA;AAAA;;;;;;KAQV,sBAAA,GAAyB,IAAA,CAAK,kBAAA;EAAA,SAC/B,MAAA,EAAQ,aAAA,CAAc,UAAA;AAAA;;;;;;;;KAUrB,aAAA,WAAwB,aAAA;EAAA,SACzB,SAAA,EAAW,YAAA,CAAa,CAAA;EAAA,SACxB,KAAA,EAAO,KAAA;AAAA;;KAIN,iBAAA,WAA4B,aAAA;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"}
+{"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"}

package/dist/embedding-model/EmbeddingModel.mjs

@@ -1,8 +1,10 @@
 import { n as __exportAll } from "../chunk-uyGKjUfl.mjs";
+import { Unsupported } from "../domain/AiError.mjs";
 import { Context, Effect } from "effect";
 //#region src/embedding-model/EmbeddingModel.ts
 var EmbeddingModel_exports = /* @__PURE__ */ __exportAll({
 	EmbeddingModel: () => EmbeddingModel,
+	assertEncoding: () => assertEncoding,
 	embed: () => embed,
 	embedMany: () => embedMany
 });
@@ -11,7 +13,24 @@ var EmbeddingModel = class extends Context.Service()("@betalyra/effect-uai/Embed
 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));
+/**
+* Guard a requested `encoding` against a provider's supported set. Returns
+* `void` when the encoding is unset or supported, and fails
+* `AiError.Unsupported` (bucket 1) otherwise.
+*
+* Used by the generic-tag registration of providers that emit a strict
+* subset of `EmbedEncoding`: OpenAI / Gemini pass `["float32"]`, Jina passes
+* `["float32", "binary"]`. Without this guard, a non-supported encoding on
+* the generic path silently returns a float32 vector mislabeled as the
+* requested type (the `as`-cast lie), which breaks downstream storage and
+* vector math.
+*/
+const assertEncoding = (encoding, supported, provider) => encoding === void 0 || supported.includes(encoding) ? Effect.void : Effect.fail(new Unsupported({
+	provider,
+	capability: "encoding",
+	reason: `${provider} emits ${supported.join(" / ")} only; encoding="${encoding}" is unavailable.`
+}));
 //#endregion
-export { EmbeddingModel, embed, embedMany, EmbeddingModel_exports as t };
+export { EmbeddingModel, assertEncoding, embed, embedMany, EmbeddingModel_exports as t };
 
 //# sourceMappingURL=EmbeddingModel.mjs.map

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

@@ -1 +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 { EmbeddingFor, 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. `JinaEmbedEncoding = \"float32\" | \"binary\" | \"sparse\" |\n * \"multivector\"`). On the generic `EmbeddingModel` path, callers can\n * pass any `EmbedEncoding` and the provider's API will reject mismatches at\n * runtime.\n */\nexport type EmbedEncoding = \"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 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 EmbedEncoding | 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 EmbedEncoding | 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.asEffect(), (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.asEffect(), (m) => m.embedMany(request))\n"],"mappings":";;;;;;;;AAsGA,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"}
+{"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.asEffect(), (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.asEffect(), (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,eAAe,UAAU,GAAG,MAAM,EAAE,MAAM,QAAQ,CAAC;;AAGpE,MAAa,aACX,YAEA,OAAO,QAAQ,eAAe,UAAU,GAAG,MAAM,EAAE,UAAU,QAAQ,CAAC;;;;;;;;;;;;;AAcxE,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"}

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

@@ -5,7 +5,7 @@ describe("EmbedResponse<E> conditional narrowing", () => {
 	it("defaults to Float32Embedding when E is undefined", () => {
 		(0, import_dist.expectTypeOf)().toEqualTypeOf();
 	});
-	it("maps each EmbedEncoding literal to the matching Embedding variant", () => {
+	it("maps each encoding literal to the matching Embedding variant", () => {
 		(0, import_dist.expectTypeOf)().toEqualTypeOf();
 		(0, import_dist.expectTypeOf)().toEqualTypeOf();
 		(0, import_dist.expectTypeOf)().toEqualTypeOf();
@@ -38,13 +38,25 @@ describe("embed / embedMany free exports preserve E in their return type", () =>
 			encoding: "int8"
 		})).toEqualTypeOf();
 	});
-	it("embedMany with encoding: multivector returns EmbedManyResponse<multivector>", () => {
+	it("embedMany with encoding: binary returns EmbedManyResponse<binary>", () => {
 		(0, import_dist.expectTypeOf)(embedMany({
 			inputs: ["x"],
 			model: "m",
-			encoding: "multivector"
+			encoding: "binary"
 		})).toEqualTypeOf();
 	});
+	it("rejects non-dense encodings on the generic path (trimmed EmbedEncoding)", () => {
+		embedMany({
+			inputs: ["x"],
+			model: "m",
+			encoding: "multivector"
+		});
+		embed({
+			input: "x",
+			model: "m",
+			encoding: "sparse"
+		});
+	});
 	it("when the request is widened to CommonEmbedRequest, the response is the open union", () => {
 		(0, import_dist.expectTypeOf)(embed({
 			input: "x",

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 EmbedEncoding 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: multivector returns EmbedManyResponse<multivector>\", () => {\n    const result = embedMany({ inputs: [\"x\"], model: \"m\", encoding: \"multivector\" })\n    expectTypeOf(result).toEqualTypeOf<\n      Effect.Effect<EmbedManyResponse<\"multivector\">, AiError.AiError, EmbeddingModel>\n    >()\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,2EAA2E;AAC5E,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,qFAAqF;AAEtF,GAAA,GAAA,YAAA,cADe,UAAU;GAAE,QAAQ,CAAC,IAAI;GAAE,OAAO;GAAK,UAAU;GAAe,CAC5D,CAAC,CAAC,eAElB;GACH;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    // @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  })\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;AAMlF,YAAU;GAAE,QAAQ,CAAC,IAAI;GAAE,OAAO;GAAK,UAAU;GAAe,CAAC;AAEjE,QAAM;GAAE,OAAO;GAAK,OAAO;GAAK,UAAU;GAAU,CAAC;GACrD;AAEF,IAAG,2FAA2F;AAS5F,GAAA,GAAA,YAAA,cADe,MAAM;GAJnB,OAAO;GACP,OAAO;GACP,UAAU;GAEY,CACL,CAAC,CAAC,eAElB;GACH;EACF"}

package/dist/index.d.mts

@@ -1,15 +1,16 @@
+import { t as Capabilities_d_exports } from "./capabilities/Capabilities.mjs";
 import { n as AiError_d_exports } from "./AiError-CAX_48RU.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 Audio_d_exports } from "./Audio-DPlTsNdz.mjs";
 import { o as Image_d_exports } from "./Image-HNmMpMTh.mjs";
-import { u as Items_d_exports } from "./Items-pXR5BAgW.mjs";
+import { u as Items_d_exports } from "./Items-D8UaXQx_.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-BbN4dosH.mjs";
 import { t as Turn_d_exports } from "./domain/Turn.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-DP-AwKOf.mjs";
+import { l as Tool_d_exports } from "./Tool-CiFXYjmR.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";
@@ -31,4 +32,4 @@ 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, Approval_d_exports as Approval, 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, Memory_d_exports as Memory, Metrics_d_exports as Metrics, Music_d_exports as Music, MusicGenerator_d_exports as MusicGenerator, Retry_d_exports as Retry, SSE_d_exports as SSE, Sandbox_d_exports as Sandbox, SandboxError_d_exports as SandboxError, SandboxImage_d_exports as SandboxImage, SandboxNetwork_d_exports as SandboxNetwork, SpeechSynthesizer_d_exports as SpeechSynthesizer, StructuredFormat_d_exports as StructuredFormat, Tool_d_exports as Tool, ToolEvent_d_exports as ToolEvent, ToolResult_d_exports as ToolResult, 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 };
+export { AiError_d_exports as AiError, Approval_d_exports as Approval, Audio_d_exports as Audio, Capabilities_d_exports as Capabilities, 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, Memory_d_exports as Memory, Metrics_d_exports as Metrics, Music_d_exports as Music, MusicGenerator_d_exports as MusicGenerator, Retry_d_exports as Retry, SSE_d_exports as SSE, Sandbox_d_exports as Sandbox, SandboxError_d_exports as SandboxError, SandboxImage_d_exports as SandboxImage, SandboxNetwork_d_exports as SandboxNetwork, SpeechSynthesizer_d_exports as SpeechSynthesizer, StructuredFormat_d_exports as StructuredFormat, Tool_d_exports as Tool, ToolEvent_d_exports as ToolEvent, ToolResult_d_exports as ToolResult, 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,5 +1,6 @@
 import { t as AiError_exports } from "./domain/AiError.mjs";
 import { t as Audio_exports } from "./domain/Audio.mjs";
+import { t as Capabilities_exports } from "./capabilities/Capabilities.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";
@@ -31,4 +32,4 @@ 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, Approval_exports as Approval, 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, Memory_exports as Memory, Metrics_exports as Metrics, Music_exports as Music, MusicGenerator_exports as MusicGenerator, Retry_exports as Retry, SSE_exports as SSE, Sandbox_exports as Sandbox, SandboxError_exports as SandboxError, SandboxImage_exports as SandboxImage, SandboxNetwork_exports as SandboxNetwork, SpeechSynthesizer_exports as SpeechSynthesizer, StructuredFormat_exports as StructuredFormat, Tool_exports as Tool, ToolEvent_exports as ToolEvent, ToolResult_exports as ToolResult, Toolkit_exports as Toolkit, Transcriber_exports as Transcriber, Transcript_exports as Transcript, Turn_exports as Turn, Vector_exports as Vector };
+export { AiError_exports as AiError, Approval_exports as Approval, Audio_exports as Audio, Capabilities_exports as Capabilities, 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, Memory_exports as Memory, Metrics_exports as Metrics, Music_exports as Music, MusicGenerator_exports as MusicGenerator, Retry_exports as Retry, SSE_exports as SSE, Sandbox_exports as Sandbox, SandboxError_exports as SandboxError, SandboxImage_exports as SandboxImage, SandboxNetwork_exports as SandboxNetwork, SpeechSynthesizer_exports as SpeechSynthesizer, StructuredFormat_exports as StructuredFormat, Tool_exports as Tool, ToolEvent_exports as ToolEvent, ToolResult_exports as ToolResult, 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,8 +1,8 @@
 import { t as AiError } from "../AiError-CAX_48RU.mjs";
-import { o as HistoryItem } from "../Items-pXR5BAgW.mjs";
+import { o as HistoryItem } from "../Items-D8UaXQx_.mjs";
 import { i as StructuredFormat } from "../StructuredFormat-BbN4dosH.mjs";
 import { Turn, TurnEvent } from "../domain/Turn.mjs";
-import { o as ToolDescriptor } from "../Tool-DP-AwKOf.mjs";
+import { o as ToolDescriptor } from "../Tool-CiFXYjmR.mjs";
 import { Context, Effect, Stream } from "effect";
 
 //#region src/language-model/LanguageModel.d.ts