@effect-uai/mistral 0.8.0

package/dist/MistralTranscriber.mjs

@@ -0,0 +1,111 @@
+import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
+import { httpStatusError, transportFailure } from "./http.mjs";
+import { audioToBlob, defaultFileName } from "./audioCodec.mjs";
+import { Array, Context, Effect, Layer, Schema, Stream } from "effect";
+import { HttpClient, HttpClientRequest } from "effect/unstable/http";
+import * as AiError from "@effect-uai/core/AiError";
+import { Transcriber } from "@effect-uai/core/Transcriber";
+import * as Capabilities from "@effect-uai/core/Capabilities";
+import { isAudioUrl } from "@effect-uai/core/Audio";
+//#region src/MistralTranscriber.ts
+var MistralTranscriber_exports = /* @__PURE__ */ __exportAll({
+	MistralTranscriber: () => MistralTranscriber,
+	layer: () => layer,
+	make: () => make,
+	transcribeImpl: () => transcribeImpl
+});
+var MistralTranscriber = class extends Context.Service()("@betalyra/effect-uai/providers/mistral/MistralTranscriber") {};
+const when = (condition, part) => condition ? [part] : [];
+const appendPart = (fd, part) => {
+	if (part.length === 3) fd.append(part[0], part[1], part[2]);
+	else fd.append(part[0], part[1]);
+	return fd;
+};
+const buildFormData = (request) => Effect.gen(function* () {
+	yield* Capabilities.warnDroppedWhen(request.prompt, {
+		provider: "mistral",
+		capability: "prompt",
+		field: "prompt",
+		reason: "Voxtral transcription has no prose prompt field; use `biasingTerms` for vocabulary hints."
+	});
+	const parts = [
+		isAudioUrl(request.audio) ? ["file_url", request.audio.url] : yield* audioToBlob(request.audio).pipe(Effect.map((blob) => [
+			"file",
+			blob,
+			request.fileName ?? defaultFileName(blob.type)
+		])),
+		["model", request.model],
+		...when(request.language !== void 0, ["language", request.language ?? ""]),
+		...when(request.diarization === true, ["diarize", "true"]),
+		...when(request.wordTimestamps === true, ["timestamp_granularities[]", "word"]),
+		...when(request.temperature !== void 0, ["temperature", String(request.temperature)]),
+		...(request.biasingTerms ?? []).map((term) => ["context_bias", term])
+	];
+	return Array.reduce(parts, new FormData(), appendPart);
+});
+const WireWord = Schema.Struct({
+	text: Schema.optional(Schema.String),
+	word: Schema.optional(Schema.String),
+	start: Schema.Number,
+	end: Schema.Number,
+	speaker: Schema.optional(Schema.NullOr(Schema.String))
+});
+const WireResponse = Schema.Struct({
+	text: Schema.String,
+	language: Schema.optional(Schema.NullOr(Schema.String)),
+	words: Schema.optional(Schema.NullOr(Schema.Array(WireWord)))
+});
+const decodeResponse = Schema.decodeUnknownEffect(WireResponse);
+const wireWordToCommon = (w) => ({
+	text: w.text ?? w.word ?? "",
+	startSeconds: w.start,
+	endSeconds: w.end,
+	...w.speaker != null && { speakerId: w.speaker }
+});
+const toResult = (raw, decoded) => ({
+	text: decoded.text,
+	...decoded.language != null && { languageCode: decoded.language },
+	...decoded.words != null && { words: decoded.words.map(wireWordToCommon) },
+	raw
+});
+/** Exported for reuse by `MistralRealtimeTranscriber` (same sync path). */
+const transcribeImpl = (cfg) => (request) => Effect.gen(function* () {
+	const client = yield* HttpClient.HttpClient;
+	const baseUrl = cfg.baseUrl ?? "https://api.mistral.ai";
+	const formData = yield* buildFormData(request);
+	const httpRequest = HttpClientRequest.post(`${baseUrl}/v1/audio/transcriptions`).pipe(HttpClientRequest.bearerToken(cfg.apiKey), HttpClientRequest.bodyFormData(formData));
+	const response = yield* client.execute(httpRequest).pipe(Effect.mapError(transportFailure));
+	if (response.status >= 400) {
+		const text = yield* response.text.pipe(Effect.orElseSucceed(() => ""));
+		return yield* Effect.fail(httpStatusError(response.status, text));
+	}
+	const json = yield* response.json.pipe(Effect.mapError(transportFailure));
+	return toResult(json, yield* decodeResponse(json).pipe(Effect.mapError(transportFailure)));
+});
+/**
+* Sync-only Layer's streaming impl. For live transcription import the
+* `MistralRealtimeTranscriber` subpath, which registers `SttStreaming` and
+* wires the Voxtral Realtime WebSocket endpoint.
+*/
+const streamUnsupported = (_audioIn, _request) => Stream.fail(new AiError.Unsupported({
+	provider: "mistral",
+	capability: "streamTranscriptionFrom",
+	reason: "This Layer is sync-only. Use `@effect-uai/mistral/MistralRealtimeTranscriber` for live Voxtral transcription."
+}));
+const make = (cfg) => Effect.map(HttpClient.HttpClient.asEffect(), (client) => ({
+	transcribe: (request) => transcribeImpl(cfg)(request).pipe(Effect.provideService(HttpClient.HttpClient, client)),
+	streamTranscriptionFrom: streamUnsupported
+}));
+/**
+* Sync-only Layer. Registers `MistralTranscriber` + the generic `Transcriber`
+* tag. Does NOT register `SttStreaming` — for live transcription use
+* `@effect-uai/mistral/MistralRealtimeTranscriber`.
+*/
+const layer = (cfg) => Layer.merge(Layer.effect(MistralTranscriber, make(cfg)), Layer.effect(Transcriber, Effect.map(make(cfg), (s) => ({
+	transcribe: (req) => s.transcribe(req),
+	streamTranscriptionFrom: s.streamTranscriptionFrom
+}))));
+//#endregion
+export { MistralTranscriber, layer, make, MistralTranscriber_exports as t, transcribeImpl };
+
+//# sourceMappingURL=MistralTranscriber.mjs.map

package/dist/MistralTranscriber.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MistralTranscriber.mjs","names":["Arr"],"sources":["../src/MistralTranscriber.ts"],"sourcesContent":["import { Array as Arr, Context, Effect, Layer, Redacted, Schema, Stream } from \"effect\"\nimport { HttpClient, HttpClientRequest } from \"effect/unstable/http\"\nimport * as AiError from \"@effect-uai/core/AiError\"\nimport * as Capabilities from \"@effect-uai/core/Capabilities\"\nimport { isAudioUrl } from \"@effect-uai/core/Audio\"\nimport type { TranscriptEvent, TranscriptResult, WordTimestamp } from \"@effect-uai/core/Transcript\"\nimport {\n  type CommonStreamTranscribeRequest,\n  type CommonTranscribeRequest,\n  Transcriber,\n  type TranscriberService,\n} from \"@effect-uai/core/Transcriber\"\nimport { audioToBlob, defaultFileName } from \"./audioCodec.js\"\nimport { httpStatusError, transportFailure } from \"./http.js\"\nimport type { MistralTranscribeModel } from \"./models.js\"\n\n// ---------------------------------------------------------------------------\n// Public types\n// ---------------------------------------------------------------------------\n\n/**\n * Mistral-typed transcribe request. `model` narrows to the typed\n * `MistralTranscribeModel` union; `fileName` overrides the multipart upload's\n * filename. Voxtral's batch endpoint supports diarization, word timestamps,\n * and context biasing.\n */\nexport type MistralTranscribeRequest = Omit<CommonTranscribeRequest, \"model\"> & {\n  readonly model: MistralTranscribeModel\n  readonly temperature?: number\n  readonly fileName?: string\n}\n\nexport type MistralTranscriberService = {\n  readonly transcribe: (\n    request: MistralTranscribeRequest,\n  ) => Effect.Effect<TranscriptResult, AiError.AiError>\n  readonly streamTranscriptionFrom: <E, R>(\n    audioIn: Stream.Stream<Uint8Array, E, R>,\n    request: CommonStreamTranscribeRequest,\n  ) => Stream.Stream<TranscriptEvent, AiError.AiError | E, R>\n}\n\nexport class MistralTranscriber extends Context.Service<\n  MistralTranscriber,\n  MistralTranscriberService\n>()(\"@betalyra/effect-uai/providers/mistral/MistralTranscriber\") {}\n\nexport type Config = {\n  readonly apiKey: Redacted.Redacted\n  readonly baseUrl?: string\n}\n\n// ---------------------------------------------------------------------------\n// Codec — request → FormData\n//\n// Each field is described as a data `Part`, then the whole list is folded into\n// one FormData. A `Part` is either a scalar field or a file field (with an\n// upload filename).\n// ---------------------------------------------------------------------------\n\ntype Part =\n  | readonly [name: string, value: string]\n  | readonly [name: string, file: Blob, filename: string]\n\nconst when = (condition: boolean, part: Part): ReadonlyArray<Part> => (condition ? [part] : [])\n\nconst appendPart = (fd: FormData, part: Part): FormData => {\n  if (part.length === 3) fd.append(part[0], part[1], part[2])\n  else fd.append(part[0], part[1])\n  return fd\n}\n\nconst buildFormData = (\n  request: MistralTranscribeRequest,\n): Effect.Effect<FormData, AiError.AiError> =>\n  Effect.gen(function* () {\n    // Voxtral transcription has no Whisper-style prose `prompt` field.\n    yield* Capabilities.warnDroppedWhen(request.prompt, {\n      provider: \"mistral\",\n      capability: \"prompt\",\n      field: \"prompt\",\n      reason:\n        \"Voxtral transcription has no prose prompt field; use `biasingTerms` for vocabulary hints.\",\n    })\n    // URL audio rides the `file_url` field; inline bytes/base64 upload directly.\n    const filePart: Part = isAudioUrl(request.audio)\n      ? [\"file_url\", request.audio.url]\n      : yield* audioToBlob(request.audio).pipe(\n          Effect.map(\n            (blob): Part => [\"file\", blob, request.fileName ?? defaultFileName(blob.type)],\n          ),\n        )\n    const parts: ReadonlyArray<Part> = [\n      filePart,\n      [\"model\", request.model],\n      ...when(request.language !== undefined, [\"language\", request.language ?? \"\"]),\n      ...when(request.diarization === true, [\"diarize\", \"true\"]),\n      ...when(request.wordTimestamps === true, [\"timestamp_granularities[]\", \"word\"]),\n      ...when(request.temperature !== undefined, [\"temperature\", String(request.temperature)]),\n      // Voxtral biases on a `context_bias` term list; one entry per term.\n      ...(request.biasingTerms ?? []).map((term): Part => [\"context_bias\", term]),\n    ]\n    return Arr.reduce(parts, new FormData(), appendPart)\n  })\n\n// ---------------------------------------------------------------------------\n// Codec — response → TranscriptResult\n// ---------------------------------------------------------------------------\n\nconst WireWord = Schema.Struct({\n  text: Schema.optional(Schema.String),\n  word: Schema.optional(Schema.String),\n  start: Schema.Number,\n  end: Schema.Number,\n  speaker: Schema.optional(Schema.NullOr(Schema.String)),\n})\n\nconst WireResponse = Schema.Struct({\n  text: Schema.String,\n  language: Schema.optional(Schema.NullOr(Schema.String)),\n  words: Schema.optional(Schema.NullOr(Schema.Array(WireWord))),\n})\n\nconst decodeResponse = Schema.decodeUnknownEffect(WireResponse)\n\nconst wireWordToCommon = (w: typeof WireWord.Type): WordTimestamp => ({\n  text: w.text ?? w.word ?? \"\",\n  startSeconds: w.start,\n  endSeconds: w.end,\n  ...(w.speaker != null && { speakerId: w.speaker }),\n})\n\nconst toResult = (raw: unknown, decoded: typeof WireResponse.Type): TranscriptResult => ({\n  text: decoded.text,\n  ...(decoded.language != null && { languageCode: decoded.language }),\n  ...(decoded.words != null && { words: decoded.words.map(wireWordToCommon) }),\n  raw,\n})\n\n// ---------------------------------------------------------------------------\n// HTTP plumbing\n// ---------------------------------------------------------------------------\n\n/** Exported for reuse by `MistralRealtimeTranscriber` (same sync path). */\nexport const transcribeImpl =\n  (cfg: Config) =>\n  (\n    request: MistralTranscribeRequest,\n  ): Effect.Effect<TranscriptResult, AiError.AiError, HttpClient.HttpClient> =>\n    Effect.gen(function* () {\n      const client = yield* HttpClient.HttpClient\n      const baseUrl = cfg.baseUrl ?? \"https://api.mistral.ai\"\n      const formData = yield* buildFormData(request)\n      const httpRequest = HttpClientRequest.post(`${baseUrl}/v1/audio/transcriptions`).pipe(\n        HttpClientRequest.bearerToken(cfg.apiKey),\n        HttpClientRequest.bodyFormData(formData),\n      )\n      const response = yield* client.execute(httpRequest).pipe(Effect.mapError(transportFailure))\n      if (response.status >= 400) {\n        const text = yield* response.text.pipe(Effect.orElseSucceed(() => \"\"))\n        return yield* Effect.fail(httpStatusError(response.status, text))\n      }\n      const json = yield* response.json.pipe(Effect.mapError(transportFailure))\n      const decoded = yield* decodeResponse(json).pipe(Effect.mapError(transportFailure))\n      return toResult(json, decoded)\n    })\n\n// ---------------------------------------------------------------------------\n// streamTranscriptionFrom — Unsupported on the sync-only Layer\n// ---------------------------------------------------------------------------\n\n/**\n * Sync-only Layer's streaming impl. For live transcription import the\n * `MistralRealtimeTranscriber` subpath, which registers `SttStreaming` and\n * wires the Voxtral Realtime WebSocket endpoint.\n */\nconst streamUnsupported = <E, R>(\n  _audioIn: Stream.Stream<Uint8Array, E, R>,\n  _request: CommonStreamTranscribeRequest,\n): Stream.Stream<TranscriptEvent, AiError.AiError | E, R> =>\n  Stream.fail(\n    new AiError.Unsupported({\n      provider: \"mistral\",\n      capability: \"streamTranscriptionFrom\",\n      reason:\n        \"This Layer is sync-only. Use `@effect-uai/mistral/MistralRealtimeTranscriber` for live Voxtral transcription.\",\n    }),\n  )\n\n// ---------------------------------------------------------------------------\n// Constructors\n// ---------------------------------------------------------------------------\n\nexport const make = (\n  cfg: Config,\n): Effect.Effect<MistralTranscriberService, never, HttpClient.HttpClient> =>\n  Effect.map(HttpClient.HttpClient.asEffect(), (client) => ({\n    transcribe: (request) =>\n      transcribeImpl(cfg)(request).pipe(Effect.provideService(HttpClient.HttpClient, client)),\n    streamTranscriptionFrom: streamUnsupported,\n  }))\n\n/**\n * Sync-only Layer. Registers `MistralTranscriber` + the generic `Transcriber`\n * tag. Does NOT register `SttStreaming` — for live transcription use\n * `@effect-uai/mistral/MistralRealtimeTranscriber`.\n */\nexport const layer = (\n  cfg: Config,\n): Layer.Layer<MistralTranscriber | Transcriber, never, HttpClient.HttpClient> =>\n  Layer.merge(\n    Layer.effect(MistralTranscriber, make(cfg)),\n    Layer.effect(\n      Transcriber,\n      Effect.map(\n        make(cfg),\n        (s): TranscriberService => ({\n          transcribe: (req: CommonTranscribeRequest) =>\n            s.transcribe(req as MistralTranscribeRequest),\n          streamTranscriptionFrom: s.streamTranscriptionFrom,\n        }),\n      ),\n    ),\n  )\n"],"mappings":"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"}

package/dist/audioCodec.d.mts

@@ -0,0 +1,27 @@
+import { Effect } from "effect";
+import * as AiError from "@effect-uai/core/AiError";
+import { AudioFormat, AudioSource } from "@effect-uai/core/Audio";
+
+//#region src/audioCodec.d.ts
+/**
+ * Build a `Blob` from any `AudioSource` variant. `url` variants pass through
+ * to the `file_url` field upstream, so this only handles inline bytes/base64.
+ */
+declare const audioToBlob: (audio: AudioSource) => Effect.Effect<Blob, AiError.AiError>;
+/** Derive a default upload filename from a MIME type, e.g. `audio/mpeg` -> `audio.mp3`. */
+declare const defaultFileName: (mimeType: string) => string;
+type MistralTtsFormat = "mp3" | "wav" | "pcm" | "flac" | "opus";
+/**
+ * Map an `AudioFormat.container` to Voxtral TTS's `response_format`. Voxtral
+ * produces mp3 / wav / pcm / flac / opus; aac / ogg / webm are unsupported.
+ */
+declare const containerToTtsFormat: (container: AudioFormat["container"]) => Effect.Effect<MistralTtsFormat, AiError.AiError>;
+/**
+ * The on-wire `AudioFormat` Voxtral actually returns for each
+ * `response_format`. Voxtral's `pcm` is float32 LE at 24 kHz; the caller's
+ * requested sample rate is not honoured for raw output.
+ */
+declare const realizedTtsFormat: (rf: MistralTtsFormat) => AudioFormat;
+//#endregion
+export { MistralTtsFormat, audioToBlob, containerToTtsFormat, defaultFileName, realizedTtsFormat };
+//# sourceMappingURL=audioCodec.d.mts.map

package/dist/audioCodec.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audioCodec.d.mts","names":[],"sources":["../src/audioCodec.ts"],"mappings":";;;;;;;AA2BA;;cAAa,WAAA,GAAc,KAAA,EAAO,WAAA,KAAgB,MAAA,CAAO,MAAA,CAAO,IAAA,EAAM,OAAA,CAAQ,OAAA;;cAgCjE,eAAA,GAAmB,QAAA;AAAA,KASpB,gBAAA;;;;;cAMC,oBAAA,GACX,SAAA,EAAW,WAAA,kBACR,MAAA,CAAO,MAAA,CAAO,gBAAA,EAAkB,OAAA,CAAQ,OAAA;;;;;;cAuBhC,iBAAA,GAAoB,EAAA,EAAI,gBAAA,KAAqB,WAAA"}

package/dist/audioCodec.mjs

@@ -0,0 +1,82 @@
+import { Array, Effect, Encoding, Match, Option, Result } from "effect";
+import * as AiError from "@effect-uai/core/AiError";
+//#region src/audioCodec.ts
+const decodeBase64ToBytes = (b64) => Result.match(Encoding.decodeBase64(b64), {
+	onSuccess: Effect.succeed,
+	onFailure: (cause) => Effect.fail(new AiError.InvalidRequest({
+		provider: "mistral",
+		param: "audio",
+		raw: cause
+	}))
+});
+/**
+* TS 6's `Blob` constructor wants `Uint8Array<ArrayBuffer>`; our domain carries
+* the broader `Uint8Array<ArrayBufferLike>`. The cast is sound: `Blob()` does
+* not mutate the buffer and the runtime accepts both.
+*/
+const bytesToBlob = (bytes, mimeType) => new Blob([bytes], { type: mimeType });
+/**
+* Build a `Blob` from any `AudioSource` variant. `url` variants pass through
+* to the `file_url` field upstream, so this only handles inline bytes/base64.
+*/
+const audioToBlob = Match.type().pipe(Match.tag("bytes", (a) => Effect.succeed(bytesToBlob(a.bytes, a.mimeType))), Match.tag("base64", (a) => decodeBase64ToBytes(a.base64).pipe(Effect.map((bytes) => bytesToBlob(bytes, a.mimeType)))), Match.tag("url", (a) => Effect.fail(new AiError.InvalidRequest({
+	provider: "mistral",
+	param: "audio",
+	raw: `Pass URL audio via the request's url source; got ${a.url} where inline bytes were expected.`
+}))), Match.exhaustive);
+const EXTENSION_BY_MIME = [
+	["mpeg", "mp3"],
+	["mp3", "mp3"],
+	["wav", "wav"],
+	["ogg", "ogg"],
+	["opus", "ogg"],
+	["flac", "flac"],
+	["aac", "aac"],
+	["mp4", "m4a"],
+	["m4a", "m4a"],
+	["webm", "webm"]
+];
+/** Derive a default upload filename from a MIME type, e.g. `audio/mpeg` -> `audio.mp3`. */
+const defaultFileName = (mimeType) => Array.findFirst(EXTENSION_BY_MIME, ([pattern]) => mimeType.includes(pattern)).pipe(Option.match({
+	onNone: () => "audio",
+	onSome: ([, ext]) => `audio.${ext}`
+}));
+/**
+* Map an `AudioFormat.container` to Voxtral TTS's `response_format`. Voxtral
+* produces mp3 / wav / pcm / flac / opus; aac / ogg / webm are unsupported.
+*/
+const containerToTtsFormat = Match.type().pipe(Match.when("mp3", () => Effect.succeed("mp3")), Match.when("wav", () => Effect.succeed("wav")), Match.when("raw", () => Effect.succeed("pcm")), Match.when("flac", () => Effect.succeed("flac")), Match.when("opus", () => Effect.succeed("opus")), Match.whenOr("aac", "ogg", "webm", (c) => Effect.fail(new AiError.Unsupported({
+	provider: "mistral",
+	capability: "outputFormat",
+	reason: `Voxtral TTS does not produce ${c} output; supported: mp3 | wav | pcm (raw) | flac | opus.`
+}))), Match.exhaustive);
+/**
+* The on-wire `AudioFormat` Voxtral actually returns for each
+* `response_format`. Voxtral's `pcm` is float32 LE at 24 kHz; the caller's
+* requested sample rate is not honoured for raw output.
+*/
+const realizedTtsFormat = Match.type().pipe(Match.when("mp3", () => ({
+	container: "mp3",
+	encoding: "mp3",
+	sampleRate: 24e3
+})), Match.when("wav", () => ({
+	container: "wav",
+	encoding: "pcm_s16le",
+	sampleRate: 24e3
+})), Match.when("pcm", () => ({
+	container: "raw",
+	encoding: "pcm_f32le",
+	sampleRate: 24e3
+})), Match.when("flac", () => ({
+	container: "flac",
+	encoding: "flac",
+	sampleRate: 24e3
+})), Match.when("opus", () => ({
+	container: "opus",
+	encoding: "opus",
+	sampleRate: 24e3
+})), Match.exhaustive);
+//#endregion
+export { audioToBlob, containerToTtsFormat, defaultFileName, realizedTtsFormat };
+
+//# sourceMappingURL=audioCodec.mjs.map

package/dist/audioCodec.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"audioCodec.mjs","names":["Arr"],"sources":["../src/audioCodec.ts"],"sourcesContent":["import { Array as Arr, Effect, Encoding, Match, Option, Result } from \"effect\"\nimport * as AiError from \"@effect-uai/core/AiError\"\nimport type { AudioFormat, AudioSource } from \"@effect-uai/core/Audio\"\n\n// ---------------------------------------------------------------------------\n// AudioSource → Blob (for multipart upload to /audio/transcriptions)\n// ---------------------------------------------------------------------------\n\nconst decodeBase64ToBytes = (b64: string): Effect.Effect<Uint8Array, AiError.AiError> =>\n  Result.match(Encoding.decodeBase64(b64), {\n    onSuccess: Effect.succeed,\n    onFailure: (cause) =>\n      Effect.fail(new AiError.InvalidRequest({ provider: \"mistral\", param: \"audio\", raw: cause })),\n  })\n\n/**\n * TS 6's `Blob` constructor wants `Uint8Array<ArrayBuffer>`; our domain carries\n * the broader `Uint8Array<ArrayBufferLike>`. The cast is sound: `Blob()` does\n * not mutate the buffer and the runtime accepts both.\n */\nconst bytesToBlob = (bytes: Uint8Array, mimeType: string): Blob =>\n  new Blob([bytes as Uint8Array<ArrayBuffer>], { type: mimeType })\n\n/**\n * Build a `Blob` from any `AudioSource` variant. `url` variants pass through\n * to the `file_url` field upstream, so this only handles inline bytes/base64.\n */\nexport const audioToBlob: (audio: AudioSource) => Effect.Effect<Blob, AiError.AiError> =\n  Match.type<AudioSource>().pipe(\n    Match.tag(\"bytes\", (a) => Effect.succeed(bytesToBlob(a.bytes, a.mimeType))),\n    Match.tag(\"base64\", (a) =>\n      decodeBase64ToBytes(a.base64).pipe(Effect.map((bytes) => bytesToBlob(bytes, a.mimeType))),\n    ),\n    Match.tag(\"url\", (a) =>\n      Effect.fail(\n        new AiError.InvalidRequest({\n          provider: \"mistral\",\n          param: \"audio\",\n          raw: `Pass URL audio via the request's url source; got ${a.url} where inline bytes were expected.`,\n        }),\n      ),\n    ),\n    Match.exhaustive,\n  )\n\nconst EXTENSION_BY_MIME: ReadonlyArray<readonly [pattern: string, ext: string]> = [\n  [\"mpeg\", \"mp3\"],\n  [\"mp3\", \"mp3\"],\n  [\"wav\", \"wav\"],\n  [\"ogg\", \"ogg\"],\n  [\"opus\", \"ogg\"],\n  [\"flac\", \"flac\"],\n  [\"aac\", \"aac\"],\n  [\"mp4\", \"m4a\"],\n  [\"m4a\", \"m4a\"],\n  [\"webm\", \"webm\"],\n]\n\n/** Derive a default upload filename from a MIME type, e.g. `audio/mpeg` -> `audio.mp3`. */\nexport const defaultFileName = (mimeType: string): string =>\n  Arr.findFirst(EXTENSION_BY_MIME, ([pattern]) => mimeType.includes(pattern)).pipe(\n    Option.match({ onNone: () => \"audio\", onSome: ([, ext]) => `audio.${ext}` }),\n  )\n\n// ---------------------------------------------------------------------------\n// AudioFormat → Voxtral TTS `response_format`\n// ---------------------------------------------------------------------------\n\nexport type MistralTtsFormat = \"mp3\" | \"wav\" | \"pcm\" | \"flac\" | \"opus\"\n\n/**\n * Map an `AudioFormat.container` to Voxtral TTS's `response_format`. Voxtral\n * produces mp3 / wav / pcm / flac / opus; aac / ogg / webm are unsupported.\n */\nexport const containerToTtsFormat: (\n  container: AudioFormat[\"container\"],\n) => Effect.Effect<MistralTtsFormat, AiError.AiError> = Match.type<AudioFormat[\"container\"]>().pipe(\n  Match.when(\"mp3\", () => Effect.succeed<MistralTtsFormat>(\"mp3\")),\n  Match.when(\"wav\", () => Effect.succeed<MistralTtsFormat>(\"wav\")),\n  Match.when(\"raw\", () => Effect.succeed<MistralTtsFormat>(\"pcm\")),\n  Match.when(\"flac\", () => Effect.succeed<MistralTtsFormat>(\"flac\")),\n  Match.when(\"opus\", () => Effect.succeed<MistralTtsFormat>(\"opus\")),\n  Match.whenOr(\"aac\", \"ogg\", \"webm\", (c) =>\n    Effect.fail(\n      new AiError.Unsupported({\n        provider: \"mistral\",\n        capability: \"outputFormat\",\n        reason: `Voxtral TTS does not produce ${c} output; supported: mp3 | wav | pcm (raw) | flac | opus.`,\n      }),\n    ),\n  ),\n  Match.exhaustive,\n)\n\n/**\n * The on-wire `AudioFormat` Voxtral actually returns for each\n * `response_format`. Voxtral's `pcm` is float32 LE at 24 kHz; the caller's\n * requested sample rate is not honoured for raw output.\n */\nexport const realizedTtsFormat: (rf: MistralTtsFormat) => AudioFormat =\n  Match.type<MistralTtsFormat>().pipe(\n    Match.when(\n      \"mp3\",\n      (): AudioFormat => ({ container: \"mp3\", encoding: \"mp3\", sampleRate: 24000 }),\n    ),\n    Match.when(\n      \"wav\",\n      (): AudioFormat => ({ container: \"wav\", encoding: \"pcm_s16le\", sampleRate: 24000 }),\n    ),\n    Match.when(\n      \"pcm\",\n      (): AudioFormat => ({ container: \"raw\", encoding: \"pcm_f32le\", sampleRate: 24000 }),\n    ),\n    Match.when(\n      \"flac\",\n      (): AudioFormat => ({ container: \"flac\", encoding: \"flac\", sampleRate: 24000 }),\n    ),\n    Match.when(\n      \"opus\",\n      (): AudioFormat => ({ container: \"opus\", encoding: \"opus\", sampleRate: 24000 }),\n    ),\n    Match.exhaustive,\n  )\n"],"mappings":";;;AAQA,MAAM,uBAAuB,QAC3B,OAAO,MAAM,SAAS,aAAa,IAAI,EAAE;CACvC,WAAW,OAAO;CAClB,YAAY,UACV,OAAO,KAAK,IAAI,QAAQ,eAAe;EAAE,UAAU;EAAW,OAAO;EAAS,KAAK;EAAO,CAAC,CAAC;CAC/F,CAAC;;;;;;AAOJ,MAAM,eAAe,OAAmB,aACtC,IAAI,KAAK,CAAC,MAAiC,EAAE,EAAE,MAAM,UAAU,CAAC;;;;;AAMlE,MAAa,cACX,MAAM,MAAmB,CAAC,KACxB,MAAM,IAAI,UAAU,MAAM,OAAO,QAAQ,YAAY,EAAE,OAAO,EAAE,SAAS,CAAC,CAAC,EAC3E,MAAM,IAAI,WAAW,MACnB,oBAAoB,EAAE,OAAO,CAAC,KAAK,OAAO,KAAK,UAAU,YAAY,OAAO,EAAE,SAAS,CAAC,CAAC,CAC1F,EACD,MAAM,IAAI,QAAQ,MAChB,OAAO,KACL,IAAI,QAAQ,eAAe;CACzB,UAAU;CACV,OAAO;CACP,KAAK,oDAAoD,EAAE,IAAI;CAChE,CAAC,CACH,CACF,EACD,MAAM,WACP;AAEH,MAAM,oBAA4E;CAChF,CAAC,QAAQ,MAAM;CACf,CAAC,OAAO,MAAM;CACd,CAAC,OAAO,MAAM;CACd,CAAC,OAAO,MAAM;CACd,CAAC,QAAQ,MAAM;CACf,CAAC,QAAQ,OAAO;CAChB,CAAC,OAAO,MAAM;CACd,CAAC,OAAO,MAAM;CACd,CAAC,OAAO,MAAM;CACd,CAAC,QAAQ,OAAO;CACjB;;AAGD,MAAa,mBAAmB,aAC9BA,MAAI,UAAU,oBAAoB,CAAC,aAAa,SAAS,SAAS,QAAQ,CAAC,CAAC,KAC1E,OAAO,MAAM;CAAE,cAAc;CAAS,SAAS,GAAG,SAAS,SAAS;CAAO,CAAC,CAC7E;;;;;AAYH,MAAa,uBAE2C,MAAM,MAAgC,CAAC,KAC7F,MAAM,KAAK,aAAa,OAAO,QAA0B,MAAM,CAAC,EAChE,MAAM,KAAK,aAAa,OAAO,QAA0B,MAAM,CAAC,EAChE,MAAM,KAAK,aAAa,OAAO,QAA0B,MAAM,CAAC,EAChE,MAAM,KAAK,cAAc,OAAO,QAA0B,OAAO,CAAC,EAClE,MAAM,KAAK,cAAc,OAAO,QAA0B,OAAO,CAAC,EAClE,MAAM,OAAO,OAAO,OAAO,SAAS,MAClC,OAAO,KACL,IAAI,QAAQ,YAAY;CACtB,UAAU;CACV,YAAY;CACZ,QAAQ,gCAAgC,EAAE;CAC3C,CAAC,CACH,CACF,EACD,MAAM,WACP;;;;;;AAOD,MAAa,oBACX,MAAM,MAAwB,CAAC,KAC7B,MAAM,KACJ,cACoB;CAAE,WAAW;CAAO,UAAU;CAAO,YAAY;CAAO,EAC7E,EACD,MAAM,KACJ,cACoB;CAAE,WAAW;CAAO,UAAU;CAAa,YAAY;CAAO,EACnF,EACD,MAAM,KACJ,cACoB;CAAE,WAAW;CAAO,UAAU;CAAa,YAAY;CAAO,EACnF,EACD,MAAM,KACJ,eACoB;CAAE,WAAW;CAAQ,UAAU;CAAQ,YAAY;CAAO,EAC/E,EACD,MAAM,KACJ,eACoB;CAAE,WAAW;CAAQ,UAAU;CAAQ,YAAY;CAAO,EAC/E,EACD,MAAM,WACP"}

package/dist/chunk-CfYAbeIz.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/dist/codec.d.mts

@@ -0,0 +1,100 @@
+import { Option, Schema } from "effect";
+import { ToolDescriptor } from "@effect-uai/core/Tool";
+import { Turn, TurnEvent } from "@effect-uai/core/Turn";
+import * as _$effect_SchemaAST0 from "effect/SchemaAST";
+import * as _$effect_Effect0 from "effect/Effect";
+import { HistoryItem, Usage } from "@effect-uai/core/Items";
+import { StructuredFormat } from "@effect-uai/core/StructuredFormat";
+
+//#region src/codec.d.ts
+declare namespace codec_d_exports {
+  export { Accumulator, WireChunk, accumulatorToTurn, applyChunk, decodeChunk, emptyAccumulator, itemsToMessages, responseFormatWire, toolChoiceWire, toolsWire };
+}
+type WireMessage = {
+  role: string;
+  content: string | ReadonlyArray<Record<string, unknown>>;
+  tool_calls?: ReadonlyArray<Record<string, unknown>>;
+  tool_call_id?: string;
+};
+/** Convert our `HistoryItem[]` history into Mistral chat `messages`. */
+declare const itemsToMessages: (items: ReadonlyArray<HistoryItem>) => ReadonlyArray<WireMessage>;
+declare const toolsWire: (descriptors: ReadonlyArray<ToolDescriptor>) => Option.Option<ReadonlyArray<Record<string, unknown>>>;
+type ToolChoice = "auto" | "required" | "none" | {
+  readonly type: "function";
+  readonly name: string;
+};
+declare const toolChoiceWire: (choice: ToolChoice) => string | Record<string, unknown>;
+declare const responseFormatWire: (structured: StructuredFormat<unknown>) => Record<string, unknown>;
+declare const WireChunk: Schema.Struct<{
+  readonly choices: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly index: Schema.optional<Schema.Number>;
+    readonly delta: Schema.optional<Schema.Struct<{
+      readonly role: Schema.optional<Schema.NullOr<Schema.String>>;
+      readonly content: Schema.optional<Schema.NullOr<Schema.String>>;
+      readonly tool_calls: Schema.optional<Schema.NullOr<Schema.$Array<Schema.Struct<{
+        readonly index: Schema.optional<Schema.Number>;
+        readonly id: Schema.optional<Schema.NullOr<Schema.String>>;
+        readonly function: Schema.optional<Schema.Struct<{
+          readonly name: Schema.optional<Schema.NullOr<Schema.String>>;
+          readonly arguments: Schema.optional<Schema.NullOr<Schema.String>>;
+        }>>;
+      }>>>>;
+    }>>;
+    readonly finish_reason: Schema.optional<Schema.NullOr<Schema.String>>;
+  }>>>;
+  readonly usage: Schema.optional<Schema.NullOr<Schema.Struct<{
+    readonly prompt_tokens: Schema.optional<Schema.Number>;
+    readonly completion_tokens: Schema.optional<Schema.Number>;
+    readonly total_tokens: Schema.optional<Schema.Number>;
+  }>>>;
+}>;
+type WireChunk = typeof WireChunk.Type;
+declare const decodeChunk: (input: unknown, options?: _$effect_SchemaAST0.ParseOptions) => _$effect_Effect0.Effect<{
+  readonly choices?: readonly {
+    readonly index?: number | undefined;
+    readonly delta?: {
+      readonly role?: string | null | undefined;
+      readonly content?: string | null | undefined;
+      readonly tool_calls?: readonly {
+        readonly function?: {
+          readonly name?: string | null | undefined;
+          readonly arguments?: string | null | undefined;
+        } | undefined;
+        readonly index?: number | undefined;
+        readonly id?: string | null | undefined;
+      }[] | null | undefined;
+    } | undefined;
+    readonly finish_reason?: string | null | undefined;
+  }[] | undefined;
+  readonly usage?: {
+    readonly prompt_tokens?: number | undefined;
+    readonly completion_tokens?: number | undefined;
+    readonly total_tokens?: number | undefined;
+  } | null | undefined;
+}, Schema.SchemaError, never>;
+type ToolAcc = {
+  readonly call_id: string;
+  readonly name: string;
+  readonly arguments: string;
+};
+type Accumulator = {
+  readonly text: string; /** Tool calls keyed by their wire `index` (defaults to position when absent). */
+  readonly tools: ReadonlyMap<number, ToolAcc>;
+  readonly order: ReadonlyArray<number>;
+  readonly usage: Usage;
+  readonly finishReason: Option.Option<string>;
+};
+declare const emptyAccumulator: Accumulator;
+/** State threaded through the fold plus the events the step produced. */
+type Step = readonly [Accumulator, ReadonlyArray<TurnEvent>];
+/**
+ * Fold one decoded chunk into the accumulator, returning the next state and
+ * the `TurnEvent`s the chunk produced. Mirrors Anthropic's `deltasFromEvent`,
+ * but over chat-completions deltas.
+ */
+declare const applyChunk: (acc: Accumulator, chunk: WireChunk) => Step;
+/** Assemble the terminal `Turn` from the accumulated state. */
+declare const accumulatorToTurn: (acc: Accumulator) => Turn;
+//#endregion
+export { Accumulator, WireChunk, accumulatorToTurn, applyChunk, decodeChunk, emptyAccumulator, itemsToMessages, responseFormatWire, codec_d_exports as t, toolChoiceWire, toolsWire };
+//# sourceMappingURL=codec.d.mts.map

package/dist/codec.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.d.mts","names":[],"sources":["../src/codec.ts"],"mappings":";;;;;;;;;;;;KAwBK,WAAA;EACH,IAAA;EACA,OAAA,WAAkB,aAAA,CAAc,MAAA;EAChC,UAAA,GAAa,aAAA,CAAc,MAAA;EAC3B,YAAA;AAAA;;cAwEW,eAAA,GAAmB,KAAA,EAAO,aAAA,CAAc,WAAA,MAAe,aAAA,CAAc,WAAA;AAAA,cAOrE,SAAA,GACX,WAAA,EAAa,aAAA,CAAc,cAAA,MAC1B,MAAA,CAAO,MAAA,CAAO,aAAA,CAAc,MAAA;AAAA,KAe1B,UAAA;EAAA,SAIU,IAAA;EAAA,SAA2B,IAAA;AAAA;AAAA,cAG7B,cAAA,GAAkB,MAAA,EAAQ,UAAA,cAAsB,MAAA;AAAA,cAQhD,kBAAA,GACX,UAAA,EAAY,gBAAA,cACX,MAAA;AAAA,cA0CU,SAAA,EAAS,MAAA,CAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;KAIV,SAAA,UAAmB,SAAA,CAAU,IAAA;AAAA,cAE5B,WAAA,GAAW,KAAA,WAAA,OAAA,GAAwC,mBAAA,CAAxC,YAAA,sBAAA,MAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;KAMnB,OAAA;EAAA,SACM,OAAA;EAAA,SACA,IAAA;EAAA,SACA,SAAA;AAAA;AAAA,KAGC,WAAA;EAAA,SACD,IAAA,UA7F0B;EAAA,SA+F1B,KAAA,EAAO,WAAA,SAAoB,OAAA;EAAA,SAC3B,KAAA,EAAO,aAAA;EAAA,SACP,KAAA,EAAO,KAAA;EAAA,SACP,YAAA,EAAc,MAAA,CAAO,MAAA;AAAA;AAAA,cAGnB,gBAAA,EAAkB,WAAA;;KAS1B,IAAA,aAAiB,WAAA,EAAa,aAAA,CAAc,SAAA;;;;;;cAmFpC,UAAA,GAAc,GAAA,EAAK,WAAA,EAAa,KAAA,EAAO,SAAA,KAAY,IAAA;AAnKhE;AAAA,cA+Ka,iBAAA,GAAqB,GAAA,EAAK,WAAA,KAAc,IAAA"}

package/dist/codec.mjs

@@ -0,0 +1,244 @@
+import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
+import { Array, Encoding, Match, Option, Schema } from "effect";
+import { TurnEvent } from "@effect-uai/core/Turn";
+//#region src/codec.ts
+var codec_exports = /* @__PURE__ */ __exportAll({
+	WireChunk: () => WireChunk,
+	accumulatorToTurn: () => accumulatorToTurn,
+	applyChunk: () => applyChunk,
+	decodeChunk: () => decodeChunk,
+	emptyAccumulator: () => emptyAccumulator,
+	itemsToMessages: () => itemsToMessages,
+	responseFormatWire: () => responseFormatWire,
+	toolChoiceWire: () => toolChoiceWire,
+	toolsWire: () => toolsWire
+});
+/** A `data:` URI for inline image bytes; URLs pass through untouched. */
+const imageSourceToUrl = Match.type().pipe(Match.tag("url", (s) => s.url), Match.tag("base64", (s) => `data:${s.mimeType};base64,${s.base64}`), Match.tag("bytes", (s) => `data:${s.mimeType};base64,${Encoding.encodeBase64(s.bytes)}`), Match.exhaustive);
+const blockToPart = Match.type().pipe(Match.discriminatorsExhaustive("type")({
+	input_text: (b) => ({
+		type: "text",
+		text: b.text
+	}),
+	output_text: (b) => ({
+		type: "text",
+		text: b.text
+	}),
+	refusal: (b) => ({
+		type: "text",
+		text: b.text
+	}),
+	input_image: (b) => ({
+		type: "image_url",
+		image_url: imageSourceToUrl(b.source)
+	})
+}));
+const isTextBlock = (b) => b.type === "input_text" || b.type === "output_text" || b.type === "refusal";
+const textOfBlock = (b) => b.type === "input_image" ? "" : b.text;
+/**
+* Collapse a message's content to a plain string when it is text-only
+* (the common case Mistral prefers), otherwise emit the multimodal parts
+* array.
+*/
+const encodeContent = (content) => Array.every(content, isTextBlock) ? content.map(textOfBlock).join("") : content.map(blockToPart);
+const toolCallWire = (call_id, name, args) => ({
+	id: call_id,
+	type: "function",
+	function: {
+		name,
+		arguments: args
+	}
+});
+const appendToolCall = (acc, call_id, name, args) => {
+	const last = acc[acc.length - 1];
+	const wire = toolCallWire(call_id, name, args);
+	if (last !== void 0 && last.role === "assistant" && last.tool_call_id === void 0) return [...acc.slice(0, -1), {
+		...last,
+		tool_calls: [...last.tool_calls ?? [], wire]
+	}];
+	return [...acc, {
+		role: "assistant",
+		content: "",
+		tool_calls: [wire]
+	}];
+};
+const foldItem = (acc, item) => Match.value(item).pipe(Match.discriminatorsExhaustive("type")({
+	message: (m) => [...acc, {
+		role: m.role,
+		content: encodeContent(m.content)
+	}],
+	function_call: (f) => appendToolCall(acc, f.call_id, f.name, f.arguments),
+	function_call_output: (o) => [...acc, {
+		role: "tool",
+		tool_call_id: o.call_id,
+		content: o.output
+	}],
+	reasoning: () => acc
+}));
+/** Convert our `HistoryItem[]` history into Mistral chat `messages`. */
+const itemsToMessages = (items) => Array.reduce(items, [], foldItem);
+const toolsWire = (descriptors) => descriptors.length > 0 ? Option.some(descriptors.map((t) => ({
+	type: "function",
+	function: {
+		name: t.name,
+		description: t.description,
+		parameters: t.inputSchema,
+		...t.strict !== void 0 && { strict: t.strict }
+	}
+}))) : Option.none();
+const toolChoiceWire = (choice) => Match.value(choice).pipe(Match.when("auto", () => "auto"), Match.when("required", () => "any"), Match.when("none", () => "none"), Match.orElse((c) => ({
+	type: "function",
+	function: { name: c.name }
+})));
+const responseFormatWire = (structured) => ({
+	type: "json_schema",
+	json_schema: {
+		name: structured.name,
+		schema: structured.schema["~standard"].jsonSchema.input({ target: "draft-2020-12" }),
+		...structured.strict !== void 0 && { strict: structured.strict }
+	}
+});
+const WireFunction = Schema.Struct({
+	name: Schema.optional(Schema.NullOr(Schema.String)),
+	arguments: Schema.optional(Schema.NullOr(Schema.String))
+});
+const WireToolCall = Schema.Struct({
+	index: Schema.optional(Schema.Number),
+	id: Schema.optional(Schema.NullOr(Schema.String)),
+	function: Schema.optional(WireFunction)
+});
+const WireDelta = Schema.Struct({
+	role: Schema.optional(Schema.NullOr(Schema.String)),
+	content: Schema.optional(Schema.NullOr(Schema.String)),
+	tool_calls: Schema.optional(Schema.NullOr(Schema.Array(WireToolCall)))
+});
+const WireChoice = Schema.Struct({
+	index: Schema.optional(Schema.Number),
+	delta: Schema.optional(WireDelta),
+	finish_reason: Schema.optional(Schema.NullOr(Schema.String))
+});
+const WireUsage = Schema.Struct({
+	prompt_tokens: Schema.optional(Schema.Number),
+	completion_tokens: Schema.optional(Schema.Number),
+	total_tokens: Schema.optional(Schema.Number)
+});
+const WireChunk = Schema.Struct({
+	choices: Schema.optional(Schema.Array(WireChoice)),
+	usage: Schema.optional(Schema.NullOr(WireUsage))
+});
+const decodeChunk = Schema.decodeUnknownEffect(WireChunk);
+const emptyAccumulator = {
+	text: "",
+	tools: /* @__PURE__ */ new Map(),
+	order: [],
+	usage: {},
+	finishReason: Option.none()
+};
+const usageFrom = (wire) => ({
+	...wire.prompt_tokens !== void 0 && { input_tokens: wire.prompt_tokens },
+	...wire.completion_tokens !== void 0 && { output_tokens: wire.completion_tokens },
+	...wire.total_tokens !== void 0 && { total_tokens: wire.total_tokens }
+});
+const reasonToStop = Match.type().pipe(Match.when("stop", () => "stop"), Match.when("length", () => "max_tokens"), Match.when("model_length", () => "max_tokens"), Match.when("tool_calls", () => "tool_calls"), Match.when("content_filter", () => "content_filter"), Match.orElse(() => "stop"));
+const stopReasonOf = (acc) => Option.match(acc.finishReason, {
+	onNone: () => acc.tools.size > 0 ? "tool_calls" : "stop",
+	onSome: reasonToStop
+});
+const withTool = (acc, index, tool, isNew) => ({
+	...acc,
+	tools: new Map(acc.tools).set(index, tool),
+	order: isNew ? [...acc.order, index] : acc.order
+});
+const applyContent = (acc, delta) => {
+	const content = delta?.content;
+	return content !== void 0 && content !== null && content.length > 0 ? [{
+		...acc,
+		text: acc.text + content
+	}, [TurnEvent.TextDelta({ text: content })]] : [acc, []];
+};
+const applyToolCall = (acc, tc, position) => {
+	const index = tc.index ?? position;
+	const argsDelta = tc.function?.arguments ?? "";
+	const existing = acc.tools.get(index);
+	if (existing === void 0) {
+		const call_id = tc.id ?? `call_${index}`;
+		const name = tc.function?.name ?? "";
+		return [withTool(acc, index, {
+			call_id,
+			name,
+			arguments: argsDelta
+		}, true), [TurnEvent.ToolCallStart({
+			call_id,
+			name
+		}), ...argsDelta.length > 0 ? [TurnEvent.ToolCallArgsDelta({
+			call_id,
+			delta: argsDelta
+		})] : []]];
+	}
+	return argsDelta.length > 0 ? [withTool(acc, index, {
+		...existing,
+		arguments: existing.arguments + argsDelta
+	}, false), [TurnEvent.ToolCallArgsDelta({
+		call_id: existing.call_id,
+		delta: argsDelta
+	})]] : [acc, []];
+};
+const chain = (step, next) => {
+	const [acc, events] = step;
+	const [acc2, more] = next(acc);
+	return [acc2, [...events, ...more]];
+};
+const applyChoice = (step, choice) => {
+	const withContent = chain(step, (acc) => applyContent(acc, choice.delta));
+	const withTools = Array.reduce(choice.delta?.tool_calls ?? [], withContent, (s, tc, i) => chain(s, (acc) => applyToolCall(acc, tc, i)));
+	const reason = choice.finish_reason;
+	return reason !== void 0 && reason !== null ? [{
+		...withTools[0],
+		finishReason: Option.some(reason)
+	}, withTools[1]] : withTools;
+};
+/**
+* Fold one decoded chunk into the accumulator, returning the next state and
+* the `TurnEvent`s the chunk produced. Mirrors Anthropic's `deltasFromEvent`,
+* but over chat-completions deltas.
+*/
+const applyChunk = (acc, chunk) => {
+	const afterChoices = Array.reduce(chunk.choices ?? [], [acc, []], applyChoice);
+	const usage = chunk.usage;
+	return usage !== void 0 && usage !== null ? chain(afterChoices, (a) => {
+		const u = usageFrom(usage);
+		return [{
+			...a,
+			usage: u
+		}, [TurnEvent.UsageUpdate({ usage: u })]];
+	}) : afterChoices;
+};
+/** Assemble the terminal `Turn` from the accumulated state. */
+const accumulatorToTurn = (acc) => {
+	const message = acc.text.length > 0 ? [{
+		type: "message",
+		role: "assistant",
+		content: [{
+			type: "output_text",
+			text: acc.text
+		}]
+	}] : [];
+	const toolCalls = acc.order.flatMap((index) => {
+		const t = acc.tools.get(index);
+		return t === void 0 ? [] : [{
+			type: "function_call",
+			call_id: t.call_id,
+			name: t.name,
+			arguments: t.arguments
+		}];
+	});
+	return {
+		items: [...message, ...toolCalls],
+		usage: acc.usage,
+		stop_reason: stopReasonOf(acc)
+	};
+};
+//#endregion
+export { WireChunk, accumulatorToTurn, applyChunk, decodeChunk, emptyAccumulator, itemsToMessages, responseFormatWire, codec_exports as t, toolChoiceWire, toolsWire };
+
+//# sourceMappingURL=codec.mjs.map