@openrouter/sdk 1.2.54 → 1.2.56

package/esm/models/outputbashservertoolitem.js

@@ -6,27 +6,76 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { ToolCallStatus$inboundSchema, ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
-export const OutputBashServerToolItemType = {
+export const OutputBashServerToolItemTypeContainerFileCitation = {
+    ContainerFileCitation: "container_file_citation",
+};
+export const OutputBashServerToolItemTypeOpenrouterBash = {
     OpenrouterBash: "openrouter:bash",
 };
 /** @internal */
-export const OutputBashServerToolItemType$inboundSchema = z.enum(OutputBashServerToolItemType);
+export const OutputBashServerToolItemTypeContainerFileCitation$inboundSchema = z.enum(OutputBashServerToolItemTypeContainerFileCitation);
+/** @internal */
+export const OutputBashServerToolItemTypeContainerFileCitation$outboundSchema = OutputBashServerToolItemTypeContainerFileCitation$inboundSchema;
+/** @internal */
+export const OutputBashServerToolItemFile$inboundSchema = z.object({
+    container_id: z.string(),
+    end_index: z.int(),
+    file_id: z.string(),
+    filename: z.string(),
+    start_index: z.int(),
+    type: OutputBashServerToolItemTypeContainerFileCitation$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "container_id": "containerId",
+        "end_index": "endIndex",
+        "file_id": "fileId",
+        "start_index": "startIndex",
+    });
+});
+/** @internal */
+export const OutputBashServerToolItemFile$outboundSchema = z.object({
+    containerId: z.string(),
+    endIndex: z.int(),
+    fileId: z.string(),
+    filename: z.string(),
+    startIndex: z.int(),
+    type: OutputBashServerToolItemTypeContainerFileCitation$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        containerId: "container_id",
+        endIndex: "end_index",
+        fileId: "file_id",
+        startIndex: "start_index",
+    });
+});
+export function outputBashServerToolItemFileToJSON(outputBashServerToolItemFile) {
+    return JSON.stringify(OutputBashServerToolItemFile$outboundSchema.parse(outputBashServerToolItemFile));
+}
+export function outputBashServerToolItemFileFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputBashServerToolItemFile$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputBashServerToolItemFile' from JSON`);
+}
+/** @internal */
+export const OutputBashServerToolItemTypeOpenrouterBash$inboundSchema = z.enum(OutputBashServerToolItemTypeOpenrouterBash);
 /** @internal */
-export const OutputBashServerToolItemType$outboundSchema = OutputBashServerToolItemType$inboundSchema;
+export const OutputBashServerToolItemTypeOpenrouterBash$outboundSchema = OutputBashServerToolItemTypeOpenrouterBash$inboundSchema;
 /** @internal */
 export const OutputBashServerToolItem$inboundSchema = z.object({
     arguments: z.nullable(z.string()).optional(),
     call_id: z.nullable(z.string()).optional(),
     command: z.string().optional(),
+    container_id: z.string().optional(),
     exitCode: z.int().optional(),
+    files: z.array(z.lazy(() => OutputBashServerToolItemFile$inboundSchema))
+        .optional(),
     id: z.string().optional(),
     status: ToolCallStatus$inboundSchema,
     stderr: z.string().optional(),
     stdout: z.string().optional(),
-    type: OutputBashServerToolItemType$inboundSchema,
+    type: OutputBashServerToolItemTypeOpenrouterBash$inboundSchema,
 }).transform((v) => {
     return remap$(v, {
         "call_id": "callId",
+        "container_id": "containerId",
     });
 });
 /** @internal */
@@ -34,15 +83,19 @@ export const OutputBashServerToolItem$outboundSchema = z.object({
     arguments: z.nullable(z.string()).optional(),
     callId: z.nullable(z.string()).optional(),
     command: z.string().optional(),
+    containerId: z.string().optional(),
     exitCode: z.int().optional(),
+    files: z.array(z.lazy(() => OutputBashServerToolItemFile$outboundSchema))
+        .optional(),
     id: z.string().optional(),
     status: ToolCallStatus$outboundSchema,
     stderr: z.string().optional(),
     stdout: z.string().optional(),
-    type: OutputBashServerToolItemType$outboundSchema,
+    type: OutputBashServerToolItemTypeOpenrouterBash$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         callId: "call_id",
+        containerId: "container_id",
     });
 });
 export function outputBashServerToolItemToJSON(outputBashServerToolItem) {

package/esm/models/outputshellcalloutputitem.d.ts

@@ -1,13 +1,34 @@
 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";
 import { ShellCallOutputContent } from "./shellcalloutputcontent.js";
 import { ShellCallStatus } from "./shellcallstatus.js";
+export declare const OutputShellCallOutputItemTypeContainerFileCitation: {
+    readonly ContainerFileCitation: "container_file_citation";
+};
+export type OutputShellCallOutputItemTypeContainerFileCitation = ClosedEnum<typeof OutputShellCallOutputItemTypeContainerFileCitation>;
+export type OutputShellCallOutputItemFile = {
+    containerId: string;
+    endIndex: number;
+    fileId: string;
+    filename: string;
+    startIndex: number;
+    type: OutputShellCallOutputItemTypeContainerFileCitation;
+};
 /**
  * A native `shell_call_output` item matching OpenAI's Responses API shape. Carries per-command stdout, stderr, and the exit/timeout outcome.
  */
 export type OutputShellCallOutputItem = {
     callId: string;
+    /**
+     * The canonical container id the command ran under — the `{container_id}` for the Container Files API, reusable as a `container_reference` in later requests. Present on every sandbox-executed call, even when no files changed.
+     */
+    containerId?: string | undefined;
+    /**
+     * Citations for the files the sandbox command created or modified, most-recently-touched first (at most 10). Retrieve them via the Container Files API.
+     */
+    files?: Array<OutputShellCallOutputItemFile> | undefined;
     id: string;
     maxOutputLength?: number | null | undefined;
     output: Array<ShellCallOutputContent>;
@@ -18,6 +39,11 @@ export type OutputShellCallOutputItem = {
     type: "shell_call_output";
 };
 /** @internal */
+export declare const OutputShellCallOutputItemTypeContainerFileCitation$inboundSchema: z.ZodEnum<typeof OutputShellCallOutputItemTypeContainerFileCitation>;
+/** @internal */
+export declare const OutputShellCallOutputItemFile$inboundSchema: z.ZodType<OutputShellCallOutputItemFile, unknown>;
+export declare function outputShellCallOutputItemFileFromJSON(jsonString: string): SafeParseResult<OutputShellCallOutputItemFile, SDKValidationError>;
+/** @internal */
 export declare const OutputShellCallOutputItem$inboundSchema: z.ZodType<OutputShellCallOutputItem, unknown>;
 export declare function outputShellCallOutputItemFromJSON(jsonString: string): SafeParseResult<OutputShellCallOutputItem, SDKValidationError>;
 //# sourceMappingURL=outputshellcalloutputitem.d.ts.map

package/esm/models/outputshellcalloutputitem.js

@@ -7,9 +7,36 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { ShellCallOutputContent$inboundSchema, } from "./shellcalloutputcontent.js";
 import { ShellCallStatus$inboundSchema, } from "./shellcallstatus.js";
+export const OutputShellCallOutputItemTypeContainerFileCitation = {
+    ContainerFileCitation: "container_file_citation",
+};
+/** @internal */
+export const OutputShellCallOutputItemTypeContainerFileCitation$inboundSchema = z.enum(OutputShellCallOutputItemTypeContainerFileCitation);
+/** @internal */
+export const OutputShellCallOutputItemFile$inboundSchema = z.object({
+    container_id: z.string(),
+    end_index: z.int(),
+    file_id: z.string(),
+    filename: z.string(),
+    start_index: z.int(),
+    type: OutputShellCallOutputItemTypeContainerFileCitation$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "container_id": "containerId",
+        "end_index": "endIndex",
+        "file_id": "fileId",
+        "start_index": "startIndex",
+    });
+});
+export function outputShellCallOutputItemFileFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputShellCallOutputItemFile$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputShellCallOutputItemFile' from JSON`);
+}
 /** @internal */
 export const OutputShellCallOutputItem$inboundSchema = z.object({
     call_id: z.string(),
+    container_id: z.string().optional(),
+    files: z.array(z.lazy(() => OutputShellCallOutputItemFile$inboundSchema))
+        .optional(),
     id: z.string(),
     max_output_length: z.nullable(z.int()).optional(),
     output: z.array(ShellCallOutputContent$inboundSchema),
@@ -18,6 +45,7 @@ export const OutputShellCallOutputItem$inboundSchema = z.object({
 }).transform((v) => {
     return remap$(v, {
         "call_id": "callId",
+        "container_id": "containerId",
         "max_output_length": "maxOutputLength",
     });
 });

package/esm/models/outputshellservertoolitem.d.ts

@@ -9,10 +9,22 @@ export type OutputShellServerToolItemAction = {
     maxOutputLength?: number | null | undefined;
     timeoutMs?: number | null | undefined;
 };
-export declare const OutputShellServerToolItemType: {
+export declare const OutputShellServerToolItemTypeContainerFileCitation: {
+    readonly ContainerFileCitation: "container_file_citation";
+};
+export type OutputShellServerToolItemTypeContainerFileCitation = ClosedEnum<typeof OutputShellServerToolItemTypeContainerFileCitation>;
+export type OutputShellServerToolItemFile = {
+    containerId: string;
+    endIndex: number;
+    fileId: string;
+    filename: string;
+    startIndex: number;
+    type: OutputShellServerToolItemTypeContainerFileCitation;
+};
+export declare const OutputShellServerToolItemTypeOpenrouterShell: {
     readonly OpenrouterShell: "openrouter:shell";
 };
-export type OutputShellServerToolItemType = ClosedEnum<typeof OutputShellServerToolItemType>;
+export type OutputShellServerToolItemTypeOpenrouterShell = ClosedEnum<typeof OutputShellServerToolItemTypeOpenrouterShell>;
 /**
  * An openrouter:shell server tool output item
  */
@@ -26,10 +38,18 @@ export type OutputShellServerToolItem = {
      * The model-generated tool call id from the originating turn.
      */
     callId?: string | null | undefined;
+    /**
+     * The canonical container id the command ran under — the `{container_id}` for the Container Files API, reusable as a `container_reference` in later requests. Present on every sandbox-executed call, even when no files changed.
+     */
+    containerId?: string | undefined;
+    /**
+     * Citations for the files the sandbox command created or modified, most-recently-touched first (at most 10). Retrieve them via the Container Files API.
+     */
+    files?: Array<OutputShellServerToolItemFile> | undefined;
     id?: string | undefined;
     output?: Array<ShellCallOutputContent> | undefined;
     status: ToolCallStatus;
-    type: OutputShellServerToolItemType;
+    type: OutputShellServerToolItemTypeOpenrouterShell;
 };
 /** @internal */
 export declare const OutputShellServerToolItemAction$inboundSchema: z.ZodType<OutputShellServerToolItemAction, unknown>;
@@ -44,9 +64,28 @@ export declare const OutputShellServerToolItemAction$outboundSchema: z.ZodType<O
 export declare function outputShellServerToolItemActionToJSON(outputShellServerToolItemAction: OutputShellServerToolItemAction): string;
 export declare function outputShellServerToolItemActionFromJSON(jsonString: string): SafeParseResult<OutputShellServerToolItemAction, SDKValidationError>;
 /** @internal */
-export declare const OutputShellServerToolItemType$inboundSchema: z.ZodEnum<typeof OutputShellServerToolItemType>;
+export declare const OutputShellServerToolItemTypeContainerFileCitation$inboundSchema: z.ZodEnum<typeof OutputShellServerToolItemTypeContainerFileCitation>;
+/** @internal */
+export declare const OutputShellServerToolItemTypeContainerFileCitation$outboundSchema: z.ZodEnum<typeof OutputShellServerToolItemTypeContainerFileCitation>;
+/** @internal */
+export declare const OutputShellServerToolItemFile$inboundSchema: z.ZodType<OutputShellServerToolItemFile, unknown>;
+/** @internal */
+export type OutputShellServerToolItemFile$Outbound = {
+    container_id: string;
+    end_index: number;
+    file_id: string;
+    filename: string;
+    start_index: number;
+    type: string;
+};
+/** @internal */
+export declare const OutputShellServerToolItemFile$outboundSchema: z.ZodType<OutputShellServerToolItemFile$Outbound, OutputShellServerToolItemFile>;
+export declare function outputShellServerToolItemFileToJSON(outputShellServerToolItemFile: OutputShellServerToolItemFile): string;
+export declare function outputShellServerToolItemFileFromJSON(jsonString: string): SafeParseResult<OutputShellServerToolItemFile, SDKValidationError>;
+/** @internal */
+export declare const OutputShellServerToolItemTypeOpenrouterShell$inboundSchema: z.ZodEnum<typeof OutputShellServerToolItemTypeOpenrouterShell>;
 /** @internal */
-export declare const OutputShellServerToolItemType$outboundSchema: z.ZodEnum<typeof OutputShellServerToolItemType>;
+export declare const OutputShellServerToolItemTypeOpenrouterShell$outboundSchema: z.ZodEnum<typeof OutputShellServerToolItemTypeOpenrouterShell>;
 /** @internal */
 export declare const OutputShellServerToolItem$inboundSchema: z.ZodType<OutputShellServerToolItem, unknown>;
 /** @internal */
@@ -54,6 +93,8 @@ export type OutputShellServerToolItem$Outbound = {
     action?: OutputShellServerToolItemAction$Outbound | undefined;
     arguments?: string | null | undefined;
     call_id?: string | null | undefined;
+    container_id?: string | undefined;
+    files?: Array<OutputShellServerToolItemFile$Outbound> | undefined;
     id?: string | undefined;
     output?: Array<ShellCallOutputContent$Outbound> | undefined;
     status: string;

package/esm/models/outputshellservertoolitem.js

@@ -7,7 +7,10 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { ShellCallOutputContent$inboundSchema, ShellCallOutputContent$outboundSchema, } from "./shellcalloutputcontent.js";
 import { ToolCallStatus$inboundSchema, ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
-export const OutputShellServerToolItemType = {
+export const OutputShellServerToolItemTypeContainerFileCitation = {
+    ContainerFileCitation: "container_file_citation",
+};
+export const OutputShellServerToolItemTypeOpenrouterShell = {
     OpenrouterShell: "openrouter:shell",
 };
 /** @internal */
@@ -39,22 +42,68 @@ export function outputShellServerToolItemActionFromJSON(jsonString) {
     return safeParse(jsonString, (x) => OutputShellServerToolItemAction$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputShellServerToolItemAction' from JSON`);
 }
 /** @internal */
-export const OutputShellServerToolItemType$inboundSchema = z.enum(OutputShellServerToolItemType);
+export const OutputShellServerToolItemTypeContainerFileCitation$inboundSchema = z.enum(OutputShellServerToolItemTypeContainerFileCitation);
 /** @internal */
-export const OutputShellServerToolItemType$outboundSchema = OutputShellServerToolItemType$inboundSchema;
+export const OutputShellServerToolItemTypeContainerFileCitation$outboundSchema = OutputShellServerToolItemTypeContainerFileCitation$inboundSchema;
+/** @internal */
+export const OutputShellServerToolItemFile$inboundSchema = z.object({
+    container_id: z.string(),
+    end_index: z.int(),
+    file_id: z.string(),
+    filename: z.string(),
+    start_index: z.int(),
+    type: OutputShellServerToolItemTypeContainerFileCitation$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "container_id": "containerId",
+        "end_index": "endIndex",
+        "file_id": "fileId",
+        "start_index": "startIndex",
+    });
+});
+/** @internal */
+export const OutputShellServerToolItemFile$outboundSchema = z.object({
+    containerId: z.string(),
+    endIndex: z.int(),
+    fileId: z.string(),
+    filename: z.string(),
+    startIndex: z.int(),
+    type: OutputShellServerToolItemTypeContainerFileCitation$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        containerId: "container_id",
+        endIndex: "end_index",
+        fileId: "file_id",
+        startIndex: "start_index",
+    });
+});
+export function outputShellServerToolItemFileToJSON(outputShellServerToolItemFile) {
+    return JSON.stringify(OutputShellServerToolItemFile$outboundSchema.parse(outputShellServerToolItemFile));
+}
+export function outputShellServerToolItemFileFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputShellServerToolItemFile$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputShellServerToolItemFile' from JSON`);
+}
+/** @internal */
+export const OutputShellServerToolItemTypeOpenrouterShell$inboundSchema = z.enum(OutputShellServerToolItemTypeOpenrouterShell);
+/** @internal */
+export const OutputShellServerToolItemTypeOpenrouterShell$outboundSchema = OutputShellServerToolItemTypeOpenrouterShell$inboundSchema;
 /** @internal */
 export const OutputShellServerToolItem$inboundSchema = z.object({
     action: z.lazy(() => OutputShellServerToolItemAction$inboundSchema)
         .optional(),
     arguments: z.nullable(z.string()).optional(),
     call_id: z.nullable(z.string()).optional(),
+    container_id: z.string().optional(),
+    files: z.array(z.lazy(() => OutputShellServerToolItemFile$inboundSchema))
+        .optional(),
     id: z.string().optional(),
     output: z.array(ShellCallOutputContent$inboundSchema).optional(),
     status: ToolCallStatus$inboundSchema,
-    type: OutputShellServerToolItemType$inboundSchema,
+    type: OutputShellServerToolItemTypeOpenrouterShell$inboundSchema,
 }).transform((v) => {
     return remap$(v, {
         "call_id": "callId",
+        "container_id": "containerId",
     });
 });
 /** @internal */
@@ -63,13 +112,17 @@ export const OutputShellServerToolItem$outboundSchema = z.object({
         .optional(),
     arguments: z.nullable(z.string()).optional(),
     callId: z.nullable(z.string()).optional(),
+    containerId: z.string().optional(),
+    files: z.array(z.lazy(() => OutputShellServerToolItemFile$outboundSchema))
+        .optional(),
     id: z.string().optional(),
     output: z.array(ShellCallOutputContent$outboundSchema).optional(),
     status: ToolCallStatus$outboundSchema,
-    type: OutputShellServerToolItemType$outboundSchema,
+    type: OutputShellServerToolItemTypeOpenrouterShell$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         callId: "call_id",
+        containerId: "container_id",
     });
 });
 export function outputShellServerToolItemToJSON(outputShellServerToolItem) {

package/esm/sdk/containers.d.ts

@@ -0,0 +1,27 @@
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+export declare class Containers extends ClientSDK {
+    /**
+     * List container files
+     *
+     * @remarks
+     * Lists the files in a container, in lexicographic path order. The container id is the canonical id returned in bash/shell tool results; a restarted session is a separate container with its own id. Paginate with `limit` and `after` (pass the previous page’s `last_id`); `has_more: true` always means the next page is fetchable that way.
+     */
+    listContainerFiles(request: operations.ListContainerFilesRequest, options?: RequestOptions): Promise<models.ContainerFileListResponse>;
+    /**
+     * Retrieve a container file
+     *
+     * @remarks
+     * Returns the metadata of a single file in a container.
+     */
+    getContainerFile(request: operations.GetContainerFileRequest, options?: RequestOptions): Promise<models.ContainerFile>;
+    /**
+     * Download container file content
+     *
+     * @remarks
+     * Streams the raw bytes of a file in a container.
+     */
+    downloadContainerFileContent(request: operations.DownloadContainerFileContentRequest, options?: RequestOptions): Promise<ReadableStream<Uint8Array>>;
+}
+//# sourceMappingURL=containers.d.ts.map

package/esm/sdk/containers.js

@@ -0,0 +1,39 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: f772470024e6
+ */
+import { containersDownloadContainerFileContent } from "../funcs/containersDownloadContainerFileContent.js";
+import { containersGetContainerFile } from "../funcs/containersGetContainerFile.js";
+import { containersListContainerFiles } from "../funcs/containersListContainerFiles.js";
+import { ClientSDK } from "../lib/sdks.js";
+import { unwrapAsync } from "../types/fp.js";
+export class Containers extends ClientSDK {
+    /**
+     * List container files
+     *
+     * @remarks
+     * Lists the files in a container, in lexicographic path order. The container id is the canonical id returned in bash/shell tool results; a restarted session is a separate container with its own id. Paginate with `limit` and `after` (pass the previous page’s `last_id`); `has_more: true` always means the next page is fetchable that way.
+     */
+    async listContainerFiles(request, options) {
+        return unwrapAsync(containersListContainerFiles(this, request, options));
+    }
+    /**
+     * Retrieve a container file
+     *
+     * @remarks
+     * Returns the metadata of a single file in a container.
+     */
+    async getContainerFile(request, options) {
+        return unwrapAsync(containersGetContainerFile(this, request, options));
+    }
+    /**
+     * Download container file content
+     *
+     * @remarks
+     * Streams the raw bytes of a file in a container.
+     */
+    async downloadContainerFileContent(request, options) {
+        return unwrapAsync(containersDownloadContainerFileContent(this, request, options));
+    }
+}
+//# sourceMappingURL=containers.js.map

package/esm/sdk/sdk.d.ts

@@ -6,6 +6,7 @@ import { Beta } from "./beta.js";
 import { BYOK } from "./byok.js";
 import { Chat } from "./chat.js";
 import { Classifications } from "./classifications.js";
+import { Containers } from "./containers.js";
 import { Credits } from "./credits.js";
 import { Datasets } from "./datasets.js";
 import { Embeddings } from "./embeddings.js";
@@ -50,6 +51,8 @@ export declare class OpenRouter extends ClientSDK {
     get chat(): Chat;
     private _classifications?;
     get classifications(): Classifications;
+    private _containers?;
+    get containers(): Containers;
     private _credits?;
     get credits(): Credits;
     private _datasets?;

package/esm/sdk/sdk.js

@@ -10,6 +10,7 @@ import { Beta } from "./beta.js";
 import { BYOK } from "./byok.js";
 import { Chat } from "./chat.js";
 import { Classifications } from "./classifications.js";
+import { Containers } from "./containers.js";
 import { Credits } from "./credits.js";
 import { Datasets } from "./datasets.js";
 import { Embeddings } from "./embeddings.js";
@@ -60,6 +61,9 @@ export class OpenRouter extends ClientSDK {
     get classifications() {
         return (this._classifications ?? (this._classifications = new Classifications(this._options)));
     }
+    get containers() {
+        return (this._containers ?? (this._containers = new Containers(this._options)));
+    }
     get credits() {
         return (this._credits ?? (this._credits = new Credits(this._options)));
     }

package/jsr.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrouter/sdk",
-  "version": "1.2.54",
+  "version": "1.2.56",
   "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",
-    "postinstall": "node scripts/check-types.js || true",
-    "test": "vitest --run --project unit",
-    "test:e2e": "vitest --run --project e2e",
+    "compile": "tsc",
+    "prepare": "npm run build",
     "test:transit": "exit 0",
     "test:watch": "vitest --watch --project unit",
+    "typecheck": "tsc --noEmit",
     "typecheck:transit": "exit 0",
-    "compile": "tsc",
-    "prepare": "npm run build",
-    "typecheck": "tsc --noEmit"
+    "postinstall": "node scripts/check-types.js || true",
+    "test": "vitest --run --project unit",
+    "test:e2e": "vitest --run --project e2e"
   },
   "peerDependencies": {},
   "devDependencies": {