@openrouter/sdk 1.4.4 → 1.4.5

package/esm/funcs/sttCreateTranscription.d.ts

@@ -13,7 +13,7 @@ import { Result } from "../types/fp.js";
  * Create transcription
  *
  * @remarks
- * Transcribes audio into text. Accepts base64-encoded audio input as JSON or an OpenAI-style multipart/form-data file upload, and returns the transcribed text.
+ * Transcribes audio into text. Accepts base64-encoded audio input as JSON, an OpenAI-style multipart/form-data file upload, or a URL the provider downloads directly, and returns the transcribed text.
  */
 export declare function sttCreateTranscription(client: OpenRouterCore, request: operations.CreateAudioTranscriptionsRequest, options?: RequestOptions): APIPromise<Result<models.STTResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.PaymentRequiredResponseError | errors.ForbiddenResponseError | errors.NotFoundResponseError | errors.PayloadTooLargeResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | errors.GatewayTimeoutResponseError | errors.EdgeNetworkTimeoutResponseError | errors.ProviderOverloadedResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=sttCreateTranscription.d.ts.map

package/esm/funcs/sttCreateTranscription.js

@@ -17,7 +17,7 @@ import { APIPromise } from "../types/async.js";
  * Create transcription
  *
  * @remarks
- * Transcribes audio into text. Accepts base64-encoded audio input as JSON or an OpenAI-style multipart/form-data file upload, and returns the transcribed text.
+ * Transcribes audio into text. Accepts base64-encoded audio input as JSON, an OpenAI-style multipart/form-data file upload, or a URL the provider downloads directly, and returns the transcribed text.
  */
 export function sttCreateTranscription(client, request, options) {
     return new APIPromise($do(client, request, options));

package/esm/funcs/sttCreateTranscriptionMultipart.d.ts

@@ -13,7 +13,7 @@ import { Result } from "../types/fp.js";
  * Create transcription
  *
  * @remarks
- * Transcribes audio into text. Accepts base64-encoded audio input as JSON or an OpenAI-style multipart/form-data file upload, and returns the transcribed text.
+ * Transcribes audio into text. Accepts base64-encoded audio input as JSON, an OpenAI-style multipart/form-data file upload, or a URL the provider downloads directly, and returns the transcribed text.
  */
 export declare function sttCreateTranscriptionMultipart(client: OpenRouterCore, request: operations.CreateAudioTranscriptionsMultipartRequest, options?: RequestOptions): APIPromise<Result<models.STTResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.PaymentRequiredResponseError | errors.ForbiddenResponseError | errors.NotFoundResponseError | errors.PayloadTooLargeResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | errors.GatewayTimeoutResponseError | errors.EdgeNetworkTimeoutResponseError | errors.ProviderOverloadedResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=sttCreateTranscriptionMultipart.d.ts.map

package/esm/funcs/sttCreateTranscriptionMultipart.js

@@ -20,7 +20,7 @@ import { isReadableStream } from "../types/streams.js";
  * Create transcription
  *
  * @remarks
- * Transcribes audio into text. Accepts base64-encoded audio input as JSON or an OpenAI-style multipart/form-data file upload, and returns the transcribed text.
+ * Transcribes audio into text. Accepts base64-encoded audio input as JSON, an OpenAI-style multipart/form-data file upload, or a URL the provider downloads directly, and returns the transcribed text.
  */
 export function sttCreateTranscriptionMultipart(client, request, options) {
     return new APIPromise($do(client, request, options));
@@ -32,33 +32,47 @@ async function $do(client, request, options) {
     }
     const payload = parsed.value;
     const body = new FormData();
-    if (isBlobLike(payload.RequestBody.file)) {
-        const file = payload.RequestBody.file;
-        const blob = await normalizeBlob(file);
-        const name = "name" in file ? file.name : undefined;
-        appendForm(body, "file", blob, name);
-    }
-    else if (isReadableStream(payload.RequestBody.file.content)) {
-        const buffer = await readableStreamToArrayBuffer(payload.RequestBody.file.content);
-        const contentType = getContentTypeFromFileName(payload.RequestBody.file.fileName)
-            || "application/octet-stream";
-        appendForm(body, "file", bytesToBlob(buffer, contentType), payload.RequestBody.file.fileName);
-    }
-    else {
-        const contentType = getContentTypeFromFileName(payload.RequestBody.file.fileName)
-            || "application/octet-stream";
-        appendForm(body, "file", bytesToBlob(payload.RequestBody.file.content, contentType), payload.RequestBody.file.fileName);
-    }
     appendForm(body, "model", payload.RequestBody.model);
+    if (payload.RequestBody.diarize !== undefined) {
+        appendForm(body, "diarize", payload.RequestBody.diarize);
+    }
+    if (payload.RequestBody.file !== undefined) {
+        if (isBlobLike(payload.RequestBody.file)) {
+            const file = payload.RequestBody.file;
+            const blob = await normalizeBlob(file);
+            const name = "name" in file ? file.name : undefined;
+            appendForm(body, "file", blob, name);
+        }
+        else if (isReadableStream(payload.RequestBody.file.content)) {
+            const buffer = await readableStreamToArrayBuffer(payload.RequestBody.file.content);
+            const contentType = getContentTypeFromFileName(payload.RequestBody.file.fileName)
+                || "application/octet-stream";
+            appendForm(body, "file", bytesToBlob(buffer, contentType), payload.RequestBody.file.fileName);
+        }
+        else {
+            const contentType = getContentTypeFromFileName(payload.RequestBody.file.fileName)
+                || "application/octet-stream";
+            appendForm(body, "file", bytesToBlob(payload.RequestBody.file.content, contentType), payload.RequestBody.file.fileName);
+        }
+    }
+    if (payload.RequestBody["keyterms[]"] !== undefined) {
+        appendForm(body, "keyterms[]", payload.RequestBody["keyterms[]"]);
+    }
     if (payload.RequestBody.language !== undefined) {
         appendForm(body, "language", payload.RequestBody.language);
     }
+    if (payload.RequestBody.provider !== undefined) {
+        appendForm(body, "provider", payload.RequestBody.provider);
+    }
     if (payload.RequestBody.response_format !== undefined) {
         appendForm(body, "response_format", payload.RequestBody.response_format);
     }
     if (payload.RequestBody.session_id !== undefined) {
         appendForm(body, "session_id", payload.RequestBody.session_id);
     }
+    if (payload.RequestBody.source_url !== undefined) {
+        appendForm(body, "source_url", payload.RequestBody.source_url);
+    }
     if (payload.RequestBody.temperature !== undefined) {
         appendForm(body, "temperature", payload.RequestBody.temperature);
     }

package/esm/lib/config.d.ts

@@ -50,8 +50,8 @@ export declare function serverURLFromOptions(options: SDKOptions): URL | null;
 export declare const SDK_METADATA: {
     readonly language: "typescript";
     readonly openapiDocVersion: "1.0.0";
-    readonly sdkVersion: "1.4.4";
+    readonly sdkVersion: "1.4.5";
     readonly genVersion: "2.914.0";
-    readonly userAgent: "speakeasy-sdk/typescript 1.4.4 2.914.0 1.0.0 @openrouter/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 1.4.5 2.914.0 1.0.0 @openrouter/sdk";
 };
 //# sourceMappingURL=config.d.ts.map

package/esm/lib/config.js

@@ -29,8 +29,8 @@ export function serverURLFromOptions(options) {
 export const SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0.0",
-    sdkVersion: "1.4.4",
+    sdkVersion: "1.4.5",
     genVersion: "2.914.0",
-    userAgent: "speakeasy-sdk/typescript 1.4.4 2.914.0 1.0.0 @openrouter/sdk",
+    userAgent: "speakeasy-sdk/typescript 1.4.5 2.914.0 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

package/esm/models/byokproviderslug.d.ts

@@ -41,6 +41,7 @@ export declare const BYOKProviderSlug: {
     readonly Deepseek: "deepseek";
     readonly Dekallm: "dekallm";
     readonly Digitalocean: "digitalocean";
+    readonly Elevenlabs: "elevenlabs";
     readonly Featherless: "featherless";
     readonly Fireworks: "fireworks";
     readonly FishAudio: "fish-audio";

package/esm/models/byokproviderslug.js

@@ -44,6 +44,7 @@ export const BYOKProviderSlug = {
     Deepseek: "deepseek",
     Dekallm: "dekallm",
     Digitalocean: "digitalocean",
+    Elevenlabs: "elevenlabs",
     Featherless: "featherless",
     Fireworks: "fireworks",
     FishAudio: "fish-audio",

package/esm/models/imagegenerationproviderpreferences.d.ts

@@ -137,6 +137,9 @@ export type ImageGenerationProviderPreferencesOptions = {
     digitalocean?: {
         [k: string]: any;
     } | undefined;
+    elevenlabs?: {
+        [k: string]: any;
+    } | undefined;
     enfer?: {
         [k: string]: any;
     } | undefined;
@@ -620,6 +623,9 @@ export type ImageGenerationProviderPreferencesOptions$Outbound = {
     digitalocean?: {
         [k: string]: any;
     } | undefined;
+    elevenlabs?: {
+        [k: string]: any;
+    } | undefined;
     enfer?: {
         [k: string]: any;
     } | undefined;

package/esm/models/imagegenerationproviderpreferences.js

@@ -62,6 +62,7 @@ export const ImageGenerationProviderPreferencesOptions$outboundSchema = z.object
     deepseek: z.record(z.string(), z.any()).optional(),
     dekallm: z.record(z.string(), z.any()).optional(),
     digitalocean: z.record(z.string(), z.any()).optional(),
+    elevenlabs: z.record(z.string(), z.any()).optional(),
     enfer: z.record(z.string(), z.any()).optional(),
     fakeProvider: z.record(z.string(), z.any()).optional(),
     featherless: z.record(z.string(), z.any()).optional(),

package/esm/models/index.d.ts

@@ -696,11 +696,14 @@ export * from "./streameventsresponseoutputitemadded.js";
 export * from "./streameventsresponseoutputitemdone.js";
 export * from "./streamlogprob.js";
 export * from "./streamlogprobtoplogprob.js";
+export * from "./sttentity.js";
+export * from "./sttinlineinputaudio.js";
 export * from "./sttinputaudio.js";
 export * from "./sttrequest.js";
 export * from "./sttresponse.js";
 export * from "./sttsegment.js";
 export * from "./stttimestampgranularity.js";
+export * from "./stturlinputaudio.js";
 export * from "./sttusage.js";
 export * from "./sttword.js";
 export * from "./subagentnestedtool.js";

package/esm/models/index.js

@@ -700,11 +700,14 @@ export * from "./streameventsresponseoutputitemadded.js";
 export * from "./streameventsresponseoutputitemdone.js";
 export * from "./streamlogprob.js";
 export * from "./streamlogprobtoplogprob.js";
+export * from "./sttentity.js";
+export * from "./sttinlineinputaudio.js";
 export * from "./sttinputaudio.js";
 export * from "./sttrequest.js";
 export * from "./sttresponse.js";
 export * from "./sttsegment.js";
 export * from "./stttimestampgranularity.js";
+export * from "./stturlinputaudio.js";
 export * from "./sttusage.js";
 export * from "./sttword.js";
 export * from "./subagentnestedtool.js";

package/esm/models/operations/createaudiotranscriptionsmultipart.d.ts

@@ -43,9 +43,17 @@ export declare const TimestampGranularities: {
 export type TimestampGranularities = OpenEnum<typeof TimestampGranularities>;
 export type CreateAudioTranscriptionsMultipartRequestBody = {
     /**
-     * The audio file to transcribe. The format is derived from the filename extension or the file part content type. Max 25 MB; send larger files as base64 JSON via input_audio.
+     * Label each word with the speaker who said it (words[].speaker, words[].speaker_label). Requires response_format "verbose_json" (400 otherwise); word timestamps are included even when timestamp_granularities[] omits "word". Only supported by some providers; 400 when the selected model cannot diarize.
      */
-    file: CreateAudioTranscriptionsMultipartFile | Blob;
+    diarize?: boolean | undefined;
+    /**
+     * The audio file to transcribe. The format is derived from the filename extension or the file part content type. Max 25 MB; send larger files as base64 JSON via input_audio, or by URL via source_url. Exactly one of file or source_url is required.
+     */
+    file?: CreateAudioTranscriptionsMultipartFile | Blob | undefined;
+    /**
+     * Domain terms, names, or phrases to bias recognition toward; repeat the part once per term (keyterms=... is also accepted). Only supported by some providers; 400 when the selected model cannot use keyterms.
+     */
+    keyterms?: Array<string> | undefined;
     /**
      * The language of the input audio (ISO-639-1).
      */
@@ -54,6 +62,10 @@ export type CreateAudioTranscriptionsMultipartRequestBody = {
      * The model to use for transcription.
      */
     model: string;
+    /**
+     * JSON-encoded provider preferences object, the same shape as the JSON body field: { "options": { "<provider-slug>": { ... } } }. Only options for the matched provider are forwarded. Must decode to a JSON object.
+     */
+    provider?: string | undefined;
     /**
      * The response format. "json" (default) returns { text, usage }; "verbose_json" additionally returns task, language, duration, and segment-level timestamps (OpenAI-compatible providers only).
      */
@@ -62,6 +74,10 @@ export type CreateAudioTranscriptionsMultipartRequestBody = {
      * A unique identifier for grouping related requests (e.g., a conversation or agent workflow). Used for observability grouping in Broadcast and private logging; never sent to the provider. If provided in both the request body and the x-session-id header, the body value takes precedence.
      */
     sessionId?: string | undefined;
+    /**
+     * Publicly reachable http(s) URL of the audio file, downloaded by the provider directly (no size limit on our side). The format is derived from the URL path extension. Only supported by some providers; exactly one of file or source_url is required.
+     */
+    sourceUrl?: string | undefined;
     /**
      * The sampling temperature.
      */
@@ -115,11 +131,15 @@ export declare const ResponseFormat$outboundSchema: z.ZodType<string, ResponseFo
 export declare const TimestampGranularities$outboundSchema: z.ZodType<string, TimestampGranularities>;
 /** @internal */
 export type CreateAudioTranscriptionsMultipartRequestBody$Outbound = {
-    file: CreateAudioTranscriptionsMultipartFile$Outbound | Blob;
+    diarize?: boolean | undefined;
+    file?: CreateAudioTranscriptionsMultipartFile$Outbound | Blob | undefined;
+    "keyterms[]"?: Array<string> | undefined;
     language?: string | undefined;
     model: string;
+    provider?: string | undefined;
     response_format?: string | undefined;
     session_id?: string | undefined;
+    source_url?: string | undefined;
     temperature?: number | undefined;
     "timestamp_granularities[]"?: Array<string> | undefined;
     trace?: string | undefined;

package/esm/models/operations/createaudiotranscriptionsmultipart.js

@@ -36,12 +36,16 @@ export const ResponseFormat$outboundSchema = openEnums.outboundSchema(ResponseFo
 export const TimestampGranularities$outboundSchema = openEnums.outboundSchema(TimestampGranularities);
 /** @internal */
 export const CreateAudioTranscriptionsMultipartRequestBody$outboundSchema = z.object({
+    diarize: z.boolean().optional(),
     file: z.lazy(() => CreateAudioTranscriptionsMultipartFile$outboundSchema)
-        .or(blobLikeSchema),
+        .or(blobLikeSchema).optional(),
+    keyterms: z.array(z.string()).optional(),
     language: z.string().optional(),
     model: z.string(),
+    provider: z.string().optional(),
     responseFormat: ResponseFormat$outboundSchema.optional(),
     sessionId: z.string().optional(),
+    sourceUrl: z.string().optional(),
     temperature: z.number().optional(),
     timestampGranularities: z.array(TimestampGranularities$outboundSchema)
         .optional(),
@@ -49,8 +53,10 @@ export const CreateAudioTranscriptionsMultipartRequestBody$outboundSchema = z.ob
     user: z.string().optional(),
 }).transform((v) => {
     return remap$(v, {
+        keyterms: "keyterms[]",
         responseFormat: "response_format",
         sessionId: "session_id",
+        sourceUrl: "source_url",
         timestampGranularities: "timestamp_granularities[]",
     });
 });

package/esm/models/operations/listbyokkeys.d.ts

@@ -65,6 +65,7 @@ export declare const Provider: {
     readonly Deepseek: "deepseek";
     readonly Dekallm: "dekallm";
     readonly Digitalocean: "digitalocean";
+    readonly Elevenlabs: "elevenlabs";
     readonly Featherless: "featherless";
     readonly Fireworks: "fireworks";
     readonly FishAudio: "fish-audio";

package/esm/models/operations/listbyokkeys.js

@@ -48,6 +48,7 @@ export const Provider = {
     Deepseek: "deepseek",
     Dekallm: "dekallm",
     Digitalocean: "digitalocean",
+    Elevenlabs: "elevenlabs",
     Featherless: "featherless",
     Fireworks: "fireworks",
     FishAudio: "fish-audio",

package/esm/models/providername.d.ts

@@ -38,6 +38,7 @@ export declare const ProviderName: {
     readonly DeepSeek: "DeepSeek";
     readonly DekaLLM: "DekaLLM";
     readonly DigitalOcean: "DigitalOcean";
+    readonly ElevenLabs: "ElevenLabs";
     readonly Featherless: "Featherless";
     readonly Fireworks: "Fireworks";
     readonly FishAudio: "Fish Audio";

package/esm/models/providername.js

@@ -41,6 +41,7 @@ export const ProviderName = {
     DeepSeek: "DeepSeek",
     DekaLLM: "DekaLLM",
     DigitalOcean: "DigitalOcean",
+    ElevenLabs: "ElevenLabs",
     Featherless: "Featherless",
     Fireworks: "Fireworks",
     FishAudio: "Fish Audio",

package/esm/models/provideroptions.d.ts

@@ -132,6 +132,9 @@ export type ProviderOptions = {
     digitalocean?: {
         [k: string]: any;
     } | undefined;
+    elevenlabs?: {
+        [k: string]: any;
+    } | undefined;
     enfer?: {
         [k: string]: any;
     } | undefined;
@@ -570,6 +573,9 @@ export type ProviderOptions$Outbound = {
     digitalocean?: {
         [k: string]: any;
     } | undefined;
+    elevenlabs?: {
+        [k: string]: any;
+    } | undefined;
     enfer?: {
         [k: string]: any;
     } | undefined;

package/esm/models/provideroptions.js

@@ -49,6 +49,7 @@ export const ProviderOptions$outboundSchema = z.object({
     deepseek: z.record(z.string(), z.any()).optional(),
     dekallm: z.record(z.string(), z.any()).optional(),
     digitalocean: z.record(z.string(), z.any()).optional(),
+    elevenlabs: z.record(z.string(), z.any()).optional(),
     enfer: z.record(z.string(), z.any()).optional(),
     fakeProvider: z.record(z.string(), z.any()).optional(),
     featherless: z.record(z.string(), z.any()).optional(),

package/esm/models/providerresponse.d.ts

@@ -71,6 +71,7 @@ export declare const ProviderResponseProviderName: {
     readonly DeepSeek: "DeepSeek";
     readonly DekaLLM: "DekaLLM";
     readonly DigitalOcean: "DigitalOcean";
+    readonly ElevenLabs: "ElevenLabs";
     readonly Featherless: "Featherless";
     readonly Fireworks: "Fireworks";
     readonly FishAudio: "Fish Audio";

package/esm/models/providerresponse.js

@@ -75,6 +75,7 @@ export const ProviderResponseProviderName = {
     DeepSeek: "DeepSeek",
     DekaLLM: "DekaLLM",
     DigitalOcean: "DigitalOcean",
+    ElevenLabs: "ElevenLabs",
     Featherless: "Featherless",
     Fireworks: "Fireworks",
     FishAudio: "Fish Audio",

package/esm/models/sttentity.d.ts

@@ -0,0 +1,28 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * A detected entity, returned when the provider runs entity detection
+ */
+export type STTEntity = {
+    /**
+     * Zero-based exclusive character offset of the entity end within the response-level text (not seconds)
+     */
+    endChar: number;
+    /**
+     * Zero-based character offset of the entity start within the response-level text (not seconds)
+     */
+    startChar: number;
+    /**
+     * Entity text as it appears in the transcript
+     */
+    text: string;
+    /**
+     * Provider entity type label
+     */
+    type: string;
+};
+/** @internal */
+export declare const STTEntity$inboundSchema: z.ZodType<STTEntity, unknown>;
+export declare function sttEntityFromJSON(jsonString: string): SafeParseResult<STTEntity, SDKValidationError>;
+//# sourceMappingURL=sttentity.d.ts.map

package/esm/models/sttentity.js

@@ -0,0 +1,23 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 7178554c1194
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const STTEntity$inboundSchema = z.object({
+    end_char: z.int(),
+    start_char: z.int(),
+    text: z.string(),
+    type: z.string(),
+}).transform((v) => {
+    return remap$(v, {
+        "end_char": "endChar",
+        "start_char": "startChar",
+    });
+});
+export function sttEntityFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => STTEntity$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'STTEntity' from JSON`);
+}
+//# sourceMappingURL=sttentity.js.map

package/esm/models/sttinlineinputaudio.d.ts

@@ -0,0 +1,23 @@
+import * as z from "zod/v4";
+/**
+ * Inline base64 audio input for speech-to-text
+ */
+export type STTInlineInputAudio = {
+    /**
+     * Base64-encoded audio data (raw bytes, not a data URI)
+     */
+    data: string;
+    /**
+     * Audio format (e.g., wav, mp3, flac, m4a, ogg, webm, aac). Supported formats vary by provider. "pcm" means headerless signed 16-bit little-endian mono audio at 16 kHz.
+     */
+    format: string;
+};
+/** @internal */
+export type STTInlineInputAudio$Outbound = {
+    data: string;
+    format: string;
+};
+/** @internal */
+export declare const STTInlineInputAudio$outboundSchema: z.ZodType<STTInlineInputAudio$Outbound, STTInlineInputAudio>;
+export declare function sttInlineInputAudioToJSON(sttInlineInputAudio: STTInlineInputAudio): string;
+//# sourceMappingURL=sttinlineinputaudio.d.ts.map

package/esm/models/sttinlineinputaudio.js

@@ -0,0 +1,14 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 58a47542cf73
+ */
+import * as z from "zod/v4";
+/** @internal */
+export const STTInlineInputAudio$outboundSchema = z.object({
+    data: z.string(),
+    format: z.string(),
+});
+export function sttInlineInputAudioToJSON(sttInlineInputAudio) {
+    return JSON.stringify(STTInlineInputAudio$outboundSchema.parse(sttInlineInputAudio));
+}
+//# sourceMappingURL=sttinlineinputaudio.js.map

package/esm/models/sttinputaudio.d.ts

@@ -1,22 +1,12 @@
 import * as z from "zod/v4";
+import { STTInlineInputAudio, STTInlineInputAudio$Outbound } from "./sttinlineinputaudio.js";
+import { STTUrlInputAudio, STTUrlInputAudio$Outbound } from "./stturlinputaudio.js";
 /**
- * Base64-encoded audio to transcribe
+ * Audio to transcribe: inline base64 bytes, or a URL the provider downloads directly.
  */
-export type STTInputAudio = {
-    /**
-     * Base64-encoded audio data (raw bytes, not a data URI)
-     */
-    data: string;
-    /**
-     * Audio format (e.g., wav, mp3, flac, m4a, ogg, webm, aac). Supported formats vary by provider.
-     */
-    format: string;
-};
+export type STTInputAudio = STTInlineInputAudio | STTUrlInputAudio;
 /** @internal */
-export type STTInputAudio$Outbound = {
-    data: string;
-    format: string;
-};
+export type STTInputAudio$Outbound = STTInlineInputAudio$Outbound | STTUrlInputAudio$Outbound;
 /** @internal */
 export declare const STTInputAudio$outboundSchema: z.ZodType<STTInputAudio$Outbound, STTInputAudio>;
 export declare function sttInputAudioToJSON(sttInputAudio: STTInputAudio): string;

package/esm/models/sttinputaudio.js

@@ -3,11 +3,13 @@
  * @generated-id: 2251488e7c0b
  */
 import * as z from "zod/v4";
+import { STTInlineInputAudio$outboundSchema, } from "./sttinlineinputaudio.js";
+import { STTUrlInputAudio$outboundSchema, } from "./stturlinputaudio.js";
 /** @internal */
-export const STTInputAudio$outboundSchema = z.object({
-    data: z.string(),
-    format: z.string(),
-});
+export const STTInputAudio$outboundSchema = z.union([
+    STTInlineInputAudio$outboundSchema,
+    STTUrlInputAudio$outboundSchema,
+]);
 export function sttInputAudioToJSON(sttInputAudio) {
     return JSON.stringify(STTInputAudio$outboundSchema.parse(sttInputAudio));
 }

package/esm/models/sttrequest.d.ts

@@ -25,13 +25,21 @@ export declare const STTRequestResponseFormat: {
  */
 export type STTRequestResponseFormat = OpenEnum<typeof STTRequestResponseFormat>;
 /**
- * Speech-to-text request input. Accepts a JSON body with input_audio containing base64-encoded audio.
+ * Speech-to-text request input. Accepts a JSON body with input_audio containing base64-encoded audio or a URL the provider downloads.
  */
 export type STTRequest = {
     /**
-     * Base64-encoded audio to transcribe
+     * Label each word with the speaker who said it. Speaker labels are returned on the words array (speaker, speaker_label), so response_format must be "verbose_json" (a "json" request is rejected with a 400) and word timestamps are included even when timestamp_granularities omits "word". Only supported by some providers; the request is rejected with a 400 when the selected model cannot diarize. Providers may charge extra.
+     */
+    diarize?: boolean | undefined;
+    /**
+     * Audio to transcribe: inline base64 bytes, or a URL the provider downloads directly.
      */
     inputAudio: STTInputAudio;
+    /**
+     * Domain terms, names, or phrases to bias recognition toward. Only supported by some providers; the request is rejected with a 400 when the selected model cannot use keyterms. Providers may cap the number of terms or characters per term and may charge extra.
+     */
+    keyterms?: Array<string> | undefined;
     /**
      * ISO-639-1 language code (e.g., "en", "ja"). Auto-detected if omitted.
      */
@@ -80,7 +88,9 @@ export declare function sttRequestProviderToJSON(sttRequestProvider: STTRequestP
 export declare const STTRequestResponseFormat$outboundSchema: z.ZodType<string, STTRequestResponseFormat>;
 /** @internal */
 export type STTRequest$Outbound = {
+    diarize?: boolean | undefined;
     input_audio: STTInputAudio$Outbound;
+    keyterms?: Array<string> | undefined;
     language?: string | undefined;
     model: string;
     provider?: STTRequestProvider$Outbound | undefined;

package/esm/models/sttrequest.js

@@ -27,7 +27,9 @@ export function sttRequestProviderToJSON(sttRequestProvider) {
 export const STTRequestResponseFormat$outboundSchema = openEnums.outboundSchema(STTRequestResponseFormat);
 /** @internal */
 export const STTRequest$outboundSchema = z.object({
+    diarize: z.boolean().optional(),
     inputAudio: STTInputAudio$outboundSchema,
+    keyterms: z.array(z.string()).optional(),
     language: z.string().optional(),
     model: z.string(),
     provider: z.lazy(() => STTRequestProvider$outboundSchema).optional(),

package/esm/models/sttresponse.d.ts

@@ -1,6 +1,7 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { STTEntity } from "./sttentity.js";
 import { STTSegment } from "./sttsegment.js";
 import { STTUsage } from "./sttusage.js";
 import { STTWord } from "./sttword.js";
@@ -16,10 +17,18 @@ export type STTResponse = {
      * Duration of the input audio in seconds, present when response_format is verbose_json
      */
     duration?: number | undefined;
+    /**
+     * Detected entities with character offsets into text, present when the provider runs entity detection
+     */
+    entities?: Array<STTEntity> | undefined;
     /**
      * Detected or forced language, present when response_format is verbose_json
      */
     language?: string | undefined;
+    /**
+     * Provider confidence in the detected language from 0 to 1, present when response_format is verbose_json and the provider scores language detection
+     */
+    languageConfidence?: number | undefined;
     /**
      * Timestamped transcript segments, present when response_format is verbose_json
      */

package/esm/models/sttresponse.js

@@ -3,7 +3,9 @@
  * @generated-id: 383a6e21047b
  */
 import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
+import { STTEntity$inboundSchema } from "./sttentity.js";
 import { STTSegment$inboundSchema } from "./sttsegment.js";
 import { STTUsage$inboundSchema } from "./sttusage.js";
 import { STTWord$inboundSchema } from "./sttword.js";
@@ -12,12 +14,18 @@ export const STTResponse$inboundSchema = z
     .object({
     confidence: z.number().optional(),
     duration: z.number().optional(),
+    entities: z.array(STTEntity$inboundSchema).optional(),
     language: z.string().optional(),
+    language_confidence: z.number().optional(),
     segments: z.array(STTSegment$inboundSchema).optional(),
     task: z.string().optional(),
     text: z.string(),
     usage: STTUsage$inboundSchema.optional(),
     words: z.array(STTWord$inboundSchema).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "language_confidence": "languageConfidence",
+    });
 });
 export function sttResponseFromJSON(jsonString) {
     return safeParse(jsonString, (x) => STTResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'STTResponse' from JSON`);

package/esm/models/sttsegment.d.ts

@@ -9,6 +9,10 @@ export type STTSegment = {
      * Average log probability of the segment
      */
     avgLogprob?: number | undefined;
+    /**
+     * Zero-based audio channel index for the segment, present when the provider transcribes channels separately
+     */
+    channel?: number | undefined;
     /**
      * Compression ratio of the segment
      */
@@ -33,6 +37,10 @@ export type STTSegment = {
      * Speaker index for the segment, present when the provider returns diarization data
      */
     speaker?: number | undefined;
+    /**
+     * Provider speaker label for the segment, present when the provider labels speakers with a string
+     */
+    speakerLabel?: string | undefined;
     /**
      * Segment start time in seconds
      */

package/esm/models/sttsegment.js

@@ -9,12 +9,14 @@ import { safeParse } from "../lib/schemas.js";
 export const STTSegment$inboundSchema = z
     .object({
     avg_logprob: z.number().optional(),
+    channel: z.int().optional(),
     compression_ratio: z.number().optional(),
     end: z.number(),
     id: z.int(),
     no_speech_prob: z.number().optional(),
     seek: z.int().optional(),
     speaker: z.int().optional(),
+    speaker_label: z.string().optional(),
     start: z.number(),
     temperature: z.number().optional(),
     text: z.string(),
@@ -24,6 +26,7 @@ export const STTSegment$inboundSchema = z
         "avg_logprob": "avgLogprob",
         "compression_ratio": "compressionRatio",
         "no_speech_prob": "noSpeechProb",
+        "speaker_label": "speakerLabel",
     });
 });
 export function sttSegmentFromJSON(jsonString) {

package/esm/models/stturlinputaudio.d.ts

@@ -0,0 +1,23 @@
+import * as z from "zod/v4";
+/**
+ * Audio input fetched by the provider from a URL
+ */
+export type STTUrlInputAudio = {
+    /**
+     * Audio format of the file at the URL. Defaults to the extension of the URL path; required when the path has no extension.
+     */
+    format?: string | undefined;
+    /**
+     * Publicly reachable http(s) URL of the audio file. The provider downloads it directly, so the inline upload size limit does not apply. Only supported by some providers.
+     */
+    url: string;
+};
+/** @internal */
+export type STTUrlInputAudio$Outbound = {
+    format?: string | undefined;
+    url: string;
+};
+/** @internal */
+export declare const STTUrlInputAudio$outboundSchema: z.ZodType<STTUrlInputAudio$Outbound, STTUrlInputAudio>;
+export declare function sttUrlInputAudioToJSON(sttUrlInputAudio: STTUrlInputAudio): string;
+//# sourceMappingURL=stturlinputaudio.d.ts.map

package/esm/models/stturlinputaudio.js

@@ -0,0 +1,14 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: d7757cc949dd
+ */
+import * as z from "zod/v4";
+/** @internal */
+export const STTUrlInputAudio$outboundSchema = z.object({
+    format: z.string().optional(),
+    url: z.string(),
+});
+export function sttUrlInputAudioToJSON(sttUrlInputAudio) {
+    return JSON.stringify(STTUrlInputAudio$outboundSchema.parse(sttUrlInputAudio));
+}
+//# sourceMappingURL=stturlinputaudio.js.map

package/esm/models/sttword.d.ts

@@ -1,10 +1,26 @@
 import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Kind of entry; omitted or "word" for spoken words, "audio_event" for non-speech sounds the provider tags with timestamps
+ */
+export declare const STTWordType: {
+    readonly Word: "word";
+    readonly AudioEvent: "audio_event";
+};
+/**
+ * Kind of entry; omitted or "word" for spoken words, "audio_event" for non-speech sounds the provider tags with timestamps
+ */
+export type STTWordType = OpenEnum<typeof STTWordType>;
 /**
  * A timestamped word, returned when the provider includes word-level timestamps
  */
 export type STTWord = {
+    /**
+     * Zero-based audio channel index for the word, present when the provider transcribes channels separately
+     */
+    channel?: number | undefined;
     /**
      * Provider confidence for the word from 0 to 1, present when the provider returns per-word confidence
      */
@@ -17,16 +33,26 @@ export type STTWord = {
      * Speaker index for the word, present when the provider returns diarization data
      */
     speaker?: number | undefined;
+    /**
+     * Provider speaker label for the word, present when the provider labels speakers with a string
+     */
+    speakerLabel?: string | undefined;
     /**
      * Word start time in seconds
      */
     start: number;
     /**
-     * The transcribed word
+     * Kind of entry; omitted or "word" for spoken words, "audio_event" for non-speech sounds the provider tags with timestamps
+     */
+    type?: STTWordType | undefined;
+    /**
+     * The transcribed word, or the event tag such as "(laughter)" when type is audio_event
      */
     word: string;
 };
 /** @internal */
+export declare const STTWordType$inboundSchema: z.ZodType<STTWordType, unknown>;
+/** @internal */
 export declare const STTWord$inboundSchema: z.ZodType<STTWord, unknown>;
 export declare function sttWordFromJSON(jsonString: string): SafeParseResult<STTWord, SDKValidationError>;
 //# sourceMappingURL=sttword.d.ts.map

package/esm/models/sttword.js

@@ -3,14 +3,32 @@
  * @generated-id: 748744003b2c
  */
 import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+/**
+ * Kind of entry; omitted or "word" for spoken words, "audio_event" for non-speech sounds the provider tags with timestamps
+ */
+export const STTWordType = {
+    Word: "word",
+    AudioEvent: "audio_event",
+};
+/** @internal */
+export const STTWordType$inboundSchema = openEnums.inboundSchema(STTWordType);
 /** @internal */
 export const STTWord$inboundSchema = z.object({
+    channel: z.int().optional(),
     confidence: z.number().optional(),
     end: z.number(),
     speaker: z.int().optional(),
+    speaker_label: z.string().optional(),
     start: z.number(),
+    type: STTWordType$inboundSchema.optional(),
     word: z.string(),
+}).transform((v) => {
+    return remap$(v, {
+        "speaker_label": "speakerLabel",
+    });
 });
 export function sttWordFromJSON(jsonString) {
     return safeParse(jsonString, (x) => STTWord$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'STTWord' from JSON`);

package/esm/models/videogenerationrequest.d.ts

@@ -154,6 +154,9 @@ export type VideoGenerationRequestOptions = {
     digitalocean?: {
         [k: string]: any;
     } | undefined;
+    elevenlabs?: {
+        [k: string]: any;
+    } | undefined;
     enfer?: {
         [k: string]: any;
     } | undefined;
@@ -688,6 +691,9 @@ export type VideoGenerationRequestOptions$Outbound = {
     digitalocean?: {
         [k: string]: any;
     } | undefined;
+    elevenlabs?: {
+        [k: string]: any;
+    } | undefined;
     enfer?: {
         [k: string]: any;
     } | undefined;

package/esm/models/videogenerationrequest.js

@@ -82,6 +82,7 @@ export const VideoGenerationRequestOptions$outboundSchema = z.object({
     deepseek: z.record(z.string(), z.any()).optional(),
     dekallm: z.record(z.string(), z.any()).optional(),
     digitalocean: z.record(z.string(), z.any()).optional(),
+    elevenlabs: z.record(z.string(), z.any()).optional(),
     enfer: z.record(z.string(), z.any()).optional(),
     fakeProvider: z.record(z.string(), z.any()).optional(),
     featherless: z.record(z.string(), z.any()).optional(),

package/esm/sdk/stt.d.ts

@@ -6,14 +6,14 @@ export declare class STT extends ClientSDK {
      * Create transcription
      *
      * @remarks
-     * Transcribes audio into text. Accepts base64-encoded audio input as JSON or an OpenAI-style multipart/form-data file upload, and returns the transcribed text.
+     * Transcribes audio into text. Accepts base64-encoded audio input as JSON, an OpenAI-style multipart/form-data file upload, or a URL the provider downloads directly, and returns the transcribed text.
      */
     createTranscription(request: operations.CreateAudioTranscriptionsRequest, options?: RequestOptions): Promise<models.STTResponse>;
     /**
      * Create transcription
      *
      * @remarks
-     * Transcribes audio into text. Accepts base64-encoded audio input as JSON or an OpenAI-style multipart/form-data file upload, and returns the transcribed text.
+     * Transcribes audio into text. Accepts base64-encoded audio input as JSON, an OpenAI-style multipart/form-data file upload, or a URL the provider downloads directly, and returns the transcribed text.
      */
     createTranscriptionMultipart(request: operations.CreateAudioTranscriptionsMultipartRequest, options?: RequestOptions): Promise<models.STTResponse>;
 }

package/esm/sdk/stt.js

@@ -11,7 +11,7 @@ export class STT extends ClientSDK {
      * Create transcription
      *
      * @remarks
-     * Transcribes audio into text. Accepts base64-encoded audio input as JSON or an OpenAI-style multipart/form-data file upload, and returns the transcribed text.
+     * Transcribes audio into text. Accepts base64-encoded audio input as JSON, an OpenAI-style multipart/form-data file upload, or a URL the provider downloads directly, and returns the transcribed text.
      */
     async createTranscription(request, options) {
         return unwrapAsync(sttCreateTranscription(this, request, options));
@@ -20,7 +20,7 @@ export class STT extends ClientSDK {
      * Create transcription
      *
      * @remarks
-     * Transcribes audio into text. Accepts base64-encoded audio input as JSON or an OpenAI-style multipart/form-data file upload, and returns the transcribed text.
+     * Transcribes audio into text. Accepts base64-encoded audio input as JSON, an OpenAI-style multipart/form-data file upload, or a URL the provider downloads directly, and returns the transcribed text.
      */
     async createTranscriptionMultipart(request, options) {
         return unwrapAsync(sttCreateTranscriptionMultipart(this, request, options));

package/jsr.json

@@ -2,7 +2,7 @@
 
 {
   "name": "@openrouter/sdk",
-  "version": "1.4.4",
+  "version": "1.4.5",
   "exports": {
     ".": "./src/index.ts",    
     "./models/errors": "./src/models/errors/index.ts",    

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrouter/sdk",
-  "version": "1.4.4",
+  "version": "1.4.5",
   "author": "OpenRouter",
   "description": "The OpenRouter TypeScript SDK is a type-safe toolkit for building AI applications with access to 400+ language models through a unified API.",
   "keywords": [
@@ -21,8 +21,8 @@
   "license": "Apache-2.0",
   "packageManager": "pnpm@10.22.0",
   "publishConfig": {
-    "access": "public",
-    "provenance": true
+    "provenance": true,
+    "access": "public"
   },
   "type": "module",
   "main": "./esm/index.js",
@@ -73,15 +73,15 @@
     "lint": "eslint --cache --max-warnings=0 src",
     "build": "tsc && node scripts/unbarrel-imports.js",
     "prepublishOnly": "npm run build",
-    "typecheck:transit": "exit 0",
+    "compile": "tsc && node scripts/unbarrel-imports.js",
     "postinstall": "node scripts/check-types.js || true",
     "prepare": "npm run build",
     "test": "vitest --run --project unit",
     "test:transit": "exit 0",
     "test:watch": "vitest --watch --project unit",
-    "compile": "tsc && node scripts/unbarrel-imports.js",
     "test:e2e": "vitest --run --project e2e",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "typecheck:transit": "exit 0"
   },
   "peerDependencies": {