@opencode/ai 2.0.18 → 2.0.19

package/README.md

@@ -129,8 +129,9 @@ VercelAIGateway.configure().experimental.evaluation("typesafe-ai/jev")
 
 OpenRouter reads `OPENROUTER_API_KEY`. Vercel reads `AI_GATEWAY_API_KEY`, then `VERCEL_OIDC_TOKEN`.
 The common API uses `boolean`; System One routes lower it to native `noul`.
-Choice and score confidence plus score legends remain available in provider metadata, and the
-provider's rounded probabilities are returned unchanged.
+Choice and score answers include `confidence` when the provider returns it, such as
+`response.answers.department.confidence`. Score legends remain available in provider metadata, and
+the provider's rounded probabilities are returned unchanged.
 
 ## Alibaba Cloud Model Studio
 
@@ -752,7 +753,10 @@ const events = Video.stream({ model: Runway.configure({ apiKey }).video("gen4.5"
 
 Status polls, result fetches, cancels, and asset downloads all run through the same request executor with the route's
 auth. `Generation.await` and `Generation.events` fail with a
-`Timeout` reason when `poll.timeout` (default 10 minutes) elapses. Failed,
+`Timeout` reason when `poll.timeout` (default 10 minutes) elapses. Status polls and result fetches retry transient
+failures (rate limits, provider 5xx, network errors) with backoff that honors `retry-after`, always within
+`poll.timeout`; submits and cancels never retry. Interrupting a wait (or aborting its `signal`) does not cancel the
+provider job, which keeps running and billing: call `cancel()` to stop it. Failed,
 cancelled, and expired generations fail typed with the provider's terminal document on `reason.body`; moderation
 outcomes (Veo `raiMediaFilteredReasons`, xAI `respect_moderation`, Runway `SAFETY.*` codes) surface as `notices` when
 a video is still returned and as a `ContentPolicy` reason when nothing is.
@@ -773,7 +777,9 @@ Provider notes:
 The promise client exposes the same surface: `ai.video.start(...)` resolves to a handle with `await`, `events`,
 `result`, `refresh`, `cancel`, and `token`; `ai.video.generate`, `ai.video.resume(model, token)`, and
 `ai.video.stream` mirror the Effect API. The handle's `status` and `progress` are a snapshot from when it was
-created; `refresh()` resolves to a new handle.
+created; `refresh()` resolves to a new handle. Every promise method and stream accepts `{ signal }`: like `fetch`,
+aborting rejects the Promise or throws from the `for await` loop with `signal.reason` (an `AbortError` `DOMException`
+unless `abort(reason)` passed one), while `break` stops a stream without throwing.
 
 ```ts
 import { ai } from "@opencode/ai/promise"
@@ -871,11 +877,12 @@ for await (const event of ai.speech.stream({ model, text: "Hello from OpenCode."
 ## Transcription
 
 Transcription (speech-to-text) is the one modality whose providers use every route kind: OpenAI and Gemini stream,
-Deepgram answers inline, and AssemblyAI is queued. `Transcription.generate` and `Transcription.stream` work on all of
-them; `Transcription.start` / `resume` return a `Generation` on queued routes and fail with `UnsupportedOperation`
-elsewhere. Models come from `.transcription(...)` selectors on the `OpenAI`, `Google`, `Deepgram`, and `AssemblyAI`
-facades. Common fields (`language`, `prompt`, `timestamps: "none" | "segment" | "word"`, `diarize`, `speakers`) lower
-natively or fail with a typed `AIError` before any network call; a route may return more than asked.
+Deepgram and ElevenLabs answer inline, and AssemblyAI is queued. `Transcription.generate` and `Transcription.stream`
+work on all of them; `Transcription.start` / `resume` return a `Generation` on queued routes and fail with
+`UnsupportedOperation` elsewhere. Models come from `.transcription(...)` selectors on the `OpenAI`, `Google`,
+`Deepgram`, `ElevenLabs`, and `AssemblyAI` facades. Common fields (`language`, `prompt`,
+`timestamps: "none" | "segment" | "word"`, `diarize`, `speakers`) lower natively or fail with a typed `AIError` before
+any network call; a route may return more than asked.
 
 ```ts
 import { Console, Effect, Stream } from "effect"
@@ -887,7 +894,7 @@ const openai = OpenAI.configure({ apiKey: process.env.OPENAI_API_KEY })
 const program = Effect.gen(function* () {
   const audio = yield* Media.file("./call.mp3")
 
-  // Speaker-labelled segments; labels are provider-native strings ("A", "0", "spk:0").
+  // Speaker-labelled segments; labels are provider-native strings ("A", "0", "spk:0", "speaker_0").
   const response = yield* Transcription.generate({
     model: Deepgram.configure({ apiKey }).transcription("nova-3"),
     audio,
@@ -897,7 +904,7 @@ const program = Effect.gen(function* () {
   response.text // "Hello from OpenCode."
   response.segments // [{ text, startSeconds, endSeconds, speaker: "0" }]
   response.words // [{ text, startSeconds, endSeconds, speaker, confidence }]
-  response.language // the provider's own value, lowercased ("en", "english", "en_us")
+  response.language // the provider's own value, lowercased ("en", "eng", "english", "en_us")
 
   // Text deltas as the model transcribes, then one finish carrying the whole transcript.
   yield* Transcription.stream({ model: openai.transcription("gpt-4o-mini-transcribe"), audio }).pipe(
@@ -921,7 +928,12 @@ Provider notes:
 - **OpenAI** takes inline audio only; `diarize` needs `gpt-4o-transcribe-diarize`, timestamps need `whisper-1`, and `whisper-1` does not stream.
 - **Gemini** needs a transcribe model (`gemini-3.5-transcribe`); `prompt` and `speakers` fail typed.
 - **Deepgram** detects the language unless `language` is set; vocabulary goes in `providerOptions.keyterm`.
-- **AssemblyAI** uploads inline audio before submitting and is the only route that accepts `speakers`.
+- **ElevenLabs** (`scribe_v2`) uploads inline audio as the multipart `file` and sends a URL as `source_url`. Words
+  always carry timestamps, and segments are speaker turns, so `diarize`, `timestamps: "segment"`, or `speakers` turns
+  on diarization. `speakers` is an upper bound (`num_speakers`); `prompt` fails typed (vocabulary goes in
+  `providerOptions.keyterms`), as do webhook delivery and per-channel output (`use_multi_channel` without
+  `multichannel_output_style: "combined"`).
+- **AssemblyAI** uploads inline audio before submitting and treats `speakers` as the exact speaker count.
 
 The promise client mirrors the Effect API:
 

package/dist/cache-policy.js

@@ -37,6 +37,7 @@ const resolve = (policy) => {
 // whole policy pass for these — emitting hints would be harmless but pointless.
 const RESPECTS_INLINE_HINTS = new Set([
     "anthropic-messages",
+    "anthropic-compatible-messages",
     "google-vertex-messages",
     "bedrock-converse",
     "openrouter",

package/dist/experimental/evaluation.d.ts

@@ -54,12 +54,14 @@ export declare const ChoiceAnswer: Schema.Struct<{
     readonly type: Schema.Literal<"choice">;
     readonly choice: Schema.String;
     readonly probabilities: Schema.optional<Schema.$Record<Schema.String, Schema.Number>>;
+    readonly confidence: Schema.optional<Schema.Number>;
 }>;
 export type ChoiceAnswer = Schema.Schema.Type<typeof ChoiceAnswer>;
 export declare const ScoreAnswer: Schema.Struct<{
     readonly type: Schema.Literal<"score">;
     readonly score: Schema.Number;
     readonly probabilities: Schema.optional<Schema.$Record<Schema.String, Schema.Number>>;
+    readonly confidence: Schema.optional<Schema.Number>;
 }>;
 export type ScoreAnswer = Schema.Schema.Type<typeof ScoreAnswer>;
 export declare const BooleanAnswer: Schema.Struct<{
@@ -71,10 +73,12 @@ export declare const EvaluationAnswer: Schema.toTaggedUnion<"type", readonly [Sc
     readonly type: Schema.Literal<"choice">;
     readonly choice: Schema.String;
     readonly probabilities: Schema.optional<Schema.$Record<Schema.String, Schema.Number>>;
+    readonly confidence: Schema.optional<Schema.Number>;
 }>, Schema.Struct<{
     readonly type: Schema.Literal<"score">;
     readonly score: Schema.Number;
     readonly probabilities: Schema.optional<Schema.$Record<Schema.String, Schema.Number>>;
+    readonly confidence: Schema.optional<Schema.Number>;
 }>, Schema.Struct<{
     readonly type: Schema.Literal<"boolean">;
     readonly probability: Schema.Number;
@@ -87,6 +91,7 @@ export type AnswerFor<Question extends EvaluationQuestion> = Question extends {
     readonly type: "choice";
     readonly choice: Extract<keyof Criteria, string>;
     readonly probabilities?: Readonly<Record<Extract<keyof Criteria, string>, number>>;
+    readonly confidence?: number;
 } : Question extends {
     readonly type: "score";
 } ? ScoreAnswer : BooleanAnswer;
@@ -206,10 +211,12 @@ declare const EvaluationResponse_base: Schema.Class<EvaluationResponse, Schema.S
         readonly type: Schema.Literal<"choice">;
         readonly choice: Schema.String;
         readonly probabilities: Schema.optional<Schema.$Record<Schema.String, Schema.Number>>;
+        readonly confidence: Schema.optional<Schema.Number>;
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"score">;
         readonly score: Schema.Number;
         readonly probabilities: Schema.optional<Schema.$Record<Schema.String, Schema.Number>>;
+        readonly confidence: Schema.optional<Schema.Number>;
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"boolean">;
         readonly probability: Schema.Number;

package/dist/experimental/evaluation.js

@@ -33,11 +33,13 @@ export const ChoiceAnswer = Schema.Struct({
     type: Schema.Literal("choice"),
     choice: Schema.String,
     probabilities: Schema.optional(Schema.Record(Schema.String, Probability)),
+    confidence: Schema.optional(Probability),
 });
 export const ScoreAnswer = Schema.Struct({
     type: Schema.Literal("score"),
     score: Schema.Number,
     probabilities: Schema.optional(Schema.Record(Schema.String, Probability)),
+    confidence: Schema.optional(Probability),
 });
 export const BooleanAnswer = Schema.Struct({
     type: Schema.Literal("boolean"),

package/dist/experimental/system-one.js

@@ -80,34 +80,37 @@ export const model = (cfg) => EvaluationModel.make({
             const fail = (message, cause, body) => new AIError({ reason: new InvalidProviderOutputError({ route: "system-one", message, body, http, cause }) });
             const text = yield* res.text.pipe(Effect.mapError((cause) => fail("Failed to read the System One response", cause)));
             const data = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Response))(text).pipe(Effect.mapError((cause) => fail("System One returned an invalid response", cause, text)));
-            const confidence = {};
             const legend = {};
             const answers = Object.fromEntries(Object.entries(data.answers).map(([id, answer]) => {
                 if (answer.type === "noul")
                     return [id, { type: "boolean", probability: answer.noul }];
                 if (answer.type === "choice") {
-                    if (answer.confidence !== undefined)
-                        confidence[id] = answer.confidence;
                     return [
                         id,
                         {
                             type: "choice",
                             choice: answer.choice,
                             probabilities: answer.probabilities,
+                            ...(answer.confidence === undefined ? {} : { confidence: answer.confidence }),
                         },
                     ];
                 }
-                if (answer.confidence !== undefined)
-                    confidence[id] = answer.confidence;
                 if (answer.legend !== undefined)
                     legend[id] = answer.legend;
-                return [id, { type: "score", score: answer.score, probabilities: answer.probabilities }];
+                return [
+                    id,
+                    {
+                        type: "score",
+                        score: answer.score,
+                        probabilities: answer.probabilities,
+                        ...(answer.confidence === undefined ? {} : { confidence: answer.confidence }),
+                    },
+                ];
             }));
             const meta = {
                 ...(data.id === undefined ? {} : { responseId: data.id }),
                 ...(data.provider === undefined ? {} : { provider: data.provider }),
                 ...data.provider_metadata?.[cfg.providerMetadataKey],
-                ...(Object.keys(confidence).length === 0 ? {} : { confidence }),
                 ...(Object.keys(legend).length === 0 ? {} : { legend }),
             };
             return new EvaluationResponse({

package/dist/generation.d.ts

@@ -72,8 +72,8 @@ export declare class Generation<Response> {
      */
     events(options?: AwaitOptions): Stream.Stream<Event, AIError>;
     private event;
-    private timeoutError;
     private poll;
     private schedule;
 }
+/** `events` followed by the expanded result, with the result fetch bounded by the same `poll.timeout` deadline. */
 export declare const resultEvents: <Response, A>(generation: Generation<Response>, expand: (response: Response) => ReadonlyArray<A>, options?: AwaitOptions) => Stream.Stream<Observation | A, AIError>;

package/dist/generation.js

@@ -56,7 +56,7 @@ export class Generation {
         const settled = this.terminal ? Effect.succeed(this) : this.poll(options?.poll);
         return settled.pipe(
         // Non-completed terminal states also go through `result` so the route can surface its provider failure body.
-        Effect.flatMap((generation) => generation.result()), Effect.timeoutOrElse({ duration: timeout, orElse: () => this.timeoutError(timeout) }));
+        Effect.flatMap((generation) => generation.result()), Effect.timeoutOrElse({ duration: timeout, orElse: () => timeoutError(this.id, timeout) }));
     }
     cancel() {
         return this.route.cancel ?? Effect.void;
@@ -73,14 +73,7 @@ export class Generation {
         const timeout = Duration.fromInputUnsafe(options?.poll?.timeout ?? DEFAULT_POLL_TIMEOUT);
         return Stream.unwrap(Clock.currentTimeMillis.pipe(Effect.map((start) => {
             const deadline = start + Duration.toMillis(timeout);
-            // Fail before polling once the deadline has passed: a fast status request could otherwise win the zero-budget
-            // race and schedule another zero-delay poll.
-            const refresh = Clock.currentTimeMillis.pipe(Effect.flatMap((now) => now >= deadline
-                ? this.timeoutError(timeout)
-                : this.refresh().pipe(Effect.timeoutOrElse({
-                    duration: Duration.millis(deadline - now),
-                    orElse: () => this.timeoutError(timeout),
-                }))));
+            const refresh = within(this.refresh(), this.id, timeout, deadline);
             const schedule = this.schedule(options?.poll).pipe(Schedule.modifyDelay((meta) => Effect.succeed(Duration.min(meta.duration, Duration.millis(Math.max(0, deadline - meta.now))))));
             return Stream.fromEffectSchedule(refresh, schedule).pipe(Stream.takeUntil((generation) => generation.terminal), Stream.map((generation) => generation.event()));
         })));
@@ -92,14 +85,6 @@ export class Generation {
             return { type: "generation-queued", id: this.id, position: this.position };
         return { type: "generation-progress", id: this.id, progress: this.progress };
     }
-    timeoutError(timeout) {
-        return new AIError({
-            reason: new TimeoutError({
-                message: `Generation ${this.id} did not finish within ${Duration.format(timeout)}`,
-                timeoutMs: Duration.toMillis(timeout),
-            }),
-        });
-    }
     poll(poll) {
         return this.refresh().pipe(Effect.repeat({ schedule: this.schedule(poll), until: (generation) => generation.terminal }));
     }
@@ -107,4 +92,24 @@ export class Generation {
         return Schedule.spaced(poll?.interval ?? DEFAULT_POLL_INTERVAL);
     }
 }
-export const resultEvents = (generation, expand, options) => generation.events(options).pipe(Stream.filter((event) => event.type !== "generation-finished"), Stream.concat(Stream.fromIterableEffect(Effect.map(generation.result(), expand))));
+/** `events` followed by the expanded result, with the result fetch bounded by the same `poll.timeout` deadline. */
+export const resultEvents = (generation, expand, options) => {
+    const timeout = Duration.fromInputUnsafe(options?.poll?.timeout ?? DEFAULT_POLL_TIMEOUT);
+    return Stream.unwrap(Clock.currentTimeMillis.pipe(Effect.map((start) => generation.events(options).pipe(Stream.filter((event) => event.type !== "generation-finished"), Stream.concat(Stream.fromIterableEffect(within(generation.result(), generation.id, timeout, start + Duration.toMillis(timeout)).pipe(Effect.map(expand))))))));
+};
+/**
+ * Run `effect` within the time left until `deadline`. Fails before starting once the deadline has passed: a fast
+ * request could otherwise win the zero-budget race and schedule another zero-delay poll.
+ */
+const within = (effect, id, timeout, deadline) => Clock.currentTimeMillis.pipe(Effect.flatMap((now) => now >= deadline
+    ? Effect.fail(timeoutError(id, timeout))
+    : effect.pipe(Effect.timeoutOrElse({
+        duration: Duration.millis(deadline - now),
+        orElse: () => Effect.fail(timeoutError(id, timeout)),
+    }))));
+const timeoutError = (id, timeout) => new AIError({
+    reason: new TimeoutError({
+        message: `Generation ${id} did not finish within ${Duration.format(timeout)}`,
+        timeoutMs: Duration.toMillis(timeout),
+    }),
+});

package/dist/index.d.ts

@@ -4,7 +4,7 @@ export { ImageClient } from "./image-client.js";
 export { Auth } from "./route/auth.js";
 export { Provider } from "./provider.js";
 export { ProviderPackage } from "./provider-package.js";
-export { isContextOverflow, isContextOverflowFailure } from "./provider-error.js";
+export { isContextOverflow, isContextOverflowFailure, isRetryable } from "./provider-error.js";
 export type { RouteLanguageModelInput, RouteRoutedLanguageModelInput, Interface as LLMClientShape, LLMClientService, } from "./route/client.js";
 export * from "./schema/index.js";
 export { ImageAspectRatio, ImageEvent, ImageModel, ImageModelSchema, ImageRequest, ImageResponse, ImageSize, } from "./image.js";

package/dist/index.js

@@ -4,7 +4,7 @@ export { ImageClient } from "./image-client.js";
 export { Auth } from "./route/auth.js";
 export { Provider } from "./provider.js";
 export { ProviderPackage } from "./provider-package.js";
-export { isContextOverflow, isContextOverflowFailure } from "./provider-error.js";
+export { isContextOverflow, isContextOverflowFailure, isRetryable } from "./provider-error.js";
 export * from "./schema/index.js";
 export { ImageAspectRatio, ImageEvent, ImageModel, ImageModelSchema, ImageRequest, ImageResponse, ImageSize, } from "./image.js";
 export { Image } from "./image.js";

package/dist/promise.d.ts

@@ -30,7 +30,7 @@ export type GenerationHandle<Response> = Snapshot & {
     /** Serializable JSON; pass it back to `resume` from another process. */
     readonly token: unknown;
     readonly await: (options?: AwaitOptions & RunOptions) => Promise<Response>;
-    /** Status observations until the first terminal one, polling like `await`; abort ends iteration without throwing. */
+    /** Status observations until the first terminal one, polling like `await`; abort throws `signal.reason`. */
     readonly events: (options?: AwaitOptions & RunOptions) => AsyncIterable<Event>;
     /** The result without polling; fails when the generation has not completed. */
     readonly result: (options?: RunOptions) => Promise<Response>;

package/dist/promise.js

@@ -10,21 +10,22 @@ import { Speech } from "./speech.js";
 import { Transcription, } from "./transcription.js";
 import { fileMediaType } from "./utils/media-type.js";
 import { Video } from "./video.js";
+// Fails with `signal.reason` so aborted calls reject and aborted streams throw like `fetch`: an `AbortError` by default.
 const abortEffect = (signal) => signal === undefined
     ? Effect.never
     : Effect.callback((resume) => {
         if (signal.aborted) {
-            resume(Effect.void);
+            resume(Effect.fail(signal.reason));
             return;
         }
-        const onAbort = () => resume(Effect.void);
+        const onAbort = () => resume(Effect.fail(signal.reason));
         signal.addEventListener("abort", onAbort, { once: true });
         return Effect.sync(() => signal.removeEventListener("abort", onAbort));
     });
 export const make = (options = {}) => {
     const runtime = ManagedRuntime.make(AIClient.layerWith(options.layer ?? RequestExecutor.fetchLayer));
     /** Run any package Effect (for example `LLMClient.compact(...)`) inside this runtime. */
-    const run = (effect, options) => runtime.runPromise(effect, { signal: options?.signal });
+    const run = (effect, options) => runtime.runPromise(Effect.raceFirst(effect, abortEffect(options?.signal)));
     const iterate = (stream, options) => Stream.toAsyncIterable(Stream.unwrap(runtime.contextEffect.pipe(Effect.map((context) => stream.pipe(Stream.interruptWhen(abortEffect(options?.signal)), Stream.provideContext(context))))));
     const handle = (generation) => ({
         ...generation.snapshot,

package/dist/protocols/alibaba-chat.d.ts

@@ -90,12 +90,17 @@ export declare const protocol: Protocol<{
             readonly ttl?: string | undefined;
         } | undefined;
         readonly tool_calls?: readonly {
-            readonly id: string;
-            readonly type: "function";
             readonly function: {
                 readonly name: string;
                 readonly arguments: string;
             };
+            readonly id: string;
+            readonly type: "function";
+            readonly extra_content?: {
+                readonly google: {
+                    readonly thought_signature: string;
+                };
+            } | undefined;
         }[] | undefined;
         readonly reasoning_details?: unknown;
     } | {
@@ -208,6 +213,7 @@ export declare const protocol: Protocol<{
                 } | null | undefined;
                 readonly id?: string | null | undefined;
                 readonly index?: number | null | undefined;
+                readonly extra_content?: unknown;
             }[] | null | undefined;
             readonly reasoning_details?: unknown;
         } | null | undefined;

package/dist/protocols/deepgram-speech.js

@@ -50,23 +50,25 @@ const fromRequest = Effect.fn("DeepgramSpeech.fromRequest")(function* (request)
 // ---------------------------------------------------------------------------
 // 6. Stream parsing
 // ---------------------------------------------------------------------------
+/** Deepgram wraps raw encodings in WAV unless `container` is `none`, and defaults their sample rate per encoding. */
 const HEADERLESS_ENCODINGS = {
-    linear16: "pcm_s16le",
-    mulaw: "pcm_mulaw",
-    alaw: "pcm_alaw",
+    linear16: { encoding: "pcm_s16le", sampleRate: 24000 },
+    mulaw: { encoding: "pcm_mulaw", sampleRate: 8000 },
+    alaw: { encoding: "pcm_alaw", sampleRate: 8000 },
 };
 const finish = (state, context) => {
     const headers = context.http.headers;
     const mediaType = headers["content-type"];
     const format = audioFormat(context.request);
-    const encoding = HEADERLESS_ENCODINGS[format.encoding ?? ""];
+    const headerless = HEADERLESS_ENCODINGS[format.encoding ?? ""];
+    const container = format.container ?? (headerless === undefined ? undefined : "wav");
     const requestID = headers["dg-request-id"];
     const modelName = headers["dg-model-name"];
     return SpeechStream.finish(route, state, {
-        ...(format.container === "none" && encoding !== undefined
-            ? SpeechStream.pcm(encoding, SpeechStream.sampleRate(mediaType), mediaType)
+        ...(container === "none" && headerless !== undefined
+            ? SpeechStream.pcm(headerless.encoding, SpeechStream.sampleRate(mediaType) ?? context.request.providerOptions?.sampleRate ?? headerless.sampleRate, mediaType)
             : // Deepgram's default encoding is MP3; WAV is a container around any encoding.
-                { mediaType, info: { format: format.container === "wav" ? "wav" : (format.encoding ?? "mp3") } }),
+                { mediaType, info: { format: container === "wav" ? "wav" : (format.encoding ?? "mp3") } }),
         usage: SpeechStream.headerUsage("characters", headers["dg-char-count"]),
         providerMetadata: requestID === undefined && modelName === undefined
             ? undefined

package/dist/protocols/deepgram-transcription.js

@@ -5,6 +5,7 @@ import { mergeJsonRecords } from "../schema/index.js";
 import { TranscriptionModel, TranscriptionResponse } from "../transcription.js";
 import { ProviderShared } from "./shared.js";
 import { MediaInput } from "./utils/media-input.js";
+import { SpeakerTurns } from "./utils/speaker-turns.js";
 const route = MediaProtocol.identity({ id: "deepgram-transcription", name: "Deepgram", provider: "deepgram" });
 export const DEFAULT_BASE_URL = "https://api.deepgram.com";
 export const PATH = "/v1/listen";
@@ -63,15 +64,6 @@ const fromRequest = Effect.fn("DeepgramTranscription.fromRequest")(function* (re
 const decodeListen = route.decodeJson(ListenResponse);
 const speaker = (value) => (value === undefined ? undefined : String(value));
 const wordText = (word) => word.punctuated_word ?? word.word;
-// Utterances split on pauses, not speakers: the v2 diarizer labels a whole utterance with one speaker even when its
-// words change speaker, so segments split each utterance at speaker changes.
-const speakerTurns = (words) => words.reduce((turns, word) => {
-    const last = turns.at(-1);
-    if (last === undefined || last[0].speaker !== word.speaker)
-        return [...turns, [word]];
-    last.push(word);
-    return turns;
-}, []);
 const decodeResponse = Effect.fn("DeepgramTranscription.decodeResponse")(function* (response) {
     const output = yield* decodeListen(response);
     const channel = output.value.results.channels[0];
@@ -82,6 +74,8 @@ const decodeResponse = Effect.fn("DeepgramTranscription.decodeResponse")(functio
     const requestID = output.value.metadata?.request_id;
     return new TranscriptionResponse({
         text: alternative.transcript,
+        // Utterances split on pauses, not speakers: the v2 diarizer labels a whole utterance with one speaker even when
+        // its words change speaker, so segments split each utterance at speaker changes.
         segments: output.value.results.utterances?.flatMap((utterance) => utterance.words === undefined || utterance.words.length === 0
             ? [
                 {
@@ -91,7 +85,7 @@ const decodeResponse = Effect.fn("DeepgramTranscription.decodeResponse")(functio
                     speaker: speaker(utterance.speaker),
                 },
             ]
-            : speakerTurns(utterance.words).map((turn) => ({
+            : SpeakerTurns.group(utterance.words, (word) => word.speaker).map((turn) => ({
                 text: turn.map(wordText).join(" "),
                 startSeconds: turn[0].start,
                 endSeconds: turn[turn.length - 1].end,

package/dist/protocols/elevenlabs-transcription.d.ts

@@ -0,0 +1,28 @@
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { type OpenString } from "../schema/index.js";
+import { TranscriptionModel, TranscriptionResponse, type TranscriptionRequestFor } from "../transcription.js";
+export declare const DEFAULT_BASE_URL = "https://api.elevenlabs.io";
+export declare const PATH = "/v1/speech-to-text";
+export type ElevenLabsTranscriptionOptions = {
+    readonly tag_audio_events?: boolean;
+    readonly timestamps_granularity?: OpenString<"none" | "word" | "character">;
+    readonly diarization_threshold?: number;
+    readonly file_format?: OpenString<"pcm_s16le_16" | "other">;
+    readonly temperature?: number;
+    readonly seed?: number;
+    readonly keyterms?: ReadonlyArray<string>;
+    readonly no_verbatim?: boolean;
+    readonly detect_speaker_roles?: boolean;
+    readonly use_speaker_library?: boolean;
+    readonly entity_detection?: string | ReadonlyArray<string>;
+    readonly entity_redaction?: string | ReadonlyArray<string>;
+    readonly entity_redaction_mode?: OpenString<"redacted" | "entity_type" | "enumerated_entity_type">;
+} & Record<string, unknown>;
+export type Request = TranscriptionRequestFor<ElevenLabsTranscriptionOptions>;
+export declare const protocol: MediaProtocol.Inline<Request, TranscriptionResponse>;
+export declare const model: (input: MediaRoute.ModelInput) => TranscriptionModel<ElevenLabsTranscriptionOptions>;
+export declare const ElevenLabsTranscription: {
+    readonly protocol: MediaProtocol.Inline<Request, TranscriptionResponse>;
+    readonly model: (input: MediaRoute.ModelInput) => TranscriptionModel<ElevenLabsTranscriptionOptions>;
+};

package/dist/protocols/elevenlabs-transcription.js

@@ -0,0 +1,137 @@
+import { Effect, Schema } from "effect";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { mergeJsonRecords } from "../schema/index.js";
+import { TranscriptionModel, TranscriptionResponse } from "../transcription.js";
+import { mediaTypeExtension } from "../utils/media-type.js";
+import { ProviderShared, optionalNull } from "./shared.js";
+import { MediaInput } from "./utils/media-input.js";
+import { SpeakerTurns } from "./utils/speaker-turns.js";
+const route = MediaProtocol.identity({
+    id: "elevenlabs-transcription",
+    name: "ElevenLabs Transcription",
+    provider: "elevenlabs",
+});
+export const DEFAULT_BASE_URL = "https://api.elevenlabs.io";
+export const PATH = "/v1/speech-to-text";
+// ---------------------------------------------------------------------------
+// 2. Response schema
+// ---------------------------------------------------------------------------
+/** `type` is `word`, `spacing` (the whitespace between words), or `audio_event` (`(laughter)`). */
+const Token = Schema.Struct({
+    text: Schema.String,
+    type: Schema.String,
+    start: optionalNull(Schema.Number),
+    end: optionalNull(Schema.Number),
+    speaker_id: optionalNull(Schema.String),
+    logprob: optionalNull(Schema.Number),
+});
+const Transcript = Schema.Struct({
+    language_code: optionalNull(Schema.String),
+    text: Schema.String,
+    words: optionalNull(Schema.Array(Token)),
+    transcription_id: optionalNull(Schema.String),
+    audio_duration_secs: optionalNull(Schema.Number),
+});
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+/** Speaker turns are the only segments ElevenLabs can produce, and `num_speakers` only applies to diarization. */
+const diarizes = (request) => request.diarize === true || request.timestamps === "segment" || request.speakers !== undefined;
+const RESERVED_FORM_FIELDS = new Set([
+    "file",
+    "cloud_storage_url",
+    "source_url",
+    "model_id",
+    "language_code",
+    "diarize",
+    "num_speakers",
+]);
+const validate = (request, overlay) => {
+    // Webhook requests return 202 with no transcript; the result arrives at a configured webhook instead.
+    if (overlay.webhook === true)
+        return Effect.fail(route.unsupported("transcription.webhook", `${route.name} does not deliver to webhooks`));
+    // Separate multichannel output replaces the transcript with one transcript per channel.
+    if (overlay.use_multi_channel === true && overlay.multichannel_output_style !== "combined")
+        return Effect.fail(route.unsupported("transcription.multichannel", `${route.name} returns a single transcript; set multichannel_output_style: "combined" to merge channels`));
+    if (overlay.timestamps_granularity === "none" && (request.timestamps === "word" || diarizes(request)))
+        return Effect.fail(route.unsupported("media.timestamps", `${route.name} cannot return word timestamps or speaker turns with timestamps_granularity: "none"`));
+    return Effect.void;
+};
+const fromRequest = Effect.fn("ElevenLabsTranscription.fromRequest")(function* (request) {
+    const overlay = mergeJsonRecords(request.providerOptions, request.http?.body) ?? {};
+    yield* validate(request, overlay);
+    const form = new FormData();
+    const url = ProviderShared.mediaUrl(request.audio);
+    if (url === undefined) {
+        const extension = mediaTypeExtension(request.audio.mediaType);
+        const audio = yield* MediaInput.inlineBytes(route.id, request.audio);
+        form.append("file", MediaInput.blob(audio, request.audio.mediaType), extension === undefined ? "audio" : `audio.${extension}`);
+    }
+    MediaInput.appendFields(form, {
+        model_id: request.model.id,
+        // `cloud_storage_url` is deprecated in favor of `source_url`, which accepts any hosted audio or video URL.
+        source_url: url,
+        language_code: request.language,
+        diarize: diarizes(request) ? true : undefined,
+        num_speakers: request.speakers,
+    }, { overlay, reserved: RESERVED_FORM_FIELDS, repeatArrays: "key" });
+    return MediaProtocol.multipart(form);
+});
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+const decodeTranscript = route.decodeJson(Transcript);
+const isTimedWord = (token) => token.type === "word" && typeof token.start === "number" && typeof token.end === "number";
+/** Turn text keeps the provider's own spacing tokens, so languages written without spaces are not re-spaced. */
+const speakerTurns = (tokens) => SpeakerTurns.group(tokens.filter((token) => token.type === "word" || token.type === "spacing"), (token) => token.speaker_id).flatMap((turn) => {
+    const words = turn.filter(isTimedWord);
+    if (words.length === 0)
+        return [];
+    return [
+        {
+            text: turn
+                .map((token) => token.text)
+                .join("")
+                .trim(),
+            startSeconds: words[0].start,
+            endSeconds: words[words.length - 1].end,
+            speaker: turn[0].speaker_id ?? undefined,
+        },
+    ];
+});
+const decodeResponse = Effect.fn("ElevenLabsTranscription.decodeResponse")(function* (response, context) {
+    const output = yield* decodeTranscript(response);
+    const transcript = output.value;
+    const tokens = transcript.words ?? [];
+    const duration = transcript.audio_duration_secs ?? undefined;
+    const transcriptionID = transcript.transcription_id ?? undefined;
+    return new TranscriptionResponse({
+        text: transcript.text,
+        segments: diarizes(context.request) ? speakerTurns(tokens) : undefined,
+        words: tokens.filter(isTimedWord).map((word) => ({
+            text: word.text,
+            startSeconds: word.start,
+            endSeconds: word.end,
+            speaker: word.speaker_id ?? undefined,
+            confidence: typeof word.logprob === "number" ? Math.exp(word.logprob) : undefined,
+        })),
+        language: transcript.language_code?.toLowerCase(),
+        durationSeconds: duration,
+        usage: duration === undefined ? undefined : { type: "seconds", seconds: duration },
+        providerMetadata: transcriptionID === undefined ? undefined : { elevenlabs: { transcriptionId: transcriptionID } },
+    });
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = MediaProtocol.inline(route, {
+    unsupported: ["prompt"],
+    body: { from: fromRequest },
+    response: { decode: decodeResponse },
+});
+export const model = (input) => TranscriptionModel.fromRoute({ protocol, baseURL: DEFAULT_BASE_URL, path: PATH }, input);
+export const ElevenLabsTranscription = {
+    protocol,
+    model,
+};

package/dist/protocols/gemini.js

@@ -435,16 +435,7 @@ const mapFinishReason = (finishReason, hasToolCalls) => {
         return hasToolCalls ? "tool-calls" : "stop";
     if (finishReason === "MAX_TOKENS")
         return "length";
-    if (finishReason === "IMAGE_SAFETY" ||
-        finishReason === "RECITATION" ||
-        finishReason === "SAFETY" ||
-        finishReason === "BLOCKLIST" ||
-        finishReason === "PROHIBITED_CONTENT" ||
-        finishReason === "SPII" ||
-        finishReason === "MODEL_ARMOR" ||
-        finishReason === "IMAGE_PROHIBITED_CONTENT" ||
-        finishReason === "IMAGE_RECITATION" ||
-        finishReason === "LANGUAGE")
+    if (GeminiGenerateContent.contentFiltered(finishReason))
         return "content-filter";
     if (finishReason === "MALFORMED_FUNCTION_CALL" ||
         finishReason === "UNEXPECTED_TOOL_CALL" ||