@openrouter/sdk 1.2.37 → 1.2.39

package/esm/models/outputshellcalloutputitem.js

@@ -5,54 +5,14 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import { discriminatedUnion } from "../types/discriminatedUnion.js";
+import { ShellCallOutputContent$inboundSchema, } from "./shellcalloutputcontent.js";
 import { ShellCallStatus$inboundSchema, } from "./shellcallstatus.js";
 /** @internal */
-export const OutcomeTimeout$inboundSchema = z.object({
-    type: z.literal("timeout"),
-});
-export function outcomeTimeoutFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OutcomeTimeout$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutcomeTimeout' from JSON`);
-}
-/** @internal */
-export const OutcomeExit$inboundSchema = z
-    .object({
-    exit_code: z.int(),
-    type: z.literal("exit"),
-}).transform((v) => {
-    return remap$(v, {
-        "exit_code": "exitCode",
-    });
-});
-export function outcomeExitFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OutcomeExit$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutcomeExit' from JSON`);
-}
-/** @internal */
-export const Outcome$inboundSchema = discriminatedUnion("type", {
-    exit: z.lazy(() => OutcomeExit$inboundSchema),
-    timeout: z.lazy(() => OutcomeTimeout$inboundSchema),
-});
-export function outcomeFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => Outcome$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Outcome' from JSON`);
-}
-/** @internal */
-export const OutputShellCallOutputItemOutput$inboundSchema = z.object({
-    outcome: discriminatedUnion("type", {
-        exit: z.lazy(() => OutcomeExit$inboundSchema),
-        timeout: z.lazy(() => OutcomeTimeout$inboundSchema),
-    }),
-    stderr: z.string(),
-    stdout: z.string(),
-});
-export function outputShellCallOutputItemOutputFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OutputShellCallOutputItemOutput$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputShellCallOutputItemOutput' from JSON`);
-}
-/** @internal */
 export const OutputShellCallOutputItem$inboundSchema = z.object({
     call_id: z.string(),
     id: z.string(),
     max_output_length: z.nullable(z.int()).optional(),
-    output: z.array(z.lazy(() => OutputShellCallOutputItemOutput$inboundSchema)),
+    output: z.array(ShellCallOutputContent$inboundSchema),
     status: ShellCallStatus$inboundSchema,
     type: z.literal("shell_call_output"),
 }).transform((v) => {

package/esm/models/outputshellservertoolitem.d.ts

@@ -0,0 +1,66 @@
+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, ShellCallOutputContent$Outbound } from "./shellcalloutputcontent.js";
+import { ToolCallStatus } from "./toolcallstatus.js";
+export type OutputShellServerToolItemAction = {
+    commands: Array<string>;
+    maxOutputLength?: number | null | undefined;
+    timeoutMs?: number | null | undefined;
+};
+export declare const OutputShellServerToolItemType: {
+    readonly OpenrouterShell: "openrouter:shell";
+};
+export type OutputShellServerToolItemType = ClosedEnum<typeof OutputShellServerToolItemType>;
+/**
+ * An openrouter:shell server tool output item
+ */
+export type OutputShellServerToolItem = {
+    action?: OutputShellServerToolItemAction | undefined;
+    /**
+     * The raw tool-call arguments string as emitted by the model.
+     */
+    arguments?: string | null | undefined;
+    /**
+     * The model-generated tool call id from the originating turn.
+     */
+    callId?: string | null | undefined;
+    id?: string | undefined;
+    output?: Array<ShellCallOutputContent> | undefined;
+    status: ToolCallStatus;
+    type: OutputShellServerToolItemType;
+};
+/** @internal */
+export declare const OutputShellServerToolItemAction$inboundSchema: z.ZodType<OutputShellServerToolItemAction, unknown>;
+/** @internal */
+export type OutputShellServerToolItemAction$Outbound = {
+    commands: Array<string>;
+    max_output_length?: number | null | undefined;
+    timeout_ms?: number | null | undefined;
+};
+/** @internal */
+export declare const OutputShellServerToolItemAction$outboundSchema: z.ZodType<OutputShellServerToolItemAction$Outbound, OutputShellServerToolItemAction>;
+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>;
+/** @internal */
+export declare const OutputShellServerToolItemType$outboundSchema: z.ZodEnum<typeof OutputShellServerToolItemType>;
+/** @internal */
+export declare const OutputShellServerToolItem$inboundSchema: z.ZodType<OutputShellServerToolItem, unknown>;
+/** @internal */
+export type OutputShellServerToolItem$Outbound = {
+    action?: OutputShellServerToolItemAction$Outbound | undefined;
+    arguments?: string | null | undefined;
+    call_id?: string | null | undefined;
+    id?: string | undefined;
+    output?: Array<ShellCallOutputContent$Outbound> | undefined;
+    status: string;
+    type: string;
+};
+/** @internal */
+export declare const OutputShellServerToolItem$outboundSchema: z.ZodType<OutputShellServerToolItem$Outbound, OutputShellServerToolItem>;
+export declare function outputShellServerToolItemToJSON(outputShellServerToolItem: OutputShellServerToolItem): string;
+export declare function outputShellServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputShellServerToolItem, SDKValidationError>;
+//# sourceMappingURL=outputshellservertoolitem.d.ts.map

package/esm/models/outputshellservertoolitem.js

@@ -0,0 +1,81 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 369a1cd63f40
+ */
+import * as z from "zod/v4";
+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 = {
+    OpenrouterShell: "openrouter:shell",
+};
+/** @internal */
+export const OutputShellServerToolItemAction$inboundSchema = z.object({
+    commands: z.array(z.string()),
+    max_output_length: z.nullable(z.int()).optional(),
+    timeout_ms: z.nullable(z.int()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "max_output_length": "maxOutputLength",
+        "timeout_ms": "timeoutMs",
+    });
+});
+/** @internal */
+export const OutputShellServerToolItemAction$outboundSchema = z.object({
+    commands: z.array(z.string()),
+    maxOutputLength: z.nullable(z.int()).optional(),
+    timeoutMs: z.nullable(z.int()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        maxOutputLength: "max_output_length",
+        timeoutMs: "timeout_ms",
+    });
+});
+export function outputShellServerToolItemActionToJSON(outputShellServerToolItemAction) {
+    return JSON.stringify(OutputShellServerToolItemAction$outboundSchema.parse(outputShellServerToolItemAction));
+}
+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);
+/** @internal */
+export const OutputShellServerToolItemType$outboundSchema = OutputShellServerToolItemType$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(),
+    id: z.string().optional(),
+    output: z.array(ShellCallOutputContent$inboundSchema).optional(),
+    status: ToolCallStatus$inboundSchema,
+    type: OutputShellServerToolItemType$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "call_id": "callId",
+    });
+});
+/** @internal */
+export const OutputShellServerToolItem$outboundSchema = z.object({
+    action: z.lazy(() => OutputShellServerToolItemAction$outboundSchema)
+        .optional(),
+    arguments: z.nullable(z.string()).optional(),
+    callId: z.nullable(z.string()).optional(),
+    id: z.string().optional(),
+    output: z.array(ShellCallOutputContent$outboundSchema).optional(),
+    status: ToolCallStatus$outboundSchema,
+    type: OutputShellServerToolItemType$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        callId: "call_id",
+    });
+});
+export function outputShellServerToolItemToJSON(outputShellServerToolItem) {
+    return JSON.stringify(OutputShellServerToolItem$outboundSchema.parse(outputShellServerToolItem));
+}
+export function outputShellServerToolItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputShellServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputShellServerToolItem' from JSON`);
+}
+//# sourceMappingURL=outputshellservertoolitem.js.map

package/esm/models/outputsubagentservertoolitem.d.ts

@@ -11,6 +11,10 @@ export type OutputSubagentServerToolItemType = ClosedEnum<typeof OutputSubagentS
  * An openrouter:subagent server tool output item
  */
 export type OutputSubagentServerToolItem = {
+    /**
+     * EXPERIMENTAL — subject to change without notice. The `call_id` of the tool call that spawned this subagent. This id will also be included as the `subagent_id` on any `function_call` items created by the subagent. This must be returned in the request so the `function_call` can be matched with the correct subagent. A suspended `in_progress` item is announced once and never re-emitted or terminally closed — completion arrives as a new item with the same `call_id`.
+     */
+    callId?: string | undefined;
     /**
      * Error message when the subagent task did not produce an outcome.
      */
@@ -51,6 +55,7 @@ export declare const OutputSubagentServerToolItemType$outboundSchema: z.ZodEnum<
 export declare const OutputSubagentServerToolItem$inboundSchema: z.ZodType<OutputSubagentServerToolItem, unknown>;
 /** @internal */
 export type OutputSubagentServerToolItem$Outbound = {
+    call_id?: string | undefined;
     error?: string | undefined;
     id?: string | undefined;
     instance_name?: string | undefined;

package/esm/models/outputsubagentservertoolitem.js

@@ -15,6 +15,7 @@ export const OutputSubagentServerToolItemType$inboundSchema = z.enum(OutputSubag
 export const OutputSubagentServerToolItemType$outboundSchema = OutputSubagentServerToolItemType$inboundSchema;
 /** @internal */
 export const OutputSubagentServerToolItem$inboundSchema = z.object({
+    call_id: z.string().optional(),
     error: z.string().optional(),
     id: z.string().optional(),
     instance_name: z.string().optional(),
@@ -27,6 +28,7 @@ export const OutputSubagentServerToolItem$inboundSchema = z.object({
     type: OutputSubagentServerToolItemType$inboundSchema,
 }).transform((v) => {
     return remap$(v, {
+        "call_id": "callId",
         "instance_name": "instanceName",
         "task_description": "taskDescription",
         "task_name": "taskName",
@@ -34,6 +36,7 @@ export const OutputSubagentServerToolItem$inboundSchema = z.object({
 });
 /** @internal */
 export const OutputSubagentServerToolItem$outboundSchema = z.object({
+    callId: z.string().optional(),
     error: z.string().optional(),
     id: z.string().optional(),
     instanceName: z.string().optional(),
@@ -46,6 +49,7 @@ export const OutputSubagentServerToolItem$outboundSchema = z.object({
     type: OutputSubagentServerToolItemType$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
+        callId: "call_id",
         instanceName: "instance_name",
         taskDescription: "task_description",
         taskName: "task_name",

package/esm/models/shellcallitem.d.ts

@@ -15,6 +15,10 @@ export type ShellCallItemType = ClosedEnum<typeof ShellCallItemType>;
  */
 export type ShellCallItem = {
     action: ShellCallItemAction;
+    /**
+     * The raw tool-call arguments string as emitted by the model. Echo back unchanged when replaying history; used verbatim to preserve provider prompt-cache prefixes.
+     */
+    arguments?: string | null | undefined;
     callId: string;
     environment?: any | undefined;
     id?: string | null | undefined;
@@ -35,6 +39,7 @@ export declare const ShellCallItemType$outboundSchema: z.ZodEnum<typeof ShellCal
 /** @internal */
 export type ShellCallItem$Outbound = {
     action: ShellCallItemAction$Outbound;
+    arguments?: string | null | undefined;
     call_id: string;
     environment?: any | undefined;
     id?: string | null | undefined;

package/esm/models/shellcallitem.js

@@ -27,6 +27,7 @@ export const ShellCallItemType$outboundSchema = z.enum(ShellCallItemType);
 /** @internal */
 export const ShellCallItem$outboundSchema = z.object({
     action: z.lazy(() => ShellCallItemAction$outboundSchema),
+    arguments: z.nullable(z.string()).optional(),
     callId: z.string(),
     environment: z.any().optional(),
     id: z.nullable(z.string()).optional(),

package/esm/models/shellcalloutputcontent.d.ts

@@ -0,0 +1,74 @@
+import * as z from "zod/v4";
+import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type OutcomeTimeout = {
+    type: "timeout";
+    additionalProperties?: {
+        [k: string]: any;
+    } | undefined;
+};
+export type OutcomeExit = {
+    exitCode: number;
+    type: "exit";
+    additionalProperties?: {
+        [k: string]: any;
+    } | undefined;
+};
+export type Outcome = OutcomeExit | OutcomeTimeout | discriminatedUnionTypes.Unknown<"type">;
+/**
+ * Captured stdout and stderr for one command of a shell call, with its exit or timeout outcome.
+ */
+export type ShellCallOutputContent = {
+    outcome: OutcomeExit | OutcomeTimeout | discriminatedUnionTypes.Unknown<"type">;
+    stderr: string;
+    stdout: string;
+    additionalProperties?: {
+        [k: string]: any;
+    } | undefined;
+};
+/** @internal */
+export declare const OutcomeTimeout$inboundSchema: z.ZodType<OutcomeTimeout, unknown>;
+/** @internal */
+export type OutcomeTimeout$Outbound = {
+    type: "timeout";
+    [additionalProperties: string]: unknown;
+};
+/** @internal */
+export declare const OutcomeTimeout$outboundSchema: z.ZodType<OutcomeTimeout$Outbound, OutcomeTimeout>;
+export declare function outcomeTimeoutToJSON(outcomeTimeout: OutcomeTimeout): string;
+export declare function outcomeTimeoutFromJSON(jsonString: string): SafeParseResult<OutcomeTimeout, SDKValidationError>;
+/** @internal */
+export declare const OutcomeExit$inboundSchema: z.ZodType<OutcomeExit, unknown>;
+/** @internal */
+export type OutcomeExit$Outbound = {
+    exit_code: number;
+    type: "exit";
+    [additionalProperties: string]: unknown;
+};
+/** @internal */
+export declare const OutcomeExit$outboundSchema: z.ZodType<OutcomeExit$Outbound, OutcomeExit>;
+export declare function outcomeExitToJSON(outcomeExit: OutcomeExit): string;
+export declare function outcomeExitFromJSON(jsonString: string): SafeParseResult<OutcomeExit, SDKValidationError>;
+/** @internal */
+export declare const Outcome$inboundSchema: z.ZodType<Outcome, unknown>;
+/** @internal */
+export type Outcome$Outbound = OutcomeExit$Outbound | OutcomeTimeout$Outbound;
+/** @internal */
+export declare const Outcome$outboundSchema: z.ZodType<Outcome$Outbound, Outcome>;
+export declare function outcomeToJSON(outcome: Outcome): string;
+export declare function outcomeFromJSON(jsonString: string): SafeParseResult<Outcome, SDKValidationError>;
+/** @internal */
+export declare const ShellCallOutputContent$inboundSchema: z.ZodType<ShellCallOutputContent, unknown>;
+/** @internal */
+export type ShellCallOutputContent$Outbound = {
+    outcome: OutcomeExit$Outbound | OutcomeTimeout$Outbound;
+    stderr: string;
+    stdout: string;
+    [additionalProperties: string]: unknown;
+};
+/** @internal */
+export declare const ShellCallOutputContent$outboundSchema: z.ZodType<ShellCallOutputContent$Outbound, ShellCallOutputContent>;
+export declare function shellCallOutputContentToJSON(shellCallOutputContent: ShellCallOutputContent): string;
+export declare function shellCallOutputContentFromJSON(jsonString: string): SafeParseResult<ShellCallOutputContent, SDKValidationError>;
+//# sourceMappingURL=shellcalloutputcontent.d.ts.map

package/esm/models/shellcalloutputcontent.js

@@ -0,0 +1,109 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: ec44d931b43f
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { collectExtraKeys as collectExtraKeys$, safeParse, } from "../lib/schemas.js";
+import { discriminatedUnion } from "../types/discriminatedUnion.js";
+/** @internal */
+export const OutcomeTimeout$inboundSchema = collectExtraKeys$(z.object({
+    type: z.literal("timeout"),
+}).catchall(z.any()), "additionalProperties", true);
+/** @internal */
+export const OutcomeTimeout$outboundSchema = z.object({
+    type: z.literal("timeout"),
+    additionalProperties: z.record(z.string(), z.any()).optional(),
+}).transform((v) => {
+    return {
+        ...v.additionalProperties,
+        ...remap$(v, {
+            additionalProperties: null,
+        }),
+    };
+});
+export function outcomeTimeoutToJSON(outcomeTimeout) {
+    return JSON.stringify(OutcomeTimeout$outboundSchema.parse(outcomeTimeout));
+}
+export function outcomeTimeoutFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutcomeTimeout$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutcomeTimeout' from JSON`);
+}
+/** @internal */
+export const OutcomeExit$inboundSchema = collectExtraKeys$(z.object({
+    exit_code: z.int(),
+    type: z.literal("exit"),
+}).catchall(z.any()), "additionalProperties", true).transform((v) => {
+    return remap$(v, {
+        "exit_code": "exitCode",
+    });
+});
+/** @internal */
+export const OutcomeExit$outboundSchema = z.object({
+    exitCode: z.int(),
+    type: z.literal("exit"),
+    additionalProperties: z.record(z.string(), z.any()).optional(),
+}).transform((v) => {
+    return {
+        ...v.additionalProperties,
+        ...remap$(v, {
+            exitCode: "exit_code",
+            additionalProperties: null,
+        }),
+    };
+});
+export function outcomeExitToJSON(outcomeExit) {
+    return JSON.stringify(OutcomeExit$outboundSchema.parse(outcomeExit));
+}
+export function outcomeExitFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutcomeExit$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutcomeExit' from JSON`);
+}
+/** @internal */
+export const Outcome$inboundSchema = discriminatedUnion("type", {
+    exit: z.lazy(() => OutcomeExit$inboundSchema),
+    timeout: z.lazy(() => OutcomeTimeout$inboundSchema),
+});
+/** @internal */
+export const Outcome$outboundSchema = z
+    .union([
+    z.lazy(() => OutcomeExit$outboundSchema),
+    z.lazy(() => OutcomeTimeout$outboundSchema),
+]);
+export function outcomeToJSON(outcome) {
+    return JSON.stringify(Outcome$outboundSchema.parse(outcome));
+}
+export function outcomeFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Outcome$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Outcome' from JSON`);
+}
+/** @internal */
+export const ShellCallOutputContent$inboundSchema = collectExtraKeys$(z.object({
+    outcome: discriminatedUnion("type", {
+        exit: z.lazy(() => OutcomeExit$inboundSchema),
+        timeout: z.lazy(() => OutcomeTimeout$inboundSchema),
+    }),
+    stderr: z.string(),
+    stdout: z.string(),
+}).catchall(z.any()), "additionalProperties", true);
+/** @internal */
+export const ShellCallOutputContent$outboundSchema = z.object({
+    outcome: z.union([
+        z.lazy(() => OutcomeExit$outboundSchema),
+        z.lazy(() => OutcomeTimeout$outboundSchema),
+    ]),
+    stderr: z.string(),
+    stdout: z.string(),
+    additionalProperties: z.record(z.string(), z.any()).optional(),
+}).transform((v) => {
+    return {
+        ...v.additionalProperties,
+        ...remap$(v, {
+            additionalProperties: null,
+        }),
+    };
+});
+export function shellCallOutputContentToJSON(shellCallOutputContent) {
+    return JSON.stringify(ShellCallOutputContent$outboundSchema.parse(shellCallOutputContent));
+}
+export function shellCallOutputContentFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ShellCallOutputContent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ShellCallOutputContent' from JSON`);
+}
+//# sourceMappingURL=shellcalloutputcontent.js.map

package/esm/models/shellcalloutputitem.d.ts

@@ -1,14 +1,7 @@
 import * as z from "zod/v4";
 import { ClosedEnum } from "../types/enums.js";
+import { ShellCallOutputContent, ShellCallOutputContent$Outbound } from "./shellcalloutputcontent.js";
 import { ToolCallStatus } from "./toolcallstatus.js";
-export type ShellCallOutputItemOutput = {
-    content?: string | null | undefined;
-    exitCode?: number | null | undefined;
-    type: string;
-    additionalProperties?: {
-        [k: string]: any;
-    } | undefined;
-};
 export declare const ShellCallOutputItemType: {
     readonly ShellCallOutput: "shell_call_output";
 };
@@ -20,28 +13,18 @@ export type ShellCallOutputItem = {
     callId: string;
     id?: string | null | undefined;
     maxOutputLength?: number | null | undefined;
-    output: Array<ShellCallOutputItemOutput>;
+    output: Array<ShellCallOutputContent>;
     status?: ToolCallStatus | null | undefined;
     type: ShellCallOutputItemType;
 };
 /** @internal */
-export type ShellCallOutputItemOutput$Outbound = {
-    content?: string | null | undefined;
-    exit_code?: number | null | undefined;
-    type: string;
-    [additionalProperties: string]: unknown;
-};
-/** @internal */
-export declare const ShellCallOutputItemOutput$outboundSchema: z.ZodType<ShellCallOutputItemOutput$Outbound, ShellCallOutputItemOutput>;
-export declare function shellCallOutputItemOutputToJSON(shellCallOutputItemOutput: ShellCallOutputItemOutput): string;
-/** @internal */
 export declare const ShellCallOutputItemType$outboundSchema: z.ZodEnum<typeof ShellCallOutputItemType>;
 /** @internal */
 export type ShellCallOutputItem$Outbound = {
     call_id: string;
     id?: string | null | undefined;
     max_output_length?: number | null | undefined;
-    output: Array<ShellCallOutputItemOutput$Outbound>;
+    output: Array<ShellCallOutputContent$Outbound>;
     status?: string | null | undefined;
     type: string;
 };

package/esm/models/shellcalloutputitem.js

@@ -4,36 +4,19 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
+import { ShellCallOutputContent$outboundSchema, } from "./shellcalloutputcontent.js";
 import { ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
 export const ShellCallOutputItemType = {
     ShellCallOutput: "shell_call_output",
 };
 /** @internal */
-export const ShellCallOutputItemOutput$outboundSchema = z.object({
-    content: z.nullable(z.string()).optional(),
-    exitCode: z.nullable(z.int()).optional(),
-    type: z.string(),
-    additionalProperties: z.record(z.string(), z.any()).optional(),
-}).transform((v) => {
-    return {
-        ...v.additionalProperties,
-        ...remap$(v, {
-            exitCode: "exit_code",
-            additionalProperties: null,
-        }),
-    };
-});
-export function shellCallOutputItemOutputToJSON(shellCallOutputItemOutput) {
-    return JSON.stringify(ShellCallOutputItemOutput$outboundSchema.parse(shellCallOutputItemOutput));
-}
-/** @internal */
 export const ShellCallOutputItemType$outboundSchema = z.enum(ShellCallOutputItemType);
 /** @internal */
 export const ShellCallOutputItem$outboundSchema = z.object({
     callId: z.string(),
     id: z.nullable(z.string()).optional(),
     maxOutputLength: z.nullable(z.int()).optional(),
-    output: z.array(z.lazy(() => ShellCallOutputItemOutput$outboundSchema)),
+    output: z.array(ShellCallOutputContent$outboundSchema),
     status: z.nullable(ToolCallStatus$outboundSchema).optional(),
     type: ShellCallOutputItemType$outboundSchema,
 }).transform((v) => {

package/esm/models/subagentreasoning.d.ts

@@ -25,7 +25,7 @@ export type SubagentReasoning = {
      */
     effort?: SubagentReasoningEffort | undefined;
     /**
-     * Maximum number of reasoning tokens the subagent may use. Accepted and validated but not yet forwarded to the subagent call.
+     * Maximum number of reasoning tokens the subagent may use. Forwarded to the subagent call as `reasoning.max_tokens`.
      */
     maxTokens?: number | undefined;
 };

package/esm/models/subagentservertoolconfig.d.ts

@@ -5,6 +5,14 @@ import { SubagentReasoning, SubagentReasoning$Outbound } from "./subagentreasoni
  * Configuration for one openrouter:subagent server tool entry.
  */
 export type SubagentServerToolConfig = {
+    /**
+     * EXPERIMENTAL — subject to change without notice. When true, the subagent inherits every client function defined in the request's top-level `tools` list. Supported on the Responses API (`/api/v1/responses`) only; other APIs reject it with a `400`.
+     */
+    inheritFunctions?: boolean | undefined;
+    /**
+     * EXPERIMENTAL — subject to change without notice. Names of the top-level function tools that the subagent will inherit. Any tool that matches by name will be copied fully into the tools array of the subagent. When `inherit_functions` is `true`, this list does nothing, because every client function will be inherited by default. Names are trimmed before validation, so a whitespace-only name is rejected with a `400`. Supported on the Responses API (`/api/v1/responses`) only; other APIs reject it with a `400`.
+     */
+    inheritedFunctionNames?: Array<string> | undefined;
     /**
      * System instructions for the subagent. When omitted, the subagent responds with no system prompt of its own.
      */
@@ -14,7 +22,7 @@ export type SubagentServerToolConfig = {
      */
     maxCompletionTokens?: number | undefined;
     /**
-     * Maximum number of tool-calling steps the subagent may take during its agentic loop. Capped at 25. Only relevant when the subagent is given tools. Accepted and validated but not yet enforced on the subagent call.
+     * Maximum number of tool-calling steps the subagent may take during its agentic loop. Capped at 25. Only relevant when the subagent is given tools. Forwarded to the subagent call as `max_tool_calls`.
      */
     maxToolCalls?: number | undefined;
     /**
@@ -40,6 +48,8 @@ export type SubagentServerToolConfig = {
 };
 /** @internal */
 export type SubagentServerToolConfig$Outbound = {
+    inherit_functions?: boolean | undefined;
+    inherited_function_names?: Array<string> | undefined;
     instructions?: string | undefined;
     max_completion_tokens?: number | undefined;
     max_tool_calls?: number | undefined;

package/esm/models/subagentservertoolconfig.js

@@ -8,6 +8,8 @@ import { SubagentNestedTool$outboundSchema, } from "./subagentnestedtool.js";
 import { SubagentReasoning$outboundSchema, } from "./subagentreasoning.js";
 /** @internal */
 export const SubagentServerToolConfig$outboundSchema = z.object({
+    inheritFunctions: z.boolean().optional(),
+    inheritedFunctionNames: z.array(z.string()).optional(),
     instructions: z.string().optional(),
     maxCompletionTokens: z.int().optional(),
     maxToolCalls: z.int().optional(),
@@ -18,6 +20,8 @@ export const SubagentServerToolConfig$outboundSchema = z.object({
     tools: z.array(SubagentNestedTool$outboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {
+        inheritFunctions: "inherit_functions",
+        inheritedFunctionNames: "inherited_function_names",
         maxCompletionTokens: "max_completion_tokens",
         maxToolCalls: "max_tool_calls",
     });

package/jsr.json

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

package/package.json

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