@openrouter/sdk 1.2.55 → 1.2.57

package/esm/funcs/containersDownloadContainerFileContent.d.ts

@@ -12,7 +12,7 @@ import { Result } from "../types/fp.js";
  * Download container file content
  *
  * @remarks
- * Streams the raw bytes of a file under a sandbox session prefix.
+ * Streams the raw bytes of a file in a container.
  */
 export declare function containersDownloadContainerFileContent(client: OpenRouterCore, request: operations.DownloadContainerFileContentRequest, options?: RequestOptions): APIPromise<Result<ReadableStream<Uint8Array>, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.ForbiddenResponseError | errors.NotFoundResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.ServiceUnavailableResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=containersDownloadContainerFileContent.d.ts.map

package/esm/funcs/containersDownloadContainerFileContent.js

@@ -17,7 +17,7 @@ import { APIPromise } from "../types/async.js";
  * Download container file content
  *
  * @remarks
- * Streams the raw bytes of a file under a sandbox session prefix.
+ * Streams the raw bytes of a file in a container.
  */
 export function containersDownloadContainerFileContent(client, request, options) {
     return new APIPromise($do(client, request, options));
@@ -30,16 +30,16 @@ async function $do(client, request, options) {
     const payload = parsed.value;
     const body = null;
     const pathParams = {
-        file_id: encodeSimple("file_id", payload.file_id, {
+        container_id: encodeSimple("container_id", payload.container_id, {
             explode: false,
             charEncoding: "percent",
         }),
-        session_id: encodeSimple("session_id", payload.session_id, {
+        file_id: encodeSimple("file_id", payload.file_id, {
             explode: false,
             charEncoding: "percent",
         }),
     };
-    const path = pathToFunc("/containers/{session_id}/files/{file_id}/content")(pathParams);
+    const path = pathToFunc("/containers/{container_id}/files/{file_id}/content")(pathParams);
     const headers = new Headers(compactMap({
         Accept: "application/octet-stream",
         "HTTP-Referer": encodeSimple("HTTP-Referer", payload["HTTP-Referer"] ?? client._options.httpReferer, { explode: false, charEncoding: "none" }),

package/esm/funcs/containersGetContainerFile.d.ts

@@ -13,7 +13,7 @@ import { Result } from "../types/fp.js";
  * Retrieve a container file
  *
  * @remarks
- * Returns the metadata of a single file under a sandbox session prefix.
+ * Returns the metadata of a single file in a container.
  */
 export declare function containersGetContainerFile(client: OpenRouterCore, request: operations.GetContainerFileRequest, options?: RequestOptions): APIPromise<Result<models.ContainerFile, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.ForbiddenResponseError | errors.NotFoundResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.ServiceUnavailableResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=containersGetContainerFile.d.ts.map

package/esm/funcs/containersGetContainerFile.js

@@ -17,7 +17,7 @@ import { APIPromise } from "../types/async.js";
  * Retrieve a container file
  *
  * @remarks
- * Returns the metadata of a single file under a sandbox session prefix.
+ * Returns the metadata of a single file in a container.
  */
 export function containersGetContainerFile(client, request, options) {
     return new APIPromise($do(client, request, options));
@@ -30,16 +30,16 @@ async function $do(client, request, options) {
     const payload = parsed.value;
     const body = null;
     const pathParams = {
-        file_id: encodeSimple("file_id", payload.file_id, {
+        container_id: encodeSimple("container_id", payload.container_id, {
             explode: false,
             charEncoding: "percent",
         }),
-        session_id: encodeSimple("session_id", payload.session_id, {
+        file_id: encodeSimple("file_id", payload.file_id, {
             explode: false,
             charEncoding: "percent",
         }),
     };
-    const path = pathToFunc("/containers/{session_id}/files/{file_id}")(pathParams);
+    const path = pathToFunc("/containers/{container_id}/files/{file_id}")(pathParams);
     const headers = new Headers(compactMap({
         Accept: "application/json",
         "HTTP-Referer": encodeSimple("HTTP-Referer", payload["HTTP-Referer"] ?? client._options.httpReferer, { explode: false, charEncoding: "none" }),

package/esm/funcs/containersListContainerFiles.d.ts

@@ -13,7 +13,7 @@ import { Result } from "../types/fp.js";
  * List container files
  *
  * @remarks
- * Lists the files under a sandbox session prefix, in lexicographic path order. A restarted session is a separate container with its own session 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.
+ * 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.
  */
 export declare function containersListContainerFiles(client: OpenRouterCore, request: operations.ListContainerFilesRequest, options?: RequestOptions): APIPromise<Result<models.ContainerFileListResponse, errors.BadRequestResponseError | errors.UnauthorizedResponseError | errors.ForbiddenResponseError | errors.TooManyRequestsResponseError | errors.InternalServerResponseError | errors.ServiceUnavailableResponseError | OpenRouterError | ResponseValidationError | ConnectionError | RequestAbortedError | RequestTimeoutError | InvalidRequestError | UnexpectedClientError | SDKValidationError>>;
 //# sourceMappingURL=containersListContainerFiles.d.ts.map

package/esm/funcs/containersListContainerFiles.js

@@ -17,7 +17,7 @@ import { APIPromise } from "../types/async.js";
  * List container files
  *
  * @remarks
- * Lists the files under a sandbox session prefix, in lexicographic path order. A restarted session is a separate container with its own session 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.
+ * 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.
  */
 export function containersListContainerFiles(client, request, options) {
     return new APIPromise($do(client, request, options));
@@ -30,12 +30,12 @@ async function $do(client, request, options) {
     const payload = parsed.value;
     const body = null;
     const pathParams = {
-        session_id: encodeSimple("session_id", payload.session_id, {
+        container_id: encodeSimple("container_id", payload.container_id, {
             explode: false,
             charEncoding: "percent",
         }),
     };
-    const path = pathToFunc("/containers/{session_id}/files")(pathParams);
+    const path = pathToFunc("/containers/{container_id}/files")(pathParams);
     const query = encodeFormQuery({
         "after": payload.after,
         "limit": payload.limit,

package/esm/lib/config.d.ts

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

package/esm/lib/config.js

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

package/esm/models/chatcontentfile.d.ts

@@ -1,7 +1,7 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export type FileT = {
+export type ChatContentFileFile = {
     /**
      * File content as base64 data URL or URL
      */
@@ -19,26 +19,26 @@ export type FileT = {
  * File content part for document processing
  */
 export type ChatContentFile = {
-    file: FileT;
+    file: ChatContentFileFile;
     type: "file";
 };
 /** @internal */
-export declare const FileT$inboundSchema: z.ZodType<FileT, unknown>;
+export declare const ChatContentFileFile$inboundSchema: z.ZodType<ChatContentFileFile, unknown>;
 /** @internal */
-export type FileT$Outbound = {
+export type ChatContentFileFile$Outbound = {
     file_data?: string | undefined;
     file_id?: string | undefined;
     filename?: string | undefined;
 };
 /** @internal */
-export declare const FileT$outboundSchema: z.ZodType<FileT$Outbound, FileT>;
-export declare function fileToJSON(fileT: FileT): string;
-export declare function fileFromJSON(jsonString: string): SafeParseResult<FileT, SDKValidationError>;
+export declare const ChatContentFileFile$outboundSchema: z.ZodType<ChatContentFileFile$Outbound, ChatContentFileFile>;
+export declare function chatContentFileFileToJSON(chatContentFileFile: ChatContentFileFile): string;
+export declare function chatContentFileFileFromJSON(jsonString: string): SafeParseResult<ChatContentFileFile, SDKValidationError>;
 /** @internal */
 export declare const ChatContentFile$inboundSchema: z.ZodType<ChatContentFile, unknown>;
 /** @internal */
 export type ChatContentFile$Outbound = {
-    file: FileT$Outbound;
+    file: ChatContentFileFile$Outbound;
     type: "file";
 };
 /** @internal */

package/esm/models/chatcontentfile.js

@@ -6,7 +6,7 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
-export const FileT$inboundSchema = z.object({
+export const ChatContentFileFile$inboundSchema = z.object({
     file_data: z.string().optional(),
     file_id: z.string().optional(),
     filename: z.string().optional(),
@@ -17,7 +17,7 @@ export const FileT$inboundSchema = z.object({
     });
 });
 /** @internal */
-export const FileT$outboundSchema = z.object({
+export const ChatContentFileFile$outboundSchema = z.object({
     fileData: z.string().optional(),
     fileId: z.string().optional(),
     filename: z.string().optional(),
@@ -27,20 +27,20 @@ export const FileT$outboundSchema = z.object({
         fileId: "file_id",
     });
 });
-export function fileToJSON(fileT) {
-    return JSON.stringify(FileT$outboundSchema.parse(fileT));
+export function chatContentFileFileToJSON(chatContentFileFile) {
+    return JSON.stringify(ChatContentFileFile$outboundSchema.parse(chatContentFileFile));
 }
-export function fileFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => FileT$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FileT' from JSON`);
+export function chatContentFileFileFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatContentFileFile$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatContentFileFile' from JSON`);
 }
 /** @internal */
 export const ChatContentFile$inboundSchema = z.object({
-    file: z.lazy(() => FileT$inboundSchema),
+    file: z.lazy(() => ChatContentFileFile$inboundSchema),
     type: z.literal("file"),
 });
 /** @internal */
 export const ChatContentFile$outboundSchema = z.object({
-    file: z.lazy(() => FileT$outboundSchema),
+    file: z.lazy(() => ChatContentFileFile$outboundSchema),
     type: z.literal("file"),
 });
 export function chatContentFileToJSON(chatContentFile) {

package/esm/models/containerfile.d.ts

@@ -22,7 +22,7 @@ export type ContainerFile = {
      */
     bytes: number;
     /**
-     * The container the file belongs to — echoes the `session_id` path parameter (OpenAI field name).
+     * The container the file belongs to — echoes the `container_id` path parameter (OpenAI field name).
      */
     containerId: string;
     /**
@@ -35,7 +35,7 @@ export type ContainerFile = {
     id: string;
     object: ContainerFileObject;
     /**
-     * Session-relative file path inside the container.
+     * Container-relative file path.
      */
     path: string;
     /**

package/esm/models/containerreferenceenvironment.d.ts

@@ -1,10 +1,10 @@
 import * as z from "zod/v4";
 /**
- * Reference to a previously created container to reuse.
+ * Reference to a container by its canonical id — a previously returned container_id or a fresh name to create a persistent container.
  */
 export type ContainerReferenceEnvironment = {
     /**
-     * Identifier of an existing container to reuse (max 20 characters).
+     * Canonical container id to reuse (max 40 characters, letters/digits/underscores/hyphens). Any container_id previously returned by a bash or shell tool result works here and reattaches to the same container and files — including session-derived ids (sess_...) and generation-derived ids (gen_...). Note that a session-derived id is always sess_ + the sanitized session key, which is not necessarily the raw session id you sent. Using the same container_id from both the bash and shell tools shares the same files, with last-write-wins when both flush concurrently. A fresh name creates a new persistent container. Containers are always scoped to your account and workspace.
      */
     containerId: string;
     type: "container_reference";

package/esm/models/messagesbashtoolresultblock.d.ts

@@ -1,19 +1,56 @@
 import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+export declare const MessagesBashToolResultBlockTypeContainerFileCitation: {
+    readonly ContainerFileCitation: "container_file_citation";
+};
+export type MessagesBashToolResultBlockTypeContainerFileCitation = ClosedEnum<typeof MessagesBashToolResultBlockTypeContainerFileCitation>;
+export type MessagesBashToolResultBlockFile = {
+    containerId: string;
+    endIndex: number;
+    fileId: string;
+    filename: string;
+    startIndex: number;
+    type: MessagesBashToolResultBlockTypeContainerFileCitation;
+};
 /**
  * Output of a sandbox-executed `openrouter:bash` call from a prior assistant turn. Accepted on replay and dropped before the provider request — Anthropic has no equivalent block.
  */
 export type MessagesBashToolResultBlock = {
+    /**
+     * 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;
     content: {
         [k: string]: any;
     };
+    /**
+     * 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<MessagesBashToolResultBlockFile> | undefined;
     toolUseId: string;
     type: "openrouter_bash_tool_result";
 };
 /** @internal */
+export declare const MessagesBashToolResultBlockTypeContainerFileCitation$outboundSchema: z.ZodEnum<typeof MessagesBashToolResultBlockTypeContainerFileCitation>;
+/** @internal */
+export type MessagesBashToolResultBlockFile$Outbound = {
+    container_id: string;
+    end_index: number;
+    file_id: string;
+    filename: string;
+    start_index: number;
+    type: string;
+};
+/** @internal */
+export declare const MessagesBashToolResultBlockFile$outboundSchema: z.ZodType<MessagesBashToolResultBlockFile$Outbound, MessagesBashToolResultBlockFile>;
+export declare function messagesBashToolResultBlockFileToJSON(messagesBashToolResultBlockFile: MessagesBashToolResultBlockFile): string;
+/** @internal */
 export type MessagesBashToolResultBlock$Outbound = {
+    container_id?: string | undefined;
     content: {
         [k: string]: any;
     };
+    files?: Array<MessagesBashToolResultBlockFile$Outbound> | undefined;
     tool_use_id: string;
     type: "openrouter_bash_tool_result";
 };

package/esm/models/messagesbashtoolresultblock.js

@@ -4,13 +4,42 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
+export const MessagesBashToolResultBlockTypeContainerFileCitation = {
+    ContainerFileCitation: "container_file_citation",
+};
+/** @internal */
+export const MessagesBashToolResultBlockTypeContainerFileCitation$outboundSchema = z
+    .enum(MessagesBashToolResultBlockTypeContainerFileCitation);
+/** @internal */
+export const MessagesBashToolResultBlockFile$outboundSchema = z.object({
+    containerId: z.string(),
+    endIndex: z.int(),
+    fileId: z.string(),
+    filename: z.string(),
+    startIndex: z.int(),
+    type: MessagesBashToolResultBlockTypeContainerFileCitation$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        containerId: "container_id",
+        endIndex: "end_index",
+        fileId: "file_id",
+        startIndex: "start_index",
+    });
+});
+export function messagesBashToolResultBlockFileToJSON(messagesBashToolResultBlockFile) {
+    return JSON.stringify(MessagesBashToolResultBlockFile$outboundSchema.parse(messagesBashToolResultBlockFile));
+}
 /** @internal */
 export const MessagesBashToolResultBlock$outboundSchema = z.object({
+    containerId: z.string().optional(),
     content: z.record(z.string(), z.any()),
+    files: z.array(z.lazy(() => MessagesBashToolResultBlockFile$outboundSchema))
+        .optional(),
     toolUseId: z.string(),
     type: z.literal("openrouter_bash_tool_result"),
 }).transform((v) => {
     return remap$(v, {
+        containerId: "container_id",
         toolUseId: "tool_use_id",
     });
 });

package/esm/models/messagesshelltoolresultblock.d.ts

@@ -1,19 +1,56 @@
 import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+export declare const MessagesShellToolResultBlockTypeContainerFileCitation: {
+    readonly ContainerFileCitation: "container_file_citation";
+};
+export type MessagesShellToolResultBlockTypeContainerFileCitation = ClosedEnum<typeof MessagesShellToolResultBlockTypeContainerFileCitation>;
+export type MessagesShellToolResultBlockFile = {
+    containerId: string;
+    endIndex: number;
+    fileId: string;
+    filename: string;
+    startIndex: number;
+    type: MessagesShellToolResultBlockTypeContainerFileCitation;
+};
 /**
  * Output of an `openrouter:shell` call from a prior assistant turn. Accepted on replay and dropped before the provider request — Anthropic has no equivalent block.
  */
 export type MessagesShellToolResultBlock = {
+    /**
+     * 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;
     content: {
         [k: string]: any;
     };
+    /**
+     * 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<MessagesShellToolResultBlockFile> | undefined;
     toolUseId: string;
     type: "openrouter_shell_tool_result";
 };
 /** @internal */
+export declare const MessagesShellToolResultBlockTypeContainerFileCitation$outboundSchema: z.ZodEnum<typeof MessagesShellToolResultBlockTypeContainerFileCitation>;
+/** @internal */
+export type MessagesShellToolResultBlockFile$Outbound = {
+    container_id: string;
+    end_index: number;
+    file_id: string;
+    filename: string;
+    start_index: number;
+    type: string;
+};
+/** @internal */
+export declare const MessagesShellToolResultBlockFile$outboundSchema: z.ZodType<MessagesShellToolResultBlockFile$Outbound, MessagesShellToolResultBlockFile>;
+export declare function messagesShellToolResultBlockFileToJSON(messagesShellToolResultBlockFile: MessagesShellToolResultBlockFile): string;
+/** @internal */
 export type MessagesShellToolResultBlock$Outbound = {
+    container_id?: string | undefined;
     content: {
         [k: string]: any;
     };
+    files?: Array<MessagesShellToolResultBlockFile$Outbound> | undefined;
     tool_use_id: string;
     type: "openrouter_shell_tool_result";
 };

package/esm/models/messagesshelltoolresultblock.js

@@ -4,13 +4,42 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
+export const MessagesShellToolResultBlockTypeContainerFileCitation = {
+    ContainerFileCitation: "container_file_citation",
+};
+/** @internal */
+export const MessagesShellToolResultBlockTypeContainerFileCitation$outboundSchema = z
+    .enum(MessagesShellToolResultBlockTypeContainerFileCitation);
+/** @internal */
+export const MessagesShellToolResultBlockFile$outboundSchema = z.object({
+    containerId: z.string(),
+    endIndex: z.int(),
+    fileId: z.string(),
+    filename: z.string(),
+    startIndex: z.int(),
+    type: MessagesShellToolResultBlockTypeContainerFileCitation$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        containerId: "container_id",
+        endIndex: "end_index",
+        fileId: "file_id",
+        startIndex: "start_index",
+    });
+});
+export function messagesShellToolResultBlockFileToJSON(messagesShellToolResultBlockFile) {
+    return JSON.stringify(MessagesShellToolResultBlockFile$outboundSchema.parse(messagesShellToolResultBlockFile));
+}
 /** @internal */
 export const MessagesShellToolResultBlock$outboundSchema = z.object({
+    containerId: z.string().optional(),
     content: z.record(z.string(), z.any()),
+    files: z.array(z.lazy(() => MessagesShellToolResultBlockFile$outboundSchema))
+        .optional(),
     toolUseId: z.string(),
     type: z.literal("openrouter_shell_tool_result"),
 }).transform((v) => {
     return remap$(v, {
+        containerId: "container_id",
         toolUseId: "tool_use_id",
     });
 });

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

@@ -44,6 +44,10 @@ export type CreateKeysRequestBody = {
      * Optional ISO 8601 UTC timestamp when the API key should expire. Must be UTC, other timezones will be rejected
      */
     expiresAt?: Date | null | undefined;
+    /**
+     * Optional partner-supplied API key. Stored as a SHA-256 hash and never returned. Accepted only when authenticating with a Connect client secret.
+     */
+    externalApiKey?: string | undefined;
     /**
      * Whether to include BYOK usage in the limit
      */
@@ -195,6 +199,7 @@ export declare const CreateKeysLimitReset$outboundSchema: z.ZodType<string, Crea
 export type CreateKeysRequestBody$Outbound = {
     creator_user_id?: string | null | undefined;
     expires_at?: string | null | undefined;
+    external_api_key?: string | undefined;
     include_byok_in_limit?: boolean | undefined;
     limit?: number | null | undefined;
     limit_reset?: string | null | undefined;

package/esm/models/operations/createkeys.js

@@ -20,6 +20,7 @@ export const CreateKeysLimitReset$outboundSchema = openEnums.outboundSchema(Crea
 export const CreateKeysRequestBody$outboundSchema = z.object({
     creatorUserId: z.nullable(z.string()).optional(),
     expiresAt: z.nullable(z.date().transform(v => v.toISOString())).optional(),
+    externalApiKey: z.string().optional(),
     includeByokInLimit: z.boolean().optional(),
     limit: z.nullable(z.number()).optional(),
     limitReset: z.nullable(CreateKeysLimitReset$outboundSchema).optional(),
@@ -29,6 +30,7 @@ export const CreateKeysRequestBody$outboundSchema = z.object({
     return remap$(v, {
         creatorUserId: "creator_user_id",
         expiresAt: "expires_at",
+        externalApiKey: "external_api_key",
         includeByokInLimit: "include_byok_in_limit",
         limitReset: "limit_reset",
         workspaceId: "workspace_id",

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

@@ -41,9 +41,9 @@ export type DownloadContainerFileContentRequest = {
      */
     appCategories?: string | undefined;
     /**
-     * The sandbox session id, exactly as stored — a restarted session has its own `-r<nonce>`-suffixed id.
+     * The canonical container id, exactly as returned in a bash/shell tool result — a restarted session has its own `-r<nonce>`-suffixed id. A session-derived id is always `sess_` + the sanitized session key, which is not necessarily the raw session id that was sent.
      */
-    sessionId: string;
+    containerId: string;
     /**
      * Container file id (`cfile_` + base64url of the file path).
      */
@@ -54,7 +54,7 @@ export type DownloadContainerFileContentRequest$Outbound = {
     "HTTP-Referer"?: string | undefined;
     appTitle?: string | undefined;
     appCategories?: string | undefined;
-    session_id: string;
+    container_id: string;
     file_id: string;
 };
 /** @internal */

package/esm/models/operations/downloadcontainerfilecontent.js

@@ -9,12 +9,12 @@ export const DownloadContainerFileContentRequest$outboundSchema = z.object({
     httpReferer: z.string().optional(),
     appTitle: z.string().optional(),
     appCategories: z.string().optional(),
-    sessionId: z.string(),
+    containerId: z.string(),
     fileId: z.string(),
 }).transform((v) => {
     return remap$(v, {
         httpReferer: "HTTP-Referer",
-        sessionId: "session_id",
+        containerId: "container_id",
         fileId: "file_id",
     });
 });

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

@@ -41,9 +41,9 @@ export type GetContainerFileRequest = {
      */
     appCategories?: string | undefined;
     /**
-     * The sandbox session id, exactly as stored — a restarted session has its own `-r<nonce>`-suffixed id.
+     * The canonical container id, exactly as returned in a bash/shell tool result — a restarted session has its own `-r<nonce>`-suffixed id. A session-derived id is always `sess_` + the sanitized session key, which is not necessarily the raw session id that was sent.
      */
-    sessionId: string;
+    containerId: string;
     /**
      * Container file id (`cfile_` + base64url of the file path).
      */
@@ -54,7 +54,7 @@ export type GetContainerFileRequest$Outbound = {
     "HTTP-Referer"?: string | undefined;
     appTitle?: string | undefined;
     appCategories?: string | undefined;
-    session_id: string;
+    container_id: string;
     file_id: string;
 };
 /** @internal */

package/esm/models/operations/getcontainerfile.js

@@ -9,12 +9,12 @@ export const GetContainerFileRequest$outboundSchema = z.object({
     httpReferer: z.string().optional(),
     appTitle: z.string().optional(),
     appCategories: z.string().optional(),
-    sessionId: z.string(),
+    containerId: z.string(),
     fileId: z.string(),
 }).transform((v) => {
     return remap$(v, {
         httpReferer: "HTTP-Referer",
-        sessionId: "session_id",
+        containerId: "container_id",
         fileId: "file_id",
     });
 });

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

@@ -41,9 +41,9 @@ export type ListContainerFilesRequest = {
      */
     appCategories?: string | undefined;
     /**
-     * The sandbox session id, exactly as stored — a restarted session has its own `-r<nonce>`-suffixed id.
+     * The canonical container id, exactly as returned in a bash/shell tool result — a restarted session has its own `-r<nonce>`-suffixed id. A session-derived id is always `sess_` + the sanitized session key, which is not necessarily the raw session id that was sent.
      */
-    sessionId: string;
+    containerId: string;
     /**
      * Maximum number of files to return (1-1000). Defaults to 100 when absent.
      */
@@ -58,7 +58,7 @@ export type ListContainerFilesRequest$Outbound = {
     "HTTP-Referer"?: string | undefined;
     appTitle?: string | undefined;
     appCategories?: string | undefined;
-    session_id: string;
+    container_id: string;
     limit: number;
     after?: string | undefined;
 };

package/esm/models/operations/listcontainerfiles.js

@@ -9,13 +9,13 @@ export const ListContainerFilesRequest$outboundSchema = z.object({
     httpReferer: z.string().optional(),
     appTitle: z.string().optional(),
     appCategories: z.string().optional(),
-    sessionId: z.string(),
+    containerId: z.string(),
     limit: z.int().default(100),
     after: z.string().optional(),
 }).transform((v) => {
     return remap$(v, {
         httpReferer: "HTTP-Referer",
-        sessionId: "session_id",
+        containerId: "container_id",
     });
 });
 export function listContainerFilesRequestToJSON(listContainerFilesRequest) {

package/esm/models/outputbashservertoolitem.d.ts

@@ -3,10 +3,22 @@ import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { ToolCallStatus } from "./toolcallstatus.js";
-export declare const OutputBashServerToolItemType: {
+export declare const OutputBashServerToolItemTypeContainerFileCitation: {
+    readonly ContainerFileCitation: "container_file_citation";
+};
+export type OutputBashServerToolItemTypeContainerFileCitation = ClosedEnum<typeof OutputBashServerToolItemTypeContainerFileCitation>;
+export type OutputBashServerToolItemFile = {
+    containerId: string;
+    endIndex: number;
+    fileId: string;
+    filename: string;
+    startIndex: number;
+    type: OutputBashServerToolItemTypeContainerFileCitation;
+};
+export declare const OutputBashServerToolItemTypeOpenrouterBash: {
     readonly OpenrouterBash: "openrouter:bash";
 };
-export type OutputBashServerToolItemType = ClosedEnum<typeof OutputBashServerToolItemType>;
+export type OutputBashServerToolItemTypeOpenrouterBash = ClosedEnum<typeof OutputBashServerToolItemTypeOpenrouterBash>;
 /**
  * An openrouter:bash server tool output item
  */
@@ -20,17 +32,44 @@ export type OutputBashServerToolItem = {
      */
     callId?: string | null | undefined;
     command?: string | 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;
     exitCode?: number | 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<OutputBashServerToolItemFile> | undefined;
     id?: string | undefined;
     status: ToolCallStatus;
     stderr?: string | undefined;
     stdout?: string | undefined;
-    type: OutputBashServerToolItemType;
+    type: OutputBashServerToolItemTypeOpenrouterBash;
 };
 /** @internal */
-export declare const OutputBashServerToolItemType$inboundSchema: z.ZodEnum<typeof OutputBashServerToolItemType>;
+export declare const OutputBashServerToolItemTypeContainerFileCitation$inboundSchema: z.ZodEnum<typeof OutputBashServerToolItemTypeContainerFileCitation>;
+/** @internal */
+export declare const OutputBashServerToolItemTypeContainerFileCitation$outboundSchema: z.ZodEnum<typeof OutputBashServerToolItemTypeContainerFileCitation>;
+/** @internal */
+export declare const OutputBashServerToolItemFile$inboundSchema: z.ZodType<OutputBashServerToolItemFile, unknown>;
+/** @internal */
+export type OutputBashServerToolItemFile$Outbound = {
+    container_id: string;
+    end_index: number;
+    file_id: string;
+    filename: string;
+    start_index: number;
+    type: string;
+};
+/** @internal */
+export declare const OutputBashServerToolItemFile$outboundSchema: z.ZodType<OutputBashServerToolItemFile$Outbound, OutputBashServerToolItemFile>;
+export declare function outputBashServerToolItemFileToJSON(outputBashServerToolItemFile: OutputBashServerToolItemFile): string;
+export declare function outputBashServerToolItemFileFromJSON(jsonString: string): SafeParseResult<OutputBashServerToolItemFile, SDKValidationError>;
+/** @internal */
+export declare const OutputBashServerToolItemTypeOpenrouterBash$inboundSchema: z.ZodEnum<typeof OutputBashServerToolItemTypeOpenrouterBash>;
 /** @internal */
-export declare const OutputBashServerToolItemType$outboundSchema: z.ZodEnum<typeof OutputBashServerToolItemType>;
+export declare const OutputBashServerToolItemTypeOpenrouterBash$outboundSchema: z.ZodEnum<typeof OutputBashServerToolItemTypeOpenrouterBash>;
 /** @internal */
 export declare const OutputBashServerToolItem$inboundSchema: z.ZodType<OutputBashServerToolItem, unknown>;
 /** @internal */
@@ -38,7 +77,9 @@ export type OutputBashServerToolItem$Outbound = {
     arguments?: string | null | undefined;
     call_id?: string | null | undefined;
     command?: string | undefined;
+    container_id?: string | undefined;
     exitCode?: number | undefined;
+    files?: Array<OutputBashServerToolItemFile$Outbound> | undefined;
     id?: string | undefined;
     status: string;
     stderr?: string | undefined;

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

@@ -6,21 +6,21 @@ export declare class Containers extends ClientSDK {
      * List container files
      *
      * @remarks
-     * Lists the files under a sandbox session prefix, in lexicographic path order. A restarted session is a separate container with its own session 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.
+     * 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 under a sandbox session prefix.
+     * 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 under a sandbox session prefix.
+     * Streams the raw bytes of a file in a container.
      */
     downloadContainerFileContent(request: operations.DownloadContainerFileContentRequest, options?: RequestOptions): Promise<ReadableStream<Uint8Array>>;
 }

package/esm/sdk/containers.js

@@ -12,7 +12,7 @@ export class Containers extends ClientSDK {
      * List container files
      *
      * @remarks
-     * Lists the files under a sandbox session prefix, in lexicographic path order. A restarted session is a separate container with its own session 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.
+     * 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));
@@ -21,7 +21,7 @@ export class Containers extends ClientSDK {
      * Retrieve a container file
      *
      * @remarks
-     * Returns the metadata of a single file under a sandbox session prefix.
+     * Returns the metadata of a single file in a container.
      */
     async getContainerFile(request, options) {
         return unwrapAsync(containersGetContainerFile(this, request, options));
@@ -30,7 +30,7 @@ export class Containers extends ClientSDK {
      * Download container file content
      *
      * @remarks
-     * Streams the raw bytes of a file under a sandbox session prefix.
+     * Streams the raw bytes of a file in a container.
      */
     async downloadContainerFileContent(request, options) {
         return unwrapAsync(containersDownloadContainerFileContent(this, request, options));

package/jsr.json

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

package/package.json

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