@openrouter/sdk 0.10.2 → 0.12.0

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

@@ -0,0 +1,175 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import * as models from "../index.js";
+export type CreateRerankGlobals = {
+    /**
+     * The app identifier should be your app's URL and is used as the primary identifier for rankings.
+     *
+     * @remarks
+     * This is used to track API usage per application.
+     */
+    httpReferer?: string | undefined;
+    /**
+     * The app display name allows you to customize how your app appears in OpenRouter's dashboard.
+     *
+     * @remarks
+     */
+    appTitle?: string | undefined;
+    /**
+     * Comma-separated list of app categories (e.g. "cli-agent,cloud-agent"). Used for marketplace rankings.
+     *
+     * @remarks
+     */
+    appCategories?: string | undefined;
+};
+/**
+ * Rerank request input
+ */
+export type CreateRerankRequestBody = {
+    /**
+     * The list of documents to rerank
+     */
+    documents: Array<string>;
+    /**
+     * The rerank model to use
+     */
+    model: string;
+    provider?: models.ProviderPreferences | null | undefined;
+    /**
+     * The search query to rerank documents against
+     */
+    query: string;
+    /**
+     * Number of most relevant documents to return
+     */
+    topN?: number | undefined;
+};
+export type CreateRerankRequest = {
+    /**
+     * The app identifier should be your app's URL and is used as the primary identifier for rankings.
+     *
+     * @remarks
+     * This is used to track API usage per application.
+     */
+    httpReferer?: string | undefined;
+    /**
+     * The app display name allows you to customize how your app appears in OpenRouter's dashboard.
+     *
+     * @remarks
+     */
+    appTitle?: string | undefined;
+    /**
+     * Comma-separated list of app categories (e.g. "cli-agent,cloud-agent"). Used for marketplace rankings.
+     *
+     * @remarks
+     */
+    appCategories?: string | undefined;
+    requestBody: CreateRerankRequestBody;
+};
+/**
+ * The document object containing the original text
+ */
+export type Document = {
+    /**
+     * The document text
+     */
+    text: string;
+};
+/**
+ * A single rerank result
+ */
+export type Result = {
+    /**
+     * The document object containing the original text
+     */
+    document: Document;
+    /**
+     * Index of the document in the original input list
+     */
+    index: number;
+    /**
+     * Relevance score of the document to the query
+     */
+    relevanceScore: number;
+};
+/**
+ * Usage statistics
+ */
+export type CreateRerankUsage = {
+    /**
+     * Cost of the request in credits
+     */
+    cost?: number | undefined;
+    /**
+     * Number of search units consumed (Cohere billing)
+     */
+    searchUnits?: number | undefined;
+    /**
+     * Total number of tokens used
+     */
+    totalTokens?: number | undefined;
+};
+/**
+ * Rerank response containing ranked results
+ */
+export type CreateRerankResponseBody = {
+    /**
+     * Unique identifier for the rerank response (ORID format)
+     */
+    id?: string | undefined;
+    /**
+     * The model used for reranking
+     */
+    model: string;
+    /**
+     * The provider that served the rerank request
+     */
+    provider?: string | undefined;
+    /**
+     * List of rerank results sorted by relevance
+     */
+    results: Array<Result>;
+    /**
+     * Usage statistics
+     */
+    usage?: CreateRerankUsage | undefined;
+};
+export type CreateRerankResponse = CreateRerankResponseBody | string;
+/** @internal */
+export type CreateRerankRequestBody$Outbound = {
+    documents: Array<string>;
+    model: string;
+    provider?: models.ProviderPreferences$Outbound | null | undefined;
+    query: string;
+    top_n?: number | undefined;
+};
+/** @internal */
+export declare const CreateRerankRequestBody$outboundSchema: z.ZodType<CreateRerankRequestBody$Outbound, CreateRerankRequestBody>;
+export declare function createRerankRequestBodyToJSON(createRerankRequestBody: CreateRerankRequestBody): string;
+/** @internal */
+export type CreateRerankRequest$Outbound = {
+    "HTTP-Referer"?: string | undefined;
+    appTitle?: string | undefined;
+    appCategories?: string | undefined;
+    RequestBody: CreateRerankRequestBody$Outbound;
+};
+/** @internal */
+export declare const CreateRerankRequest$outboundSchema: z.ZodType<CreateRerankRequest$Outbound, CreateRerankRequest>;
+export declare function createRerankRequestToJSON(createRerankRequest: CreateRerankRequest): string;
+/** @internal */
+export declare const Document$inboundSchema: z.ZodType<Document, unknown>;
+export declare function documentFromJSON(jsonString: string): SafeParseResult<Document, SDKValidationError>;
+/** @internal */
+export declare const Result$inboundSchema: z.ZodType<Result, unknown>;
+export declare function resultFromJSON(jsonString: string): SafeParseResult<Result, SDKValidationError>;
+/** @internal */
+export declare const CreateRerankUsage$inboundSchema: z.ZodType<CreateRerankUsage, unknown>;
+export declare function createRerankUsageFromJSON(jsonString: string): SafeParseResult<CreateRerankUsage, SDKValidationError>;
+/** @internal */
+export declare const CreateRerankResponseBody$inboundSchema: z.ZodType<CreateRerankResponseBody, unknown>;
+export declare function createRerankResponseBodyFromJSON(jsonString: string): SafeParseResult<CreateRerankResponseBody, SDKValidationError>;
+/** @internal */
+export declare const CreateRerankResponse$inboundSchema: z.ZodType<CreateRerankResponse, unknown>;
+export declare function createRerankResponseFromJSON(jsonString: string): SafeParseResult<CreateRerankResponse, SDKValidationError>;
+//# sourceMappingURL=creatererank.d.ts.map

package/esm/models/operations/creatererank.js

@@ -0,0 +1,89 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: e1de55b94363
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import * as models from "../index.js";
+/** @internal */
+export const CreateRerankRequestBody$outboundSchema = z.object({
+    documents: z.array(z.string()),
+    model: z.string(),
+    provider: z.nullable(models.ProviderPreferences$outboundSchema).optional(),
+    query: z.string(),
+    topN: z.int().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        topN: "top_n",
+    });
+});
+export function createRerankRequestBodyToJSON(createRerankRequestBody) {
+    return JSON.stringify(CreateRerankRequestBody$outboundSchema.parse(createRerankRequestBody));
+}
+/** @internal */
+export const CreateRerankRequest$outboundSchema = z.object({
+    httpReferer: z.string().optional(),
+    appTitle: z.string().optional(),
+    appCategories: z.string().optional(),
+    requestBody: z.lazy(() => CreateRerankRequestBody$outboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        httpReferer: "HTTP-Referer",
+        requestBody: "RequestBody",
+    });
+});
+export function createRerankRequestToJSON(createRerankRequest) {
+    return JSON.stringify(CreateRerankRequest$outboundSchema.parse(createRerankRequest));
+}
+/** @internal */
+export const Document$inboundSchema = z.object({
+    text: z.string(),
+});
+export function documentFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Document$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Document' from JSON`);
+}
+/** @internal */
+export const Result$inboundSchema = z.object({
+    document: z.lazy(() => Document$inboundSchema),
+    index: z.int(),
+    relevance_score: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        "relevance_score": "relevanceScore",
+    });
+});
+export function resultFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Result$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Result' from JSON`);
+}
+/** @internal */
+export const CreateRerankUsage$inboundSchema = z.object({
+    cost: z.number().optional(),
+    search_units: z.int().optional(),
+    total_tokens: z.int().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "search_units": "searchUnits",
+        "total_tokens": "totalTokens",
+    });
+});
+export function createRerankUsageFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CreateRerankUsage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateRerankUsage' from JSON`);
+}
+/** @internal */
+export const CreateRerankResponseBody$inboundSchema = z.object({
+    id: z.string().optional(),
+    model: z.string(),
+    provider: z.string().optional(),
+    results: z.array(z.lazy(() => Result$inboundSchema)),
+    usage: z.lazy(() => CreateRerankUsage$inboundSchema).optional(),
+});
+export function createRerankResponseBodyFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CreateRerankResponseBody$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateRerankResponseBody' from JSON`);
+}
+/** @internal */
+export const CreateRerankResponse$inboundSchema = z.union([z.lazy(() => CreateRerankResponseBody$inboundSchema), z.string()]);
+export function createRerankResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CreateRerankResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateRerankResponse' from JSON`);
+}
+//# sourceMappingURL=creatererank.js.map

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

@@ -44,7 +44,7 @@ export type CreateResponsesRequest = {
      * @remarks
      */
     appCategories?: string | undefined;
-    openResponsesRequest: models.OpenResponsesRequest;
+    responsesRequest: models.ResponsesRequest;
 };
 /**
  * Successful response
@@ -53,15 +53,15 @@ export type CreateResponsesResponseBody = {
     /**
      * Union of all possible event types emitted during response streaming
      */
-    data: models.OpenResponsesStreamEvent;
+    data: models.StreamEvents;
 };
-export type CreateResponsesResponse = models.OpenResponsesNonStreamingResponse | EventStream<models.OpenResponsesStreamEvent>;
+export type CreateResponsesResponse = models.OpenResponsesResult | EventStream<models.StreamEvents>;
 /** @internal */
 export type CreateResponsesRequest$Outbound = {
     "HTTP-Referer"?: string | undefined;
     appTitle?: string | undefined;
     appCategories?: string | undefined;
-    OpenResponsesRequest: models.OpenResponsesRequest$Outbound;
+    ResponsesRequest: models.ResponsesRequest$Outbound;
 };
 /** @internal */
 export declare const CreateResponsesRequest$outboundSchema: z.ZodType<CreateResponsesRequest$Outbound, CreateResponsesRequest>;

package/esm/models/operations/createresponses.js

@@ -12,11 +12,11 @@ export const CreateResponsesRequest$outboundSchema = z.object({
     httpReferer: z.string().optional(),
     appTitle: z.string().optional(),
     appCategories: z.string().optional(),
-    openResponsesRequest: models.OpenResponsesRequest$outboundSchema,
+    responsesRequest: models.ResponsesRequest$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         httpReferer: "HTTP-Referer",
-        openResponsesRequest: "OpenResponsesRequest",
+        responsesRequest: "ResponsesRequest",
     });
 });
 export function createResponsesRequestToJSON(createResponsesRequest) {
@@ -36,20 +36,21 @@ export const CreateResponsesResponseBody$inboundSchema = z.object({
             });
             return z.NEVER;
         }
-    }).pipe(models.OpenResponsesStreamEvent$inboundSchema),
+    }).pipe(models.StreamEvents$inboundSchema),
 });
 export function createResponsesResponseBodyFromJSON(jsonString) {
     return safeParse(jsonString, (x) => CreateResponsesResponseBody$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateResponsesResponseBody' from JSON`);
 }
 /** @internal */
 export const CreateResponsesResponse$inboundSchema = z.union([
-    models.OpenResponsesNonStreamingResponse$inboundSchema,
+    models.OpenResponsesResult$inboundSchema,
     z.custom(x => x instanceof ReadableStream)
         .transform(stream => {
         return new EventStream(stream, rawEvent => {
             if (rawEvent.data === "[DONE]")
-                return { done: true };
+                return { done: true, value: undefined };
             return {
+                done: false,
                 value: z.lazy(() => CreateResponsesResponseBody$inboundSchema).parse(rawEvent)?.data,
             };
         });

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

@@ -0,0 +1,56 @@
+import * as z from "zod/v4";
+import * as models from "../index.js";
+export type CreateVideosGlobals = {
+    /**
+     * The app identifier should be your app's URL and is used as the primary identifier for rankings.
+     *
+     * @remarks
+     * This is used to track API usage per application.
+     */
+    httpReferer?: string | undefined;
+    /**
+     * The app display name allows you to customize how your app appears in OpenRouter's dashboard.
+     *
+     * @remarks
+     */
+    appTitle?: string | undefined;
+    /**
+     * Comma-separated list of app categories (e.g. "cli-agent,cloud-agent"). Used for marketplace rankings.
+     *
+     * @remarks
+     */
+    appCategories?: string | undefined;
+};
+export type CreateVideosRequest = {
+    /**
+     * The app identifier should be your app's URL and is used as the primary identifier for rankings.
+     *
+     * @remarks
+     * This is used to track API usage per application.
+     */
+    httpReferer?: string | undefined;
+    /**
+     * The app display name allows you to customize how your app appears in OpenRouter's dashboard.
+     *
+     * @remarks
+     */
+    appTitle?: string | undefined;
+    /**
+     * Comma-separated list of app categories (e.g. "cli-agent,cloud-agent"). Used for marketplace rankings.
+     *
+     * @remarks
+     */
+    appCategories?: string | undefined;
+    videoGenerationRequest: models.VideoGenerationRequest;
+};
+/** @internal */
+export type CreateVideosRequest$Outbound = {
+    "HTTP-Referer"?: string | undefined;
+    appTitle?: string | undefined;
+    appCategories?: string | undefined;
+    VideoGenerationRequest: models.VideoGenerationRequest$Outbound;
+};
+/** @internal */
+export declare const CreateVideosRequest$outboundSchema: z.ZodType<CreateVideosRequest$Outbound, CreateVideosRequest>;
+export declare function createVideosRequestToJSON(createVideosRequest: CreateVideosRequest): string;
+//# sourceMappingURL=createvideos.d.ts.map

package/esm/models/operations/createvideos.js

@@ -0,0 +1,23 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 06dc92996e18
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as models from "../index.js";
+/** @internal */
+export const CreateVideosRequest$outboundSchema = z.object({
+    httpReferer: z.string().optional(),
+    appTitle: z.string().optional(),
+    appCategories: z.string().optional(),
+    videoGenerationRequest: models.VideoGenerationRequest$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        httpReferer: "HTTP-Referer",
+        videoGenerationRequest: "VideoGenerationRequest",
+    });
+});
+export function createVideosRequestToJSON(createVideosRequest) {
+    return JSON.stringify(CreateVideosRequest$outboundSchema.parse(createVideosRequest));
+}
+//# sourceMappingURL=createvideos.js.map

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

@@ -1,6 +1,4 @@
 import * as z from "zod/v4";
-import { Result as SafeParseResult } from "../../types/fp.js";
-import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 export type DeleteGuardrailGlobals = {
     /**
      * The app identifier should be your app's URL and is used as the primary identifier for rankings.
@@ -47,15 +45,6 @@ export type DeleteGuardrailRequest = {
      */
     id: string;
 };
-/**
- * Guardrail deleted successfully
- */
-export type DeleteGuardrailResponse = {
-    /**
-     * Confirmation that the guardrail was deleted
-     */
-    deleted: true;
-};
 /** @internal */
 export type DeleteGuardrailRequest$Outbound = {
     "HTTP-Referer"?: string | undefined;
@@ -66,7 +55,4 @@ export type DeleteGuardrailRequest$Outbound = {
 /** @internal */
 export declare const DeleteGuardrailRequest$outboundSchema: z.ZodType<DeleteGuardrailRequest$Outbound, DeleteGuardrailRequest>;
 export declare function deleteGuardrailRequestToJSON(deleteGuardrailRequest: DeleteGuardrailRequest): string;
-/** @internal */
-export declare const DeleteGuardrailResponse$inboundSchema: z.ZodType<DeleteGuardrailResponse, unknown>;
-export declare function deleteGuardrailResponseFromJSON(jsonString: string): SafeParseResult<DeleteGuardrailResponse, SDKValidationError>;
 //# sourceMappingURL=deleteguardrail.d.ts.map

package/esm/models/operations/deleteguardrail.js

@@ -4,7 +4,6 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
-import { safeParse } from "../../lib/schemas.js";
 /** @internal */
 export const DeleteGuardrailRequest$outboundSchema = z.object({
     httpReferer: z.string().optional(),
@@ -19,11 +18,4 @@ export const DeleteGuardrailRequest$outboundSchema = z.object({
 export function deleteGuardrailRequestToJSON(deleteGuardrailRequest) {
     return JSON.stringify(DeleteGuardrailRequest$outboundSchema.parse(deleteGuardrailRequest));
 }
-/** @internal */
-export const DeleteGuardrailResponse$inboundSchema = z.object({
-    deleted: z.literal(true),
-});
-export function deleteGuardrailResponseFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => DeleteGuardrailResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'DeleteGuardrailResponse' from JSON`);
-}
 //# sourceMappingURL=deleteguardrail.js.map

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

@@ -39,14 +39,14 @@ export type ExchangeAuthCodeForAPIKeyRequestBody = {
      * The authorization code received from the OAuth redirect
      */
     code: string;
-    /**
-     * The code verifier if code_challenge was used in the authorization request
-     */
-    codeVerifier?: string | undefined;
     /**
      * The method used to generate the code challenge
      */
     codeChallengeMethod?: ExchangeAuthCodeForAPIKeyCodeChallengeMethod | null | undefined;
+    /**
+     * The code verifier if code_challenge was used in the authorization request
+     */
+    codeVerifier?: string | undefined;
 };
 export type ExchangeAuthCodeForAPIKeyRequest = {
     /**
@@ -88,8 +88,8 @@ export declare const ExchangeAuthCodeForAPIKeyCodeChallengeMethod$outboundSchema
 /** @internal */
 export type ExchangeAuthCodeForAPIKeyRequestBody$Outbound = {
     code: string;
-    code_verifier?: string | undefined;
     code_challenge_method?: string | null | undefined;
+    code_verifier?: string | undefined;
 };
 /** @internal */
 export declare const ExchangeAuthCodeForAPIKeyRequestBody$outboundSchema: z.ZodType<ExchangeAuthCodeForAPIKeyRequestBody$Outbound, ExchangeAuthCodeForAPIKeyRequestBody>;

package/esm/models/operations/exchangeauthcodeforapikey.js

@@ -19,12 +19,12 @@ export const ExchangeAuthCodeForAPIKeyCodeChallengeMethod$outboundSchema = openE
 /** @internal */
 export const ExchangeAuthCodeForAPIKeyRequestBody$outboundSchema = z.object({
     code: z.string(),
-    codeVerifier: z.string().optional(),
     codeChallengeMethod: z.nullable(ExchangeAuthCodeForAPIKeyCodeChallengeMethod$outboundSchema).optional(),
+    codeVerifier: z.string().optional(),
 }).transform((v) => {
     return remap$(v, {
-        codeVerifier: "code_verifier",
         codeChallengeMethod: "code_challenge_method",
+        codeVerifier: "code_verifier",
     });
 });
 export function exchangeAuthCodeForAPIKeyRequestBodyToJSON(exchangeAuthCodeForAPIKeyRequestBody) {

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

@@ -49,10 +49,6 @@ export type GetCurrentKeyRequest = {
  * @deprecated class: This will be removed in a future release, please migrate away from it as soon as possible.
  */
 export type RateLimit = {
-    /**
-     * Number of requests allowed per interval
-     */
-    requests: number;
     /**
      * Rate limit interval
      */
@@ -61,35 +57,15 @@ export type RateLimit = {
      * Note about the rate limit
      */
     note: string;
+    /**
+     * Number of requests allowed per interval
+     */
+    requests: number;
 };
 /**
  * Current API key information
  */
 export type GetCurrentKeyData = {
-    /**
-     * Human-readable label for the API key
-     */
-    label: string;
-    /**
-     * Spending limit for the API key in USD
-     */
-    limit: number | null;
-    /**
-     * Total OpenRouter credit usage (in USD) for the API key
-     */
-    usage: number;
-    /**
-     * OpenRouter credit usage (in USD) for the current UTC day
-     */
-    usageDaily: number;
-    /**
-     * OpenRouter credit usage (in USD) for the current UTC week (Monday-Sunday)
-     */
-    usageWeekly: number;
-    /**
-     * OpenRouter credit usage (in USD) for the current UTC month
-     */
-    usageMonthly: number;
     /**
      * Total external BYOK usage (in USD) for the API key
      */
@@ -98,14 +74,26 @@ export type GetCurrentKeyData = {
      * External BYOK usage (in USD) for the current UTC day
      */
     byokUsageDaily: number;
+    /**
+     * External BYOK usage (in USD) for current UTC month
+     */
+    byokUsageMonthly: number;
     /**
      * External BYOK usage (in USD) for the current UTC week (Monday-Sunday)
      */
     byokUsageWeekly: number;
     /**
-     * External BYOK usage (in USD) for current UTC month
+     * The user ID of the key creator. For organization-owned keys, this is the member who created the key. For individual users, this is the user's own ID.
      */
-    byokUsageMonthly: number;
+    creatorUserId: string | null;
+    /**
+     * ISO 8601 UTC timestamp when the API key expires, or null if no expiration
+     */
+    expiresAt?: Date | null | undefined;
+    /**
+     * Whether to include external BYOK usage in the credit limit
+     */
+    includeByokInLimit: boolean;
     /**
      * Whether this is a free tier API key
      */
@@ -121,27 +109,43 @@ export type GetCurrentKeyData = {
      */
     isProvisioningKey: boolean;
     /**
-     * Remaining spending limit in USD
+     * Human-readable label for the API key
      */
-    limitRemaining: number | null;
+    label: string;
     /**
-     * Type of limit reset for the API key
+     * Spending limit for the API key in USD
      */
-    limitReset: string | null;
+    limit: number;
     /**
-     * Whether to include external BYOK usage in the credit limit
+     * Remaining spending limit in USD
      */
-    includeByokInLimit: boolean;
+    limitRemaining: number;
     /**
-     * ISO 8601 UTC timestamp when the API key expires, or null if no expiration
+     * Type of limit reset for the API key
      */
-    expiresAt?: Date | null | undefined;
+    limitReset: string | null;
     /**
      * Legacy rate limit information about a key. Will always return -1.
      *
      * @deprecated field: This will be removed in a future release, please migrate away from it as soon as possible.
      */
     rateLimit: RateLimit;
+    /**
+     * Total OpenRouter credit usage (in USD) for the API key
+     */
+    usage: number;
+    /**
+     * OpenRouter credit usage (in USD) for the current UTC day
+     */
+    usageDaily: number;
+    /**
+     * OpenRouter credit usage (in USD) for the current UTC month
+     */
+    usageMonthly: number;
+    /**
+     * OpenRouter credit usage (in USD) for the current UTC week (Monday-Sunday)
+     */
+    usageWeekly: number;
 };
 /**
  * API key details