@openrouter/sdk 1.1.17 → 1.1.19

package/esm/funcs/benchmarksGetBenchmarks.d.ts

@@ -13,7 +13,7 @@ import { Result } from "../types/fp.js";
  * List Benchmarks
  *
  * @remarks
- * Unified benchmark endpoint that aggregates scores from multiple benchmark sources (Artificial Analysis, Design Arena). Filter by source to reproduce the exact shapes from the legacy per-source endpoints, or use task_type to find models suited for specific workloads. Authenticate with any valid OpenRouter API key. Rate-limited to 30 requests/minute per key and 500 requests/day per account.
+ * Unified benchmark endpoint that aggregates scores from multiple benchmark sources (Artificial Analysis, Design Arena, and OpenRouter's own tau-bench and GPQA evals). Filter by source to reproduce the exact shapes from the legacy per-source endpoints, or use task_type to find models suited for specific workloads. Authenticate with any valid OpenRouter API key. Rate-limited to 30 requests/minute per key and 500 requests/day per account.
  */
 export declare function benchmarksGetBenchmarks(client: OpenRouterCore, request?: operations.GetBenchmarksRequest | undefined, options?: RequestOptions): APIPromise<Result<models.UnifiedBenchmarksResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=benchmarksGetBenchmarks.d.ts.map

package/esm/funcs/benchmarksGetBenchmarks.js

@@ -17,7 +17,7 @@ import { APIPromise } from "../types/async.js";
  * List Benchmarks
  *
  * @remarks
- * Unified benchmark endpoint that aggregates scores from multiple benchmark sources (Artificial Analysis, Design Arena). Filter by source to reproduce the exact shapes from the legacy per-source endpoints, or use task_type to find models suited for specific workloads. Authenticate with any valid OpenRouter API key. Rate-limited to 30 requests/minute per key and 500 requests/day per account.
+ * Unified benchmark endpoint that aggregates scores from multiple benchmark sources (Artificial Analysis, Design Arena, and OpenRouter's own tau-bench and GPQA evals). Filter by source to reproduce the exact shapes from the legacy per-source endpoints, or use task_type to find models suited for specific workloads. Authenticate with any valid OpenRouter API key. Rate-limited to 30 requests/minute per key and 500 requests/day per account.
  */
 export function benchmarksGetBenchmarks(client, request, options) {
     return new APIPromise($do(client, request, options));

package/esm/funcs/filesDelete.d.ts

@@ -15,5 +15,5 @@ import { Result } from "../types/fp.js";
  * @remarks
  * Deletes a file owned by the requesting workspace. Deletion is irreversible.
  */
-export declare function filesDelete(client: OpenRouterCore, request: operations.DeleteFileRequest, options?: RequestOptions): APIPromise<Result<models.FileDeleteResponse, errors.UnauthorizedResponseError | errors.NotFoundResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function filesDelete(client: OpenRouterCore, request: operations.DeleteFileRequest, options?: RequestOptions): APIPromise<Result<models.FileDeleteResponse, errors.UnauthorizedResponseError | errors.ForbiddenResponseError | errors.NotFoundResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=filesDelete.d.ts.map

package/esm/funcs/filesDelete.js

@@ -37,6 +37,7 @@ async function $do(client, request, options) {
     };
     const path = pathToFunc("/files/{file_id}")(pathParams);
     const query = encodeFormQuery({
+        "provider": payload.provider,
         "workspace_id": payload.workspace_id,
     });
     const headers = new Headers(compactMap({
@@ -98,7 +99,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.FileDeleteResponse$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(429, errors.TooManyRequestsResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, models.FileDeleteResponse$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(403, errors.ForbiddenResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(429, errors.TooManyRequestsResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.jsonErr(502, errors.BadGatewayResponseError$inboundSchema), M.jsonErr(503, errors.ServiceUnavailableResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/filesDownload.d.ts

@@ -14,5 +14,5 @@ import { Result } from "../types/fp.js";
  * @remarks
  * Downloads the raw bytes of a file. Only files created server-side are downloadable; uploaded files return 400.
  */
-export declare function filesDownload(client: OpenRouterCore, request: operations.DownloadFileContentRequest, options?: RequestOptions): APIPromise<Result<ReadableStream<Uint8Array>, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.NotFoundResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function filesDownload(client: OpenRouterCore, request: operations.DownloadFileContentRequest, options?: RequestOptions): APIPromise<Result<ReadableStream<Uint8Array>, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.ForbiddenResponseError | errors.NotFoundResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=filesDownload.d.ts.map

package/esm/funcs/filesDownload.js

@@ -37,6 +37,7 @@ async function $do(client, request, options) {
     };
     const path = pathToFunc("/files/{file_id}/content")(pathParams);
     const query = encodeFormQuery({
+        "provider": payload.provider,
         "workspace_id": payload.workspace_id,
     });
     const headers = new Headers(compactMap({
@@ -98,7 +99,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.stream(200, z.custom(x => x instanceof ReadableStream)), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(429, errors.TooManyRequestsResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.stream(200, z.custom(x => x instanceof ReadableStream)), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(403, errors.ForbiddenResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(429, errors.TooManyRequestsResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.jsonErr(502, errors.BadGatewayResponseError$inboundSchema), M.jsonErr(503, errors.ServiceUnavailableResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/filesList.d.ts

@@ -15,7 +15,7 @@ import { PageIterator } from "../types/operations.js";
  * @remarks
  * Lists files belonging to the workspace of the authenticating API key.
  */
-export declare function filesList(client: OpenRouterCore, request?: operations.ListFilesRequest | undefined, options?: RequestOptions): APIPromise<PageIterator<Result<operations.ListFilesResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>, {
+export declare function filesList(client: OpenRouterCore, request?: operations.ListFilesRequest | undefined, options?: RequestOptions): APIPromise<PageIterator<Result<operations.ListFilesResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.ForbiddenResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>, {
     cursor: string;
 }>>;
 //# sourceMappingURL=filesList.d.ts.map

package/esm/funcs/filesList.js

@@ -31,8 +31,13 @@ async function $do(client, request, options) {
     const body = null;
     const path = pathToFunc("/files")();
     const query = encodeFormQuery({
+        "after": payload?.after,
+        "after_id": payload?.after_id,
+        "before_id": payload?.before_id,
         "cursor": payload?.cursor,
         "limit": payload?.limit,
+        "order": payload?.order,
+        "provider": payload?.provider,
         "workspace_id": payload?.workspace_id,
     });
     const headers = new Headers(compactMap({
@@ -94,7 +99,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result, raw] = await M.match(M.json(200, operations.ListFilesResponse$inboundSchema, { key: "Result" }), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(429, errors.TooManyRequestsResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result, raw] = await M.match(M.json(200, operations.ListFilesResponse$inboundSchema, { key: "Result" }), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(403, errors.ForbiddenResponseError$inboundSchema), M.jsonErr(429, errors.TooManyRequestsResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.jsonErr(502, errors.BadGatewayResponseError$inboundSchema), M.jsonErr(503, errors.ServiceUnavailableResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [haltIterator(result), {
                 status: "complete",
@@ -103,14 +108,16 @@ async function $do(client, request, options) {
             }];
     }
     const nextFunc = (responseData) => {
-        const nextCursor = responseData.cursor;
+        const nextCursor = responseData
+            ?.cursor;
         if (typeof nextCursor !== "string") {
             return { next: () => null };
         }
         if (nextCursor.trim() === "") {
             return { next: () => null };
         }
-        const results = responseData.data;
+        const results = responseData
+            ?.data;
         if (!Array.isArray(results) || !results.length) {
             return { next: () => null };
         }

package/esm/funcs/filesRetrieve.d.ts

@@ -15,5 +15,5 @@ import { Result } from "../types/fp.js";
  * @remarks
  * Retrieves metadata for a single file owned by the requesting workspace.
  */
-export declare function filesRetrieve(client: OpenRouterCore, request: operations.GetFileMetadataRequest, options?: RequestOptions): APIPromise<Result<models.FileMetadata, errors.UnauthorizedResponseError | errors.NotFoundResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function filesRetrieve(client: OpenRouterCore, request: operations.GetFileMetadataRequest, options?: RequestOptions): APIPromise<Result<models.FileResponse, errors.UnauthorizedResponseError | errors.ForbiddenResponseError | errors.NotFoundResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=filesRetrieve.d.ts.map

package/esm/funcs/filesRetrieve.js

@@ -37,6 +37,7 @@ async function $do(client, request, options) {
     };
     const path = pathToFunc("/files/{file_id}")(pathParams);
     const query = encodeFormQuery({
+        "provider": payload.provider,
         "workspace_id": payload.workspace_id,
     });
     const headers = new Headers(compactMap({
@@ -98,7 +99,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.FileMetadata$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(429, errors.TooManyRequestsResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, models.FileResponse$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(403, errors.ForbiddenResponseError$inboundSchema), M.jsonErr(404, errors.NotFoundResponseError$inboundSchema), M.jsonErr(429, errors.TooManyRequestsResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.jsonErr(502, errors.BadGatewayResponseError$inboundSchema), M.jsonErr(503, errors.ServiceUnavailableResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

package/esm/funcs/filesUpload.d.ts

@@ -15,5 +15,5 @@ import { Result } from "../types/fp.js";
  * @remarks
  * Uploads a file to be referenced in future API calls. The file is stored under the workspace of the authenticating API key. Maximum file size: 100 MB.
  */
-export declare function filesUpload(client: OpenRouterCore, request: operations.UploadFileRequest, options?: RequestOptions): APIPromise<Result<models.FileMetadata, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.ForbiddenResponseError | errors.PayloadTooLargeResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
+export declare function filesUpload(client: OpenRouterCore, request: operations.UploadFileRequest, options?: RequestOptions): APIPromise<Result<models.FileResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.ForbiddenResponseError | errors.PayloadTooLargeResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.BadGatewayResponseError | errors.ServiceUnavailableResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=filesUpload.d.ts.map

package/esm/funcs/filesUpload.js

@@ -51,6 +51,7 @@ async function $do(client, request, options) {
     }
     const path = pathToFunc("/files")();
     const query = encodeFormQuery({
+        "provider": payload.provider,
         "workspace_id": payload.workspace_id,
     });
     const headers = new Headers(compactMap({
@@ -112,7 +113,7 @@ async function $do(client, request, options) {
     const responseFields = {
         HttpMeta: { Response: response, Request: req },
     };
-    const [result] = await M.match(M.json(200, models.FileMetadata$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(403, errors.ForbiddenResponseError$inboundSchema), M.jsonErr(413, errors.PayloadTooLargeResponseError$inboundSchema), M.jsonErr(429, errors.TooManyRequestsResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
+    const [result] = await M.match(M.json(200, models.FileResponse$inboundSchema), M.jsonErr(400, errors.BadRequestResponseError$inboundSchema), M.jsonErr(401, errors.UnauthorizedResponseError$inboundSchema), M.jsonErr(403, errors.ForbiddenResponseError$inboundSchema), M.jsonErr(413, errors.PayloadTooLargeResponseError$inboundSchema), M.jsonErr(429, errors.TooManyRequestsResponseError$inboundSchema), M.jsonErr(500, errors.InternalServerResponseError$inboundSchema), M.jsonErr(502, errors.BadGatewayResponseError$inboundSchema), M.jsonErr(503, errors.ServiceUnavailableResponseError$inboundSchema), M.fail("4XX"), M.fail("5XX"))(response, req, { extraFields: responseFields });
     if (!result.ok) {
         return [result, { status: "complete", request: req, response }];
     }

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: "1.1.17";
+    readonly sdkVersion: "1.1.19";
     readonly genVersion: "2.914.0";
-    readonly userAgent: "speakeasy-sdk/typescript 1.1.17 2.914.0 1.0.0 @openrouter/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 1.1.19 2.914.0 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: "1.1.17",
+    sdkVersion: "1.1.19",
     genVersion: "2.914.0",
-    userAgent: "speakeasy-sdk/typescript 1.1.17 2.914.0 1.0.0 @openrouter/sdk",
+    userAgent: "speakeasy-sdk/typescript 1.1.19 2.914.0 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

package/esm/models/anthropicfile.d.ts

@@ -0,0 +1,33 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const AnthropicFileShape: {
+    readonly Anthropic: "anthropic";
+};
+export type AnthropicFileShape = ClosedEnum<typeof AnthropicFileShape>;
+export declare const AnthropicFileType: {
+    readonly File: "file";
+};
+export type AnthropicFileType = ClosedEnum<typeof AnthropicFileType>;
+/**
+ * A stored file in Anthropic's Files API shape.
+ */
+export type AnthropicFile = {
+    shape: AnthropicFileShape;
+    createdAt: string;
+    downloadable: boolean;
+    filename: string;
+    id: string;
+    mimeType: string;
+    sizeBytes: number;
+    type: AnthropicFileType;
+};
+/** @internal */
+export declare const AnthropicFileShape$inboundSchema: z.ZodEnum<typeof AnthropicFileShape>;
+/** @internal */
+export declare const AnthropicFileType$inboundSchema: z.ZodEnum<typeof AnthropicFileType>;
+/** @internal */
+export declare const AnthropicFile$inboundSchema: z.ZodType<AnthropicFile, unknown>;
+export declare function anthropicFileFromJSON(jsonString: string): SafeParseResult<AnthropicFile, SDKValidationError>;
+//# sourceMappingURL=anthropicfile.d.ts.map

package/esm/models/anthropicfile.js

@@ -0,0 +1,40 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: ef320fa3557d
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+export const AnthropicFileShape = {
+    Anthropic: "anthropic",
+};
+export const AnthropicFileType = {
+    File: "file",
+};
+/** @internal */
+export const AnthropicFileShape$inboundSchema = z.enum(AnthropicFileShape);
+/** @internal */
+export const AnthropicFileType$inboundSchema = z.enum(AnthropicFileType);
+/** @internal */
+export const AnthropicFile$inboundSchema = z
+    .object({
+    _shape: AnthropicFileShape$inboundSchema,
+    created_at: z.string(),
+    downloadable: z.boolean(),
+    filename: z.string(),
+    id: z.string(),
+    mime_type: z.string(),
+    size_bytes: z.int(),
+    type: AnthropicFileType$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "_shape": "shape",
+        "created_at": "createdAt",
+        "mime_type": "mimeType",
+        "size_bytes": "sizeBytes",
+    });
+});
+export function anthropicFileFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicFile$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicFile' from JSON`);
+}
+//# sourceMappingURL=anthropicfile.js.map

package/esm/models/anthropicfiledeleted.d.ts

@@ -0,0 +1,22 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const AnthropicFileDeletedType: {
+    readonly FileDeleted: "file_deleted";
+};
+export type AnthropicFileDeletedType = ClosedEnum<typeof AnthropicFileDeletedType>;
+/**
+ * Deletion result in Anthropic's shape.
+ */
+export type AnthropicFileDeleted = {
+    shape: "anthropic";
+    id: string;
+    type: AnthropicFileDeletedType;
+};
+/** @internal */
+export declare const AnthropicFileDeletedType$inboundSchema: z.ZodEnum<typeof AnthropicFileDeletedType>;
+/** @internal */
+export declare const AnthropicFileDeleted$inboundSchema: z.ZodType<AnthropicFileDeleted, unknown>;
+export declare function anthropicFileDeletedFromJSON(jsonString: string): SafeParseResult<AnthropicFileDeleted, SDKValidationError>;
+//# sourceMappingURL=anthropicfiledeleted.d.ts.map

package/esm/models/anthropicfiledeleted.js

@@ -0,0 +1,26 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 37177e6e8a12
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+export const AnthropicFileDeletedType = {
+    FileDeleted: "file_deleted",
+};
+/** @internal */
+export const AnthropicFileDeletedType$inboundSchema = z.enum(AnthropicFileDeletedType);
+/** @internal */
+export const AnthropicFileDeleted$inboundSchema = z.object({
+    _shape: z.literal("anthropic"),
+    id: z.string(),
+    type: AnthropicFileDeletedType$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "_shape": "shape",
+    });
+});
+export function anthropicFileDeletedFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicFileDeleted$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicFileDeleted' from JSON`);
+}
+//# sourceMappingURL=anthropicfiledeleted.js.map

package/esm/models/anthropicfilelist.d.ts

@@ -0,0 +1,18 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { AnthropicFile } from "./anthropicfile.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * A page of files in Anthropic's shape.
+ */
+export type AnthropicFileList = {
+    shape: "anthropic";
+    data: Array<AnthropicFile>;
+    firstId: string | null;
+    hasMore: boolean;
+    lastId: string | null;
+};
+/** @internal */
+export declare const AnthropicFileList$inboundSchema: z.ZodType<AnthropicFileList, unknown>;
+export declare function anthropicFileListFromJSON(jsonString: string): SafeParseResult<AnthropicFileList, SDKValidationError>;
+//# sourceMappingURL=anthropicfilelist.d.ts.map

package/esm/models/anthropicfilelist.js

@@ -0,0 +1,27 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 7ef7b8e43b6c
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { AnthropicFile$inboundSchema } from "./anthropicfile.js";
+/** @internal */
+export const AnthropicFileList$inboundSchema = z.object({
+    _shape: z.literal("anthropic"),
+    data: z.array(AnthropicFile$inboundSchema),
+    first_id: z.nullable(z.string()),
+    has_more: z.boolean(),
+    last_id: z.nullable(z.string()),
+}).transform((v) => {
+    return remap$(v, {
+        "_shape": "shape",
+        "first_id": "firstId",
+        "has_more": "hasMore",
+        "last_id": "lastId",
+    });
+});
+export function anthropicFileListFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicFileList$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicFileList' from JSON`);
+}
+//# sourceMappingURL=anthropicfilelist.js.map

package/esm/models/filedeleteresponse.d.ts

@@ -1,20 +1,14 @@
 import * as z from "zod/v4";
-import { ClosedEnum } from "../types/enums.js";
+import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
 import { Result as SafeParseResult } from "../types/fp.js";
+import { AnthropicFileDeleted } from "./anthropicfiledeleted.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export declare const FileDeleteResponseType: {
-    readonly FileDeleted: "file_deleted";
-};
-export type FileDeleteResponseType = ClosedEnum<typeof FileDeleteResponseType>;
+import { OpenAIFileDeleted } from "./openaifiledeleted.js";
+import { OpenRouterFileDeleted } from "./openrouterfiledeleted.js";
 /**
- * Confirmation that a file was deleted.
+ * Confirmation that a file was deleted, in the negotiated shape.
  */
-export type FileDeleteResponse = {
-    id: string;
-    type: FileDeleteResponseType;
-};
-/** @internal */
-export declare const FileDeleteResponseType$inboundSchema: z.ZodEnum<typeof FileDeleteResponseType>;
+export type FileDeleteResponse = AnthropicFileDeleted | OpenAIFileDeleted | OpenRouterFileDeleted | discriminatedUnionTypes.Unknown<"shape">;
 /** @internal */
 export declare const FileDeleteResponse$inboundSchema: z.ZodType<FileDeleteResponse, unknown>;
 export declare function fileDeleteResponseFromJSON(jsonString: string): SafeParseResult<FileDeleteResponse, SDKValidationError>;

package/esm/models/filedeleteresponse.js

@@ -2,18 +2,17 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  * @generated-id: 2464f2b51ee5
  */
-import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
-export const FileDeleteResponseType = {
-    FileDeleted: "file_deleted",
-};
+import { discriminatedUnion } from "../types/discriminatedUnion.js";
+import { AnthropicFileDeleted$inboundSchema, } from "./anthropicfiledeleted.js";
+import { OpenAIFileDeleted$inboundSchema, } from "./openaifiledeleted.js";
+import { OpenRouterFileDeleted$inboundSchema, } from "./openrouterfiledeleted.js";
 /** @internal */
-export const FileDeleteResponseType$inboundSchema = z.enum(FileDeleteResponseType);
-/** @internal */
-export const FileDeleteResponse$inboundSchema = z.object({
-    id: z.string(),
-    type: FileDeleteResponseType$inboundSchema,
-});
+export const FileDeleteResponse$inboundSchema = discriminatedUnion("_shape", {
+    anthropic: AnthropicFileDeleted$inboundSchema,
+    openai: OpenAIFileDeleted$inboundSchema,
+    openrouter: OpenRouterFileDeleted$inboundSchema,
+}, { outputPropertyName: "shape" });
 export function fileDeleteResponseFromJSON(jsonString) {
     return safeParse(jsonString, (x) => FileDeleteResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FileDeleteResponse' from JSON`);
 }

package/esm/models/filelistresponse.d.ts

@@ -1,20 +1,14 @@
 import * as z from "zod/v4";
+import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
 import { Result as SafeParseResult } from "../types/fp.js";
+import { AnthropicFileList } from "./anthropicfilelist.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import { FileMetadata } from "./filemetadata.js";
+import { OpenAIFileList } from "./openaifilelist.js";
+import { OpenRouterFileList } from "./openrouterfilelist.js";
 /**
- * A page of files belonging to the requesting workspace.
+ * A page of files, in the negotiated shape.
  */
-export type FileListResponse = {
-    /**
-     * Opaque cursor for the next page; null when there are no more results.
-     */
-    cursor: string | null;
-    data: Array<FileMetadata>;
-    firstId: string | null;
-    hasMore: boolean;
-    lastId: string | null;
-};
+export type FileListResponse = AnthropicFileList | OpenAIFileList | OpenRouterFileList | discriminatedUnionTypes.Unknown<"shape">;
 /** @internal */
 export declare const FileListResponse$inboundSchema: z.ZodType<FileListResponse, unknown>;
 export declare function fileListResponseFromJSON(jsonString: string): SafeParseResult<FileListResponse, SDKValidationError>;

package/esm/models/filelistresponse.js

@@ -2,24 +2,17 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  * @generated-id: e4978ed568c7
  */
-import * as z from "zod/v4";
-import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import { FileMetadata$inboundSchema } from "./filemetadata.js";
+import { discriminatedUnion } from "../types/discriminatedUnion.js";
+import { AnthropicFileList$inboundSchema, } from "./anthropicfilelist.js";
+import { OpenAIFileList$inboundSchema, } from "./openaifilelist.js";
+import { OpenRouterFileList$inboundSchema, } from "./openrouterfilelist.js";
 /** @internal */
-export const FileListResponse$inboundSchema = z.object({
-    cursor: z.nullable(z.string()),
-    data: z.array(FileMetadata$inboundSchema),
-    first_id: z.nullable(z.string()),
-    has_more: z.boolean(),
-    last_id: z.nullable(z.string()),
-}).transform((v) => {
-    return remap$(v, {
-        "first_id": "firstId",
-        "has_more": "hasMore",
-        "last_id": "lastId",
-    });
-});
+export const FileListResponse$inboundSchema = discriminatedUnion("_shape", {
+    anthropic: AnthropicFileList$inboundSchema,
+    openai: OpenAIFileList$inboundSchema,
+    openrouter: OpenRouterFileList$inboundSchema,
+}, { outputPropertyName: "shape" });
 export function fileListResponseFromJSON(jsonString) {
     return safeParse(jsonString, (x) => FileListResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FileListResponse' from JSON`);
 }

package/esm/models/fileprovider.d.ts

@@ -0,0 +1,16 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+/**
+ * Store or read this file on the named provider using your own API key for it. Omit to use OpenRouter storage.
+ */
+export declare const FileProvider: {
+    readonly Openai: "openai";
+    readonly Anthropic: "anthropic";
+};
+/**
+ * Store or read this file on the named provider using your own API key for it. Omit to use OpenRouter storage.
+ */
+export type FileProvider = OpenEnum<typeof FileProvider>;
+/** @internal */
+export declare const FileProvider$outboundSchema: z.ZodType<string, FileProvider>;
+//# sourceMappingURL=fileprovider.d.ts.map

package/esm/models/fileprovider.js

@@ -0,0 +1,15 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: f319a1008f4d
+ */
+import * as openEnums from "../types/enums.js";
+/**
+ * Store or read this file on the named provider using your own API key for it. Omit to use OpenRouter storage.
+ */
+export const FileProvider = {
+    Openai: "openai",
+    Anthropic: "anthropic",
+};
+/** @internal */
+export const FileProvider$outboundSchema = openEnums.outboundSchema(FileProvider);
+//# sourceMappingURL=fileprovider.js.map

package/esm/models/fileresponse.d.ts

@@ -0,0 +1,21 @@
+import * as z from "zod/v4";
+import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { AnthropicFile } from "./anthropicfile.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { OpenAIFile } from "./openaifile.js";
+import { OpenRouterFile } from "./openrouterfile.js";
+/**
+ * A stored file. The shape is negotiated per request — see the endpoint description.
+ */
+export type FileResponse = (AnthropicFile & {
+    shape: "anthropic";
+}) | (OpenAIFile & {
+    shape: "openai";
+}) | (OpenRouterFile & {
+    shape: "openrouter";
+}) | discriminatedUnionTypes.Unknown<"shape">;
+/** @internal */
+export declare const FileResponse$inboundSchema: z.ZodType<FileResponse, unknown>;
+export declare function fileResponseFromJSON(jsonString: string): SafeParseResult<FileResponse, SDKValidationError>;
+//# sourceMappingURL=fileresponse.d.ts.map

package/esm/models/fileresponse.js

@@ -0,0 +1,26 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: f1edf3b92523
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { discriminatedUnion } from "../types/discriminatedUnion.js";
+import { AnthropicFile$inboundSchema } from "./anthropicfile.js";
+import { OpenAIFile$inboundSchema } from "./openaifile.js";
+import { OpenRouterFile$inboundSchema, } from "./openrouterfile.js";
+/** @internal */
+export const FileResponse$inboundSchema = discriminatedUnion("_shape", {
+    anthropic: AnthropicFile$inboundSchema.and(z.object({ _shape: z.literal("anthropic") }).transform((v) => ({
+        shape: v._shape,
+    }))),
+    openai: OpenAIFile$inboundSchema.and(z.object({ _shape: z.literal("openai") }).transform((v) => ({
+        shape: v._shape,
+    }))),
+    openrouter: OpenRouterFile$inboundSchema.and(z.object({ _shape: z.literal("openrouter") }).transform((v) => ({
+        shape: v._shape,
+    }))),
+}, { outputPropertyName: "shape" });
+export function fileResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FileResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FileResponse' from JSON`);
+}
+//# sourceMappingURL=fileresponse.js.map