@openrouter/sdk 0.13.27 → 0.13.28

package/esm/funcs/datasetsGetRankingsDaily.d.ts

@@ -22,6 +22,13 @@ import { Result } from "../types/fp.js";
  * reserved permaslug `other` and is always returned last within its date, so callers
  * can compute `top-50 traffic / total daily traffic` without a second request.
  *
+ * Optional filters slice the dataset. `period` (`day`/`week`/`month`) sets the time
+ * grain. `modality` and `context_bucket` narrow the exact dataset by output/input
+ * modality (or tool-calling activity) and request context length. `category` and
+ * `language_type` instead read a sampled, upsampled dataset whose `total_tokens` are
+ * weekly-grain estimates — they cannot be combined with each other or with the exact
+ * filters, and reject `period=day` with a 400.
+ *
  * Authenticate with any valid OpenRouter API key (same key used for inference).
  * Rate-limited to 30 requests/minute per key and 500 requests/day per account.
  *

package/esm/funcs/datasetsGetRankingsDaily.js

@@ -26,6 +26,13 @@ import { APIPromise } from "../types/async.js";
  * reserved permaslug `other` and is always returned last within its date, so callers
  * can compute `top-50 traffic / total daily traffic` without a second request.
  *
+ * Optional filters slice the dataset. `period` (`day`/`week`/`month`) sets the time
+ * grain. `modality` and `context_bucket` narrow the exact dataset by output/input
+ * modality (or tool-calling activity) and request context length. `category` and
+ * `language_type` instead read a sampled, upsampled dataset whose `total_tokens` are
+ * weekly-grain estimates — they cannot be combined with each other or with the exact
+ * filters, and reject `period=day` with a 400.
+ *
  * Authenticate with any valid OpenRouter API key (same key used for inference).
  * Rate-limited to 30 requests/minute per key and 500 requests/day per account.
  *
@@ -49,7 +56,12 @@ async function $do(client, request, options) {
     const body = null;
     const path = pathToFunc("/datasets/rankings-daily")();
     const query = encodeFormQuery({
+        "category": payload?.category,
+        "context_bucket": payload?.context_bucket,
         "end_date": payload?.end_date,
+        "language_type": payload?.language_type,
+        "modality": payload?.modality,
+        "period": payload?.period,
         "start_date": payload?.start_date,
     });
     const headers = new Headers(compactMap({

package/esm/funcs/sttCreateTranscriptionMultipart.js

@@ -59,6 +59,9 @@ async function $do(client, request, options) {
     if (payload.RequestBody.temperature !== undefined) {
         appendForm(body, "temperature", payload.RequestBody.temperature);
     }
+    if (payload.RequestBody["timestamp_granularities[]"] !== undefined) {
+        appendForm(body, "timestamp_granularities[]", payload.RequestBody["timestamp_granularities[]"]);
+    }
     const path = pathToFunc("/audio/transcriptions")();
     const headers = new Headers(compactMap({
         Accept: "application/json",

package/esm/lib/config.d.ts

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

package/esm/lib/config.js

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

package/esm/models/index.d.ts

@@ -467,7 +467,10 @@ export * from "./streamlogprobtoplogprob.js";
 export * from "./sttinputaudio.js";
 export * from "./sttrequest.js";
 export * from "./sttresponse.js";
+export * from "./sttsegment.js";
+export * from "./stttimestampgranularity.js";
 export * from "./sttusage.js";
+export * from "./sttword.js";
 export * from "./subagentnestedtool.js";
 export * from "./subagentreasoning.js";
 export * from "./subagentservertoolconfig.js";

package/esm/models/index.js

@@ -471,7 +471,10 @@ export * from "./streamlogprobtoplogprob.js";
 export * from "./sttinputaudio.js";
 export * from "./sttrequest.js";
 export * from "./sttresponse.js";
+export * from "./sttsegment.js";
+export * from "./stttimestampgranularity.js";
 export * from "./sttusage.js";
+export * from "./sttword.js";
 export * from "./subagentnestedtool.js";
 export * from "./subagentreasoning.js";
 export * from "./subagentservertoolconfig.js";

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

@@ -1,5 +1,5 @@
 import * as z from "zod/v4";
-import { ClosedEnum } from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 export type CreateAudioTranscriptionsMultipartGlobals = {
     /**
      * The app identifier should be your app's URL and is used as the primary identifier for rankings.
@@ -26,15 +26,21 @@ export type CreateAudioTranscriptionsMultipartFile = {
     content: ReadableStream<Uint8Array> | Blob | ArrayBuffer | Uint8Array;
 };
 /**
- * The response format. Only "json" is supported.
+ * The response format. "json" (default) returns { text, usage }; "verbose_json" additionally returns task, language, duration, and segment-level timestamps (OpenAI-compatible providers only).
  */
 export declare const ResponseFormat: {
     readonly Json: "json";
+    readonly VerboseJson: "verbose_json";
 };
 /**
- * The response format. Only "json" is supported.
+ * The response format. "json" (default) returns { text, usage }; "verbose_json" additionally returns task, language, duration, and segment-level timestamps (OpenAI-compatible providers only).
  */
-export type ResponseFormat = ClosedEnum<typeof ResponseFormat>;
+export type ResponseFormat = OpenEnum<typeof ResponseFormat>;
+export declare const TimestampGranularities: {
+    readonly Word: "word";
+    readonly Segment: "segment";
+};
+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.
@@ -49,13 +55,17 @@ export type CreateAudioTranscriptionsMultipartRequestBody = {
      */
     model: string;
     /**
-     * The response format. Only "json" is supported.
+     * The response format. "json" (default) returns { text, usage }; "verbose_json" additionally returns task, language, duration, and segment-level timestamps (OpenAI-compatible providers only).
      */
     responseFormat?: ResponseFormat | undefined;
     /**
      * The sampling temperature.
      */
     temperature?: number | undefined;
+    /**
+     * Timestamp detail levels to include when response_format is "verbose_json". "word" additionally returns word-level timestamps in the words array.
+     */
+    timestampGranularities?: Array<TimestampGranularities> | undefined;
 };
 export type CreateAudioTranscriptionsMultipartRequest = {
     /**
@@ -88,7 +98,9 @@ export type CreateAudioTranscriptionsMultipartFile$Outbound = {
 export declare const CreateAudioTranscriptionsMultipartFile$outboundSchema: z.ZodType<CreateAudioTranscriptionsMultipartFile$Outbound, CreateAudioTranscriptionsMultipartFile>;
 export declare function createAudioTranscriptionsMultipartFileToJSON(createAudioTranscriptionsMultipartFile: CreateAudioTranscriptionsMultipartFile): string;
 /** @internal */
-export declare const ResponseFormat$outboundSchema: z.ZodEnum<typeof ResponseFormat>;
+export declare const ResponseFormat$outboundSchema: z.ZodType<string, ResponseFormat>;
+/** @internal */
+export declare const TimestampGranularities$outboundSchema: z.ZodType<string, TimestampGranularities>;
 /** @internal */
 export type CreateAudioTranscriptionsMultipartRequestBody$Outbound = {
     file: CreateAudioTranscriptionsMultipartFile$Outbound | Blob;
@@ -96,6 +108,7 @@ export type CreateAudioTranscriptionsMultipartRequestBody$Outbound = {
     model: string;
     response_format?: string | undefined;
     temperature?: number | undefined;
+    "timestamp_granularities[]"?: Array<string> | undefined;
 };
 /** @internal */
 export declare const CreateAudioTranscriptionsMultipartRequestBody$outboundSchema: z.ZodType<CreateAudioTranscriptionsMultipartRequestBody$Outbound, CreateAudioTranscriptionsMultipartRequestBody>;

package/esm/models/operations/createaudiotranscriptionsmultipart.js

@@ -5,11 +5,17 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { blobLikeSchema } from "../../types/blobs.js";
+import * as openEnums from "../../types/enums.js";
 /**
- * The response format. Only "json" is supported.
+ * The response format. "json" (default) returns { text, usage }; "verbose_json" additionally returns task, language, duration, and segment-level timestamps (OpenAI-compatible providers only).
  */
 export const ResponseFormat = {
     Json: "json",
+    VerboseJson: "verbose_json",
+};
+export const TimestampGranularities = {
+    Word: "word",
+    Segment: "segment",
 };
 /** @internal */
 export const CreateAudioTranscriptionsMultipartFile$outboundSchema = z.object({
@@ -25,8 +31,9 @@ export function createAudioTranscriptionsMultipartFileToJSON(createAudioTranscri
     return JSON.stringify(CreateAudioTranscriptionsMultipartFile$outboundSchema.parse(createAudioTranscriptionsMultipartFile));
 }
 /** @internal */
-export const ResponseFormat$outboundSchema = z
-    .enum(ResponseFormat);
+export const ResponseFormat$outboundSchema = openEnums.outboundSchema(ResponseFormat);
+/** @internal */
+export const TimestampGranularities$outboundSchema = openEnums.outboundSchema(TimestampGranularities);
 /** @internal */
 export const CreateAudioTranscriptionsMultipartRequestBody$outboundSchema = z.object({
     file: z.lazy(() => CreateAudioTranscriptionsMultipartFile$outboundSchema)
@@ -35,9 +42,12 @@ export const CreateAudioTranscriptionsMultipartRequestBody$outboundSchema = z.ob
     model: z.string(),
     responseFormat: ResponseFormat$outboundSchema.optional(),
     temperature: z.number().optional(),
+    timestampGranularities: z.array(TimestampGranularities$outboundSchema)
+        .optional(),
 }).transform((v) => {
     return remap$(v, {
         responseFormat: "response_format",
+        timestampGranularities: "timestamp_granularities[]",
     });
 });
 export function createAudioTranscriptionsMultipartRequestBodyToJSON(createAudioTranscriptionsMultipartRequestBody) {

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

@@ -1,4 +1,5 @@
 import * as z from "zod/v4";
+import { OpenEnum } from "../../types/enums.js";
 export type GetRankingsDailyGlobals = {
     /**
      * The app identifier should be your app's URL and is used as the primary identifier for rankings.
@@ -20,6 +21,78 @@ export type GetRankingsDailyGlobals = {
      */
     appCategories?: string | undefined;
 };
+/**
+ * Time grain of each row. `day` (default) returns the per-UTC-day series; `week` buckets by ISO week start; `month` buckets by month start. With `category` or `language_type` only `week` (default) and `month` are available — `day` is rejected with a 400 because those datasets are aggregated weekly. For those sampled datasets `period=month` buckets each week by its week-start month, so totals are approximate at month boundaries.
+ */
+export declare const Period: {
+    readonly Day: "day";
+    readonly Week: "week";
+    readonly Month: "month";
+};
+/**
+ * Time grain of each row. `day` (default) returns the per-UTC-day series; `week` buckets by ISO week start; `month` buckets by month start. With `category` or `language_type` only `week` (default) and `month` are available — `day` is rejected with a 400 because those datasets are aggregated weekly. For those sampled datasets `period=month` buckets each week by its week-start month, so totals are approximate at month boundaries.
+ */
+export type Period = OpenEnum<typeof Period>;
+/**
+ * Restrict to models for a modality surface: `text` / `image_output` match output modality, `image` / `audio` match input modality, and `tool_calling` keeps only rows that recorded at least one tool call. Exact dataset — cannot be combined with `category` or `language_type`.
+ */
+export declare const Modality: {
+    readonly Text: "text";
+    readonly Image: "image";
+    readonly ImageOutput: "image_output";
+    readonly Audio: "audio";
+    readonly ToolCalling: "tool_calling";
+};
+/**
+ * Restrict to models for a modality surface: `text` / `image_output` match output modality, `image` / `audio` match input modality, and `tool_calling` keeps only rows that recorded at least one tool call. Exact dataset — cannot be combined with `category` or `language_type`.
+ */
+export type Modality = OpenEnum<typeof Modality>;
+/**
+ * Restrict to requests whose context length falls in this bucket (`1K`, `10K`, `100K`, `1M`, or `10M`). Exact dataset — cannot be combined with `category` or `language_type`.
+ */
+export declare const ContextBucket: {
+    readonly OneK: "1K";
+    readonly TenK: "10K";
+    readonly OneHundredK: "100K";
+    readonly OneM: "1M";
+    readonly TenM: "10M";
+};
+/**
+ * Restrict to requests whose context length falls in this bucket (`1K`, `10K`, `100K`, `1M`, or `10M`). Exact dataset — cannot be combined with `category` or `language_type`.
+ */
+export type ContextBucket = OpenEnum<typeof ContextBucket>;
+/**
+ * Restrict to a use-case category (e.g. `programming`, `roleplay`). Sourced from a sampled, upsampled dataset, so `total_tokens` is an estimate and is aggregated weekly (the trailing weekly bucket may include traffic past `end_date`). Cannot be combined with `modality`, `context_bucket`, or `language_type`.
+ */
+export declare const GetRankingsDailyCategory: {
+    readonly Programming: "programming";
+    readonly Roleplay: "roleplay";
+    readonly Marketing: "marketing";
+    readonly MarketingSeo: "marketing/seo";
+    readonly Technology: "technology";
+    readonly Science: "science";
+    readonly Translation: "translation";
+    readonly Legal: "legal";
+    readonly Finance: "finance";
+    readonly Health: "health";
+    readonly Trivia: "trivia";
+    readonly Academia: "academia";
+};
+/**
+ * Restrict to a use-case category (e.g. `programming`, `roleplay`). Sourced from a sampled, upsampled dataset, so `total_tokens` is an estimate and is aggregated weekly (the trailing weekly bucket may include traffic past `end_date`). Cannot be combined with `modality`, `context_bucket`, or `language_type`.
+ */
+export type GetRankingsDailyCategory = OpenEnum<typeof GetRankingsDailyCategory>;
+/**
+ * Restrict to natural-language or programming-language tagged activity. Sourced from a sampled, upsampled dataset, so `total_tokens` is an estimate and is aggregated weekly (the trailing weekly bucket may include traffic past `end_date`). Cannot be combined with `modality`, `context_bucket`, or `category`.
+ */
+export declare const LanguageType: {
+    readonly Natural: "natural";
+    readonly Programming: "programming";
+};
+/**
+ * Restrict to natural-language or programming-language tagged activity. Sourced from a sampled, upsampled dataset, so `total_tokens` is an estimate and is aggregated weekly (the trailing weekly bucket may include traffic past `end_date`). Cannot be combined with `modality`, `context_bucket`, or `category`.
+ */
+export type LanguageType = OpenEnum<typeof LanguageType>;
 export type GetRankingsDailyRequest = {
     /**
      * The app identifier should be your app's URL and is used as the primary identifier for rankings.
@@ -48,14 +121,49 @@ export type GetRankingsDailyRequest = {
      * End of the date window in YYYY-MM-DD (UTC), inclusive. Defaults to the most recent completed UTC day. Must be on or after 2025-01-01; earlier values are rejected with a 400.
      */
     endDate?: string | undefined;
+    /**
+     * Time grain of each row. `day` (default) returns the per-UTC-day series; `week` buckets by ISO week start; `month` buckets by month start. With `category` or `language_type` only `week` (default) and `month` are available — `day` is rejected with a 400 because those datasets are aggregated weekly. For those sampled datasets `period=month` buckets each week by its week-start month, so totals are approximate at month boundaries.
+     */
+    period?: Period | undefined;
+    /**
+     * Restrict to models for a modality surface: `text` / `image_output` match output modality, `image` / `audio` match input modality, and `tool_calling` keeps only rows that recorded at least one tool call. Exact dataset — cannot be combined with `category` or `language_type`.
+     */
+    modality?: Modality | undefined;
+    /**
+     * Restrict to requests whose context length falls in this bucket (`1K`, `10K`, `100K`, `1M`, or `10M`). Exact dataset — cannot be combined with `category` or `language_type`.
+     */
+    contextBucket?: ContextBucket | undefined;
+    /**
+     * Restrict to a use-case category (e.g. `programming`, `roleplay`). Sourced from a sampled, upsampled dataset, so `total_tokens` is an estimate and is aggregated weekly (the trailing weekly bucket may include traffic past `end_date`). Cannot be combined with `modality`, `context_bucket`, or `language_type`.
+     */
+    category?: GetRankingsDailyCategory | undefined;
+    /**
+     * Restrict to natural-language or programming-language tagged activity. Sourced from a sampled, upsampled dataset, so `total_tokens` is an estimate and is aggregated weekly (the trailing weekly bucket may include traffic past `end_date`). Cannot be combined with `modality`, `context_bucket`, or `category`.
+     */
+    languageType?: LanguageType | undefined;
 };
 /** @internal */
+export declare const Period$outboundSchema: z.ZodType<string, Period>;
+/** @internal */
+export declare const Modality$outboundSchema: z.ZodType<string, Modality>;
+/** @internal */
+export declare const ContextBucket$outboundSchema: z.ZodType<string, ContextBucket>;
+/** @internal */
+export declare const GetRankingsDailyCategory$outboundSchema: z.ZodType<string, GetRankingsDailyCategory>;
+/** @internal */
+export declare const LanguageType$outboundSchema: z.ZodType<string, LanguageType>;
+/** @internal */
 export type GetRankingsDailyRequest$Outbound = {
     "HTTP-Referer"?: string | undefined;
     appTitle?: string | undefined;
     appCategories?: string | undefined;
     start_date?: string | undefined;
     end_date?: string | undefined;
+    period?: string | undefined;
+    modality?: string | undefined;
+    context_bucket?: string | undefined;
+    category?: string | undefined;
+    language_type?: string | undefined;
 };
 /** @internal */
 export declare const GetRankingsDailyRequest$outboundSchema: z.ZodType<GetRankingsDailyRequest$Outbound, GetRankingsDailyRequest>;

package/esm/models/operations/getrankingsdaily.js

@@ -4,6 +4,71 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
+import * as openEnums from "../../types/enums.js";
+/**
+ * Time grain of each row. `day` (default) returns the per-UTC-day series; `week` buckets by ISO week start; `month` buckets by month start. With `category` or `language_type` only `week` (default) and `month` are available — `day` is rejected with a 400 because those datasets are aggregated weekly. For those sampled datasets `period=month` buckets each week by its week-start month, so totals are approximate at month boundaries.
+ */
+export const Period = {
+    Day: "day",
+    Week: "week",
+    Month: "month",
+};
+/**
+ * Restrict to models for a modality surface: `text` / `image_output` match output modality, `image` / `audio` match input modality, and `tool_calling` keeps only rows that recorded at least one tool call. Exact dataset — cannot be combined with `category` or `language_type`.
+ */
+export const Modality = {
+    Text: "text",
+    Image: "image",
+    ImageOutput: "image_output",
+    Audio: "audio",
+    ToolCalling: "tool_calling",
+};
+/**
+ * Restrict to requests whose context length falls in this bucket (`1K`, `10K`, `100K`, `1M`, or `10M`). Exact dataset — cannot be combined with `category` or `language_type`.
+ */
+export const ContextBucket = {
+    OneK: "1K",
+    TenK: "10K",
+    OneHundredK: "100K",
+    OneM: "1M",
+    TenM: "10M",
+};
+/**
+ * Restrict to a use-case category (e.g. `programming`, `roleplay`). Sourced from a sampled, upsampled dataset, so `total_tokens` is an estimate and is aggregated weekly (the trailing weekly bucket may include traffic past `end_date`). Cannot be combined with `modality`, `context_bucket`, or `language_type`.
+ */
+export const GetRankingsDailyCategory = {
+    Programming: "programming",
+    Roleplay: "roleplay",
+    Marketing: "marketing",
+    MarketingSeo: "marketing/seo",
+    Technology: "technology",
+    Science: "science",
+    Translation: "translation",
+    Legal: "legal",
+    Finance: "finance",
+    Health: "health",
+    Trivia: "trivia",
+    Academia: "academia",
+};
+/**
+ * Restrict to natural-language or programming-language tagged activity. Sourced from a sampled, upsampled dataset, so `total_tokens` is an estimate and is aggregated weekly (the trailing weekly bucket may include traffic past `end_date`). Cannot be combined with `modality`, `context_bucket`, or `category`.
+ */
+export const LanguageType = {
+    Natural: "natural",
+    Programming: "programming",
+};
+/** @internal */
+export const Period$outboundSchema = openEnums
+    .outboundSchema(Period);
+/** @internal */
+export const Modality$outboundSchema = openEnums
+    .outboundSchema(Modality);
+/** @internal */
+export const ContextBucket$outboundSchema = openEnums.outboundSchema(ContextBucket);
+/** @internal */
+export const GetRankingsDailyCategory$outboundSchema = openEnums.outboundSchema(GetRankingsDailyCategory);
+/** @internal */
+export const LanguageType$outboundSchema = openEnums.outboundSchema(LanguageType);
 /** @internal */
 export const GetRankingsDailyRequest$outboundSchema = z.object({
     httpReferer: z.string().optional(),
@@ -11,11 +76,18 @@ export const GetRankingsDailyRequest$outboundSchema = z.object({
     appCategories: z.string().optional(),
     startDate: z.string().optional(),
     endDate: z.string().optional(),
+    period: Period$outboundSchema.optional(),
+    modality: Modality$outboundSchema.optional(),
+    contextBucket: ContextBucket$outboundSchema.optional(),
+    category: GetRankingsDailyCategory$outboundSchema.optional(),
+    languageType: LanguageType$outboundSchema.optional(),
 }).transform((v) => {
     return remap$(v, {
         httpReferer: "HTTP-Referer",
         startDate: "start_date",
         endDate: "end_date",
+        contextBucket: "context_bucket",
+        languageType: "language_type",
     });
 });
 export function getRankingsDailyRequestToJSON(getRankingsDailyRequest) {

package/esm/models/speechrequest.d.ts

@@ -13,14 +13,14 @@ export type SpeechRequestProvider = {
 /**
  * Audio output format
  */
-export declare const ResponseFormatEnum: {
+export declare const SpeechRequestResponseFormat: {
     readonly Mp3: "mp3";
     readonly Pcm: "pcm";
 };
 /**
  * Audio output format
  */
-export type ResponseFormatEnum = OpenEnum<typeof ResponseFormatEnum>;
+export type SpeechRequestResponseFormat = OpenEnum<typeof SpeechRequestResponseFormat>;
 /**
  * Text-to-speech request input
  */
@@ -40,7 +40,7 @@ export type SpeechRequest = {
     /**
      * Audio output format
      */
-    responseFormat?: ResponseFormatEnum | undefined;
+    responseFormat?: SpeechRequestResponseFormat | undefined;
     /**
      * Playback speed multiplier. Only used by models that support it (e.g. OpenAI TTS). Ignored by other providers.
      */
@@ -58,7 +58,7 @@ export type SpeechRequestProvider$Outbound = {
 export declare const SpeechRequestProvider$outboundSchema: z.ZodType<SpeechRequestProvider$Outbound, SpeechRequestProvider>;
 export declare function speechRequestProviderToJSON(speechRequestProvider: SpeechRequestProvider): string;
 /** @internal */
-export declare const ResponseFormatEnum$outboundSchema: z.ZodType<string, ResponseFormatEnum>;
+export declare const SpeechRequestResponseFormat$outboundSchema: z.ZodType<string, SpeechRequestResponseFormat>;
 /** @internal */
 export type SpeechRequest$Outbound = {
     input: string;

package/esm/models/speechrequest.js

@@ -9,7 +9,7 @@ import { ProviderOptions$outboundSchema, } from "./provideroptions.js";
 /**
  * Audio output format
  */
-export const ResponseFormatEnum = {
+export const SpeechRequestResponseFormat = {
     Mp3: "mp3",
     Pcm: "pcm",
 };
@@ -21,13 +21,13 @@ export function speechRequestProviderToJSON(speechRequestProvider) {
     return JSON.stringify(SpeechRequestProvider$outboundSchema.parse(speechRequestProvider));
 }
 /** @internal */
-export const ResponseFormatEnum$outboundSchema = openEnums.outboundSchema(ResponseFormatEnum);
+export const SpeechRequestResponseFormat$outboundSchema = openEnums.outboundSchema(SpeechRequestResponseFormat);
 /** @internal */
 export const SpeechRequest$outboundSchema = z.object({
     input: z.string(),
     model: z.string(),
     provider: z.lazy(() => SpeechRequestProvider$outboundSchema).optional(),
-    responseFormat: ResponseFormatEnum$outboundSchema.default("pcm"),
+    responseFormat: SpeechRequestResponseFormat$outboundSchema.default("pcm"),
     speed: z.number().optional(),
     voice: z.string(),
 }).transform((v) => {

package/esm/models/sttrequest.d.ts

@@ -1,6 +1,8 @@
 import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
 import { ProviderOptions, ProviderOptions$Outbound } from "./provideroptions.js";
 import { STTInputAudio, STTInputAudio$Outbound } from "./sttinputaudio.js";
+import { STTTimestampGranularity } from "./stttimestampgranularity.js";
 /**
  * Provider-specific passthrough configuration
  */
@@ -10,6 +12,17 @@ export type STTRequestProvider = {
      */
     options?: ProviderOptions | undefined;
 };
+/**
+ * Output format. "json" (default) returns { text, usage }. "verbose_json" additionally returns task, language, duration, and segment-level timestamps; only supported by OpenAI-compatible providers.
+ */
+export declare const STTRequestResponseFormat: {
+    readonly Json: "json";
+    readonly VerboseJson: "verbose_json";
+};
+/**
+ * Output format. "json" (default) returns { text, usage }. "verbose_json" additionally returns task, language, duration, and segment-level timestamps; only supported by OpenAI-compatible providers.
+ */
+export type STTRequestResponseFormat = OpenEnum<typeof STTRequestResponseFormat>;
 /**
  * Speech-to-text request input. Accepts a JSON body with input_audio containing base64-encoded audio.
  */
@@ -30,10 +43,18 @@ export type STTRequest = {
      * Provider-specific passthrough configuration
      */
     provider?: STTRequestProvider | undefined;
+    /**
+     * Output format. "json" (default) returns { text, usage }. "verbose_json" additionally returns task, language, duration, and segment-level timestamps; only supported by OpenAI-compatible providers.
+     */
+    responseFormat?: STTRequestResponseFormat | undefined;
     /**
      * Sampling temperature for transcription
      */
     temperature?: number | undefined;
+    /**
+     * Timestamp detail levels to include when response_format is "verbose_json". "segment" returns segment-level timestamps; "word" additionally returns word-level timestamps in the words array. Ignored unless response_format is "verbose_json".
+     */
+    timestampGranularities?: Array<STTTimestampGranularity> | undefined;
 };
 /** @internal */
 export type STTRequestProvider$Outbound = {
@@ -43,12 +64,16 @@ export type STTRequestProvider$Outbound = {
 export declare const STTRequestProvider$outboundSchema: z.ZodType<STTRequestProvider$Outbound, STTRequestProvider>;
 export declare function sttRequestProviderToJSON(sttRequestProvider: STTRequestProvider): string;
 /** @internal */
+export declare const STTRequestResponseFormat$outboundSchema: z.ZodType<string, STTRequestResponseFormat>;
+/** @internal */
 export type STTRequest$Outbound = {
     input_audio: STTInputAudio$Outbound;
     language?: string | undefined;
     model: string;
     provider?: STTRequestProvider$Outbound | undefined;
+    response_format?: string | undefined;
     temperature?: number | undefined;
+    timestamp_granularities?: Array<string> | undefined;
 };
 /** @internal */
 export declare const STTRequest$outboundSchema: z.ZodType<STTRequest$Outbound, STTRequest>;

package/esm/models/sttrequest.js

@@ -4,8 +4,17 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
+import * as openEnums from "../types/enums.js";
 import { ProviderOptions$outboundSchema, } from "./provideroptions.js";
 import { STTInputAudio$outboundSchema, } from "./sttinputaudio.js";
+import { STTTimestampGranularity$outboundSchema, } from "./stttimestampgranularity.js";
+/**
+ * Output format. "json" (default) returns { text, usage }. "verbose_json" additionally returns task, language, duration, and segment-level timestamps; only supported by OpenAI-compatible providers.
+ */
+export const STTRequestResponseFormat = {
+    Json: "json",
+    VerboseJson: "verbose_json",
+};
 /** @internal */
 export const STTRequestProvider$outboundSchema = z.object({
     options: ProviderOptions$outboundSchema.optional(),
@@ -14,15 +23,22 @@ export function sttRequestProviderToJSON(sttRequestProvider) {
     return JSON.stringify(STTRequestProvider$outboundSchema.parse(sttRequestProvider));
 }
 /** @internal */
+export const STTRequestResponseFormat$outboundSchema = openEnums.outboundSchema(STTRequestResponseFormat);
+/** @internal */
 export const STTRequest$outboundSchema = z.object({
     inputAudio: STTInputAudio$outboundSchema,
     language: z.string().optional(),
     model: z.string(),
     provider: z.lazy(() => STTRequestProvider$outboundSchema).optional(),
+    responseFormat: STTRequestResponseFormat$outboundSchema.optional(),
     temperature: z.number().optional(),
+    timestampGranularities: z.array(STTTimestampGranularity$outboundSchema)
+        .optional(),
 }).transform((v) => {
     return remap$(v, {
         inputAudio: "input_audio",
+        responseFormat: "response_format",
+        timestampGranularities: "timestamp_granularities",
     });
 });
 export function sttRequestToJSON(sttRequest) {

package/esm/models/sttresponse.d.ts

@@ -1,11 +1,29 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { STTSegment } from "./sttsegment.js";
 import { STTUsage } from "./sttusage.js";
+import { STTWord } from "./sttword.js";
 /**
  * STT response containing transcribed text and optional usage statistics
  */
 export type STTResponse = {
+    /**
+     * Duration of the input audio in seconds, present when response_format is verbose_json
+     */
+    duration?: number | undefined;
+    /**
+     * Detected or forced language, present when response_format is verbose_json
+     */
+    language?: string | undefined;
+    /**
+     * Timestamped transcript segments, present when response_format is verbose_json
+     */
+    segments?: Array<STTSegment> | undefined;
+    /**
+     * The task performed, present when response_format is verbose_json
+     */
+    task?: string | undefined;
     /**
      * The transcribed text
      */
@@ -14,6 +32,10 @@ export type STTResponse = {
      * Aggregated usage statistics for the request
      */
     usage?: STTUsage | undefined;
+    /**
+     * Timestamped words, present when the provider returns word-level timestamps
+     */
+    words?: Array<STTWord> | undefined;
 };
 /** @internal */
 export declare const STTResponse$inboundSchema: z.ZodType<STTResponse, unknown>;

package/esm/models/sttresponse.js

@@ -4,12 +4,19 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
+import { STTSegment$inboundSchema } from "./sttsegment.js";
 import { STTUsage$inboundSchema } from "./sttusage.js";
+import { STTWord$inboundSchema } from "./sttword.js";
 /** @internal */
 export const STTResponse$inboundSchema = z
     .object({
+    duration: z.number().optional(),
+    language: z.string().optional(),
+    segments: z.array(STTSegment$inboundSchema).optional(),
+    task: z.string().optional(),
     text: z.string(),
     usage: STTUsage$inboundSchema.optional(),
+    words: z.array(STTWord$inboundSchema).optional(),
 });
 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

@@ -0,0 +1,52 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * A timestamped transcript segment, returned when response_format is verbose_json
+ */
+export type STTSegment = {
+    /**
+     * Average log probability of the segment
+     */
+    avgLogprob?: number | undefined;
+    /**
+     * Compression ratio of the segment
+     */
+    compressionRatio?: number | undefined;
+    /**
+     * Segment end time in seconds
+     */
+    end: number;
+    /**
+     * Segment index within the transcript
+     */
+    id: number;
+    /**
+     * Probability the segment contains no speech
+     */
+    noSpeechProb?: number | undefined;
+    /**
+     * Seek offset of the segment
+     */
+    seek?: number | undefined;
+    /**
+     * Segment start time in seconds
+     */
+    start: number;
+    /**
+     * Temperature used for the segment
+     */
+    temperature?: number | undefined;
+    /**
+     * Transcribed text of the segment
+     */
+    text: string;
+    /**
+     * Token IDs of the segment
+     */
+    tokens?: Array<number> | undefined;
+};
+/** @internal */
+export declare const STTSegment$inboundSchema: z.ZodType<STTSegment, unknown>;
+export declare function sttSegmentFromJSON(jsonString: string): SafeParseResult<STTSegment, SDKValidationError>;
+//# sourceMappingURL=sttsegment.d.ts.map

package/esm/models/sttsegment.js

@@ -0,0 +1,31 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 610157864a1c
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const STTSegment$inboundSchema = z
+    .object({
+    avg_logprob: z.number().optional(),
+    compression_ratio: z.number().optional(),
+    end: z.number(),
+    id: z.int(),
+    no_speech_prob: z.number().optional(),
+    seek: z.int().optional(),
+    start: z.number(),
+    temperature: z.number().optional(),
+    text: z.string(),
+    tokens: z.array(z.int()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "avg_logprob": "avgLogprob",
+        "compression_ratio": "compressionRatio",
+        "no_speech_prob": "noSpeechProb",
+    });
+});
+export function sttSegmentFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => STTSegment$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'STTSegment' from JSON`);
+}
+//# sourceMappingURL=sttsegment.js.map

package/esm/models/stttimestampgranularity.d.ts

@@ -0,0 +1,16 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+/**
+ * A timestamp detail level for verbose_json transcription responses.
+ */
+export declare const STTTimestampGranularity: {
+    readonly Word: "word";
+    readonly Segment: "segment";
+};
+/**
+ * A timestamp detail level for verbose_json transcription responses.
+ */
+export type STTTimestampGranularity = OpenEnum<typeof STTTimestampGranularity>;
+/** @internal */
+export declare const STTTimestampGranularity$outboundSchema: z.ZodType<string, STTTimestampGranularity>;
+//# sourceMappingURL=stttimestampgranularity.d.ts.map

package/esm/models/stttimestampgranularity.js

@@ -0,0 +1,15 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 506bf5060d97
+ */
+import * as openEnums from "../types/enums.js";
+/**
+ * A timestamp detail level for verbose_json transcription responses.
+ */
+export const STTTimestampGranularity = {
+    Word: "word",
+    Segment: "segment",
+};
+/** @internal */
+export const STTTimestampGranularity$outboundSchema = openEnums.outboundSchema(STTTimestampGranularity);
+//# sourceMappingURL=stttimestampgranularity.js.map

package/esm/models/sttword.d.ts

@@ -0,0 +1,24 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * A timestamped word, returned when the provider includes word-level timestamps
+ */
+export type STTWord = {
+    /**
+     * Word end time in seconds
+     */
+    end: number;
+    /**
+     * Word start time in seconds
+     */
+    start: number;
+    /**
+     * The transcribed word
+     */
+    word: string;
+};
+/** @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

@@ -0,0 +1,16 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 748744003b2c
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const STTWord$inboundSchema = z.object({
+    end: z.number(),
+    start: z.number(),
+    word: z.string(),
+});
+export function sttWordFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => STTWord$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'STTWord' from JSON`);
+}
+//# sourceMappingURL=sttword.js.map

package/esm/sdk/datasets.d.ts

@@ -47,6 +47,13 @@ export declare class Datasets extends ClientSDK {
      * reserved permaslug `other` and is always returned last within its date, so callers
      * can compute `top-50 traffic / total daily traffic` without a second request.
      *
+     * Optional filters slice the dataset. `period` (`day`/`week`/`month`) sets the time
+     * grain. `modality` and `context_bucket` narrow the exact dataset by output/input
+     * modality (or tool-calling activity) and request context length. `category` and
+     * `language_type` instead read a sampled, upsampled dataset whose `total_tokens` are
+     * weekly-grain estimates — they cannot be combined with each other or with the exact
+     * filters, and reject `period=day` with a 400.
+     *
      * Authenticate with any valid OpenRouter API key (same key used for inference).
      * Rate-limited to 30 requests/minute per key and 500 requests/day per account.
      *

package/esm/sdk/datasets.js

@@ -52,6 +52,13 @@ export class Datasets extends ClientSDK {
      * reserved permaslug `other` and is always returned last within its date, so callers
      * can compute `top-50 traffic / total daily traffic` without a second request.
      *
+     * Optional filters slice the dataset. `period` (`day`/`week`/`month`) sets the time
+     * grain. `modality` and `context_bucket` narrow the exact dataset by output/input
+     * modality (or tool-calling activity) and request context length. `category` and
+     * `language_type` instead read a sampled, upsampled dataset whose `total_tokens` are
+     * weekly-grain estimates — they cannot be combined with each other or with the exact
+     * filters, and reject `period=day` with a 400.
+     *
      * Authenticate with any valid OpenRouter API key (same key used for inference).
      * Rate-limited to 30 requests/minute per key and 500 requests/day per account.
      *

package/jsr.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrouter/sdk",
-  "version": "0.13.27",
+  "version": "0.13.28",
   "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": [
@@ -73,15 +73,15 @@
     "lint": "eslint --cache --max-warnings=0 src",
     "build": "tsc",
     "prepublishOnly": "npm run build",
-    "test": "vitest --run --project unit",
-    "test:e2e": "vitest --run --project e2e",
+    "prepare": "npm run build",
     "test:transit": "exit 0",
-    "test:watch": "vitest --watch --project unit",
+    "typecheck": "tsc --noEmit",
     "compile": "tsc",
     "postinstall": "node scripts/check-types.js || true",
-    "typecheck": "tsc --noEmit",
-    "typecheck:transit": "exit 0",
-    "prepare": "npm run build"
+    "test": "vitest --run --project unit",
+    "test:e2e": "vitest --run --project e2e",
+    "test:watch": "vitest --watch --project unit",
+    "typecheck:transit": "exit 0"
   },
   "peerDependencies": {},
   "devDependencies": {