@openrouter/sdk 0.12.35 → 0.13.7

package/esm/models/outputitems.js

@@ -5,16 +5,20 @@
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 import { discriminatedUnion } from "../types/discriminatedUnion.js";
+import { OutputAdvisorServerToolItem$inboundSchema, } from "./outputadvisorservertoolitem.js";
+import { OutputApplyPatchCallItem$inboundSchema, } from "./outputapplypatchcallitem.js";
 import { OutputApplyPatchServerToolItem$inboundSchema, } from "./outputapplypatchservertoolitem.js";
 import { OutputBashServerToolItem$inboundSchema, } from "./outputbashservertoolitem.js";
 import { OutputBrowserUseServerToolItem$inboundSchema, } from "./outputbrowseruseservertoolitem.js";
 import { OutputCodeInterpreterCallItem$inboundSchema, } from "./outputcodeinterpretercallitem.js";
 import { OutputCodeInterpreterServerToolItem$inboundSchema, } from "./outputcodeinterpreterservertoolitem.js";
 import { OutputComputerCallItem$inboundSchema, } from "./outputcomputercallitem.js";
+import { OutputCustomToolCallItem$inboundSchema, } from "./outputcustomtoolcallitem.js";
 import { OutputDatetimeItem$inboundSchema, } from "./outputdatetimeitem.js";
 import { OutputFileSearchCallItem$inboundSchema, } from "./outputfilesearchcallitem.js";
 import { OutputFileSearchServerToolItem$inboundSchema, } from "./outputfilesearchservertoolitem.js";
 import { OutputFunctionCallItem$inboundSchema, } from "./outputfunctioncallitem.js";
+import { OutputFusionServerToolItem$inboundSchema, } from "./outputfusionservertoolitem.js";
 import { OutputImageGenerationCallItem$inboundSchema, } from "./outputimagegenerationcallitem.js";
 import { OutputImageGenerationServerToolItem$inboundSchema, } from "./outputimagegenerationservertoolitem.js";
 import { OutputMcpServerToolItem$inboundSchema, } from "./outputmcpservertoolitem.js";
@@ -22,6 +26,9 @@ import { OutputMemoryServerToolItem$inboundSchema, } from "./outputmemoryservert
 import { OutputMessageItem$inboundSchema, } from "./outputmessageitem.js";
 import { OutputReasoningItem$inboundSchema, } from "./outputreasoningitem.js";
 import { OutputSearchModelsServerToolItem$inboundSchema, } from "./outputsearchmodelsservertoolitem.js";
+import { OutputShellCallItem$inboundSchema, } from "./outputshellcallitem.js";
+import { OutputShellCallOutputItem$inboundSchema, } from "./outputshellcalloutputitem.js";
+import { OutputSubagentServerToolItem$inboundSchema, } from "./outputsubagentservertoolitem.js";
 import { OutputTextEditorServerToolItem$inboundSchema, } from "./outputtexteditorservertoolitem.js";
 import { OutputToolSearchServerToolItem$inboundSchema, } from "./outputtoolsearchservertoolitem.js";
 import { OutputWebFetchServerToolItem$inboundSchema, } from "./outputwebfetchservertoolitem.js";
@@ -29,12 +36,15 @@ import { OutputWebSearchCallItem$inboundSchema, } from "./outputwebsearchcallite
 import { OutputWebSearchServerToolItem$inboundSchema, } from "./outputwebsearchservertoolitem.js";
 /** @internal */
 export const OutputItems$inboundSchema = discriminatedUnion("type", {
+    apply_patch_call: OutputApplyPatchCallItem$inboundSchema,
     code_interpreter_call: OutputCodeInterpreterCallItem$inboundSchema.and(z.object({ type: z.literal("code_interpreter_call") })),
     computer_call: OutputComputerCallItem$inboundSchema.and(z.object({ type: z.literal("computer_call") })),
+    custom_tool_call: OutputCustomToolCallItem$inboundSchema.and(z.object({ type: z.literal("custom_tool_call") })),
     file_search_call: OutputFileSearchCallItem$inboundSchema.and(z.object({ type: z.literal("file_search_call") })),
     function_call: OutputFunctionCallItem$inboundSchema.and(z.object({ type: z.literal("function_call") })),
     image_generation_call: OutputImageGenerationCallItem$inboundSchema.and(z.object({ type: z.literal("image_generation_call") })),
     message: OutputMessageItem$inboundSchema,
+    ["openrouter:advisor"]: OutputAdvisorServerToolItem$inboundSchema.and(z.object({ type: z.literal("openrouter:advisor") })),
     ["openrouter:apply_patch"]: OutputApplyPatchServerToolItem$inboundSchema
         .and(z.object({ type: z.literal("openrouter:apply_patch") })),
     ["openrouter:bash"]: OutputBashServerToolItem$inboundSchema.and(z.object({ type: z.literal("openrouter:bash") })),
@@ -45,9 +55,11 @@ export const OutputItems$inboundSchema = discriminatedUnion("type", {
     ["openrouter:experimental__search_models"]: OutputSearchModelsServerToolItem$inboundSchema.and(z.object({ type: z.literal("openrouter:experimental__search_models") })),
     ["openrouter:file_search"]: OutputFileSearchServerToolItem$inboundSchema
         .and(z.object({ type: z.literal("openrouter:file_search") })),
+    ["openrouter:fusion"]: OutputFusionServerToolItem$inboundSchema.and(z.object({ type: z.literal("openrouter:fusion") })),
     ["openrouter:image_generation"]: OutputImageGenerationServerToolItem$inboundSchema.and(z.object({ type: z.literal("openrouter:image_generation") })),
     ["openrouter:mcp"]: OutputMcpServerToolItem$inboundSchema.and(z.object({ type: z.literal("openrouter:mcp") })),
     ["openrouter:memory"]: OutputMemoryServerToolItem$inboundSchema.and(z.object({ type: z.literal("openrouter:memory") })),
+    ["openrouter:subagent"]: OutputSubagentServerToolItem$inboundSchema.and(z.object({ type: z.literal("openrouter:subagent") })),
     ["openrouter:text_editor"]: OutputTextEditorServerToolItem$inboundSchema
         .and(z.object({ type: z.literal("openrouter:text_editor") })),
     ["openrouter:tool_search"]: OutputToolSearchServerToolItem$inboundSchema
@@ -55,6 +67,8 @@ export const OutputItems$inboundSchema = discriminatedUnion("type", {
     ["openrouter:web_fetch"]: OutputWebFetchServerToolItem$inboundSchema.and(z.object({ type: z.literal("openrouter:web_fetch") })),
     ["openrouter:web_search"]: OutputWebSearchServerToolItem$inboundSchema.and(z.object({ type: z.literal("openrouter:web_search") })),
     reasoning: OutputReasoningItem$inboundSchema,
+    shell_call: OutputShellCallItem$inboundSchema,
+    shell_call_output: OutputShellCallOutputItem$inboundSchema,
     web_search_call: OutputWebSearchCallItem$inboundSchema.and(z.object({ type: z.literal("web_search_call") })),
 });
 export function outputItemsFromJSON(jsonString) {

package/esm/models/outputshellcallitem.d.ts

@@ -0,0 +1,29 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ShellCallStatus } from "./shellcallstatus.js";
+export type OutputShellCallItemAction = {
+    commands: Array<string>;
+    maxOutputLength: number | null;
+    timeoutMs: number | null;
+};
+/**
+ * A native `shell_call` output item matching OpenAI's Responses API shape. Emitted for the sandbox-backed `shell` tool.
+ */
+export type OutputShellCallItem = {
+    action?: OutputShellCallItemAction | undefined;
+    callId: string;
+    id: string;
+    /**
+     * Status of a shell call or its output.
+     */
+    status: ShellCallStatus;
+    type: "shell_call";
+};
+/** @internal */
+export declare const OutputShellCallItemAction$inboundSchema: z.ZodType<OutputShellCallItemAction, unknown>;
+export declare function outputShellCallItemActionFromJSON(jsonString: string): SafeParseResult<OutputShellCallItemAction, SDKValidationError>;
+/** @internal */
+export declare const OutputShellCallItem$inboundSchema: z.ZodType<OutputShellCallItem, unknown>;
+export declare function outputShellCallItemFromJSON(jsonString: string): SafeParseResult<OutputShellCallItem, SDKValidationError>;
+//# sourceMappingURL=outputshellcallitem.d.ts.map

package/esm/models/outputshellcallitem.js

@@ -0,0 +1,38 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: d8b35b2daab6
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ShellCallStatus$inboundSchema, } from "./shellcallstatus.js";
+/** @internal */
+export const OutputShellCallItemAction$inboundSchema = z.object({
+    commands: z.array(z.string()),
+    max_output_length: z.nullable(z.int()),
+    timeout_ms: z.nullable(z.int()),
+}).transform((v) => {
+    return remap$(v, {
+        "max_output_length": "maxOutputLength",
+        "timeout_ms": "timeoutMs",
+    });
+});
+export function outputShellCallItemActionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputShellCallItemAction$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputShellCallItemAction' from JSON`);
+}
+/** @internal */
+export const OutputShellCallItem$inboundSchema = z.object({
+    action: z.lazy(() => OutputShellCallItemAction$inboundSchema).optional(),
+    call_id: z.string(),
+    id: z.string(),
+    status: ShellCallStatus$inboundSchema,
+    type: z.literal("shell_call"),
+}).transform((v) => {
+    return remap$(v, {
+        "call_id": "callId",
+    });
+});
+export function outputShellCallItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputShellCallItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputShellCallItem' from JSON`);
+}
+//# sourceMappingURL=outputshellcallitem.js.map

package/esm/models/outputshellcalloutputitem.d.ts

@@ -0,0 +1,48 @@
+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";
+import { ShellCallStatus } from "./shellcallstatus.js";
+export type OutcomeTimeout = {
+    type: "timeout";
+};
+export type OutcomeExit = {
+    exitCode: number;
+    type: "exit";
+};
+export type Outcome = OutcomeExit | OutcomeTimeout | discriminatedUnionTypes.Unknown<"type">;
+export type OutputShellCallOutputItemOutput = {
+    outcome: OutcomeExit | OutcomeTimeout | discriminatedUnionTypes.Unknown<"type">;
+    stderr: string;
+    stdout: string;
+};
+/**
+ * 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;
+    id: string;
+    maxOutputLength?: number | null | undefined;
+    output: Array<OutputShellCallOutputItemOutput>;
+    /**
+     * Status of a shell call or its output.
+     */
+    status: ShellCallStatus;
+    type: "shell_call_output";
+};
+/** @internal */
+export declare const OutcomeTimeout$inboundSchema: z.ZodType<OutcomeTimeout, unknown>;
+export declare function outcomeTimeoutFromJSON(jsonString: string): SafeParseResult<OutcomeTimeout, SDKValidationError>;
+/** @internal */
+export declare const OutcomeExit$inboundSchema: z.ZodType<OutcomeExit, unknown>;
+export declare function outcomeExitFromJSON(jsonString: string): SafeParseResult<OutcomeExit, SDKValidationError>;
+/** @internal */
+export declare const Outcome$inboundSchema: z.ZodType<Outcome, unknown>;
+export declare function outcomeFromJSON(jsonString: string): SafeParseResult<Outcome, SDKValidationError>;
+/** @internal */
+export declare const OutputShellCallOutputItemOutput$inboundSchema: z.ZodType<OutputShellCallOutputItemOutput, unknown>;
+export declare function outputShellCallOutputItemOutputFromJSON(jsonString: string): SafeParseResult<OutputShellCallOutputItemOutput, 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

@@ -0,0 +1,67 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: a933ffbb5346
+ */
+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 { 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)),
+    status: ShellCallStatus$inboundSchema,
+    type: z.literal("shell_call_output"),
+}).transform((v) => {
+    return remap$(v, {
+        "call_id": "callId",
+        "max_output_length": "maxOutputLength",
+    });
+});
+export function outputShellCallOutputItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputShellCallOutputItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputShellCallOutputItem' from JSON`);
+}
+//# sourceMappingURL=outputshellcalloutputitem.js.map

package/esm/models/outputsubagentservertoolitem.d.ts

@@ -0,0 +1,59 @@
+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 { ToolCallStatus } from "./toolcallstatus.js";
+export declare const OutputSubagentServerToolItemType: {
+    readonly OpenrouterSubagent: "openrouter:subagent";
+};
+export type OutputSubagentServerToolItemType = ClosedEnum<typeof OutputSubagentServerToolItemType>;
+/**
+ * An openrouter:subagent server tool output item
+ */
+export type OutputSubagentServerToolItem = {
+    /**
+     * Error message when the subagent task did not produce an outcome.
+     */
+    error?: string | undefined;
+    id?: string | undefined;
+    /**
+     * Slug of the worker model that executed the task.
+     */
+    model?: string | undefined;
+    /**
+     * The worker model's result (the outcome text returned to the delegating model).
+     */
+    outcome?: string | undefined;
+    status: ToolCallStatus;
+    /**
+     * The task description the delegating model sent to the worker.
+     */
+    taskDescription?: string | undefined;
+    /**
+     * The short task identifier the delegating model supplied.
+     */
+    taskName?: string | undefined;
+    type: OutputSubagentServerToolItemType;
+};
+/** @internal */
+export declare const OutputSubagentServerToolItemType$inboundSchema: z.ZodEnum<typeof OutputSubagentServerToolItemType>;
+/** @internal */
+export declare const OutputSubagentServerToolItemType$outboundSchema: z.ZodEnum<typeof OutputSubagentServerToolItemType>;
+/** @internal */
+export declare const OutputSubagentServerToolItem$inboundSchema: z.ZodType<OutputSubagentServerToolItem, unknown>;
+/** @internal */
+export type OutputSubagentServerToolItem$Outbound = {
+    error?: string | undefined;
+    id?: string | undefined;
+    model?: string | undefined;
+    outcome?: string | undefined;
+    status: string;
+    task_description?: string | undefined;
+    task_name?: string | undefined;
+    type: string;
+};
+/** @internal */
+export declare const OutputSubagentServerToolItem$outboundSchema: z.ZodType<OutputSubagentServerToolItem$Outbound, OutputSubagentServerToolItem>;
+export declare function outputSubagentServerToolItemToJSON(outputSubagentServerToolItem: OutputSubagentServerToolItem): string;
+export declare function outputSubagentServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputSubagentServerToolItem, SDKValidationError>;
+//# sourceMappingURL=outputsubagentservertoolitem.d.ts.map

package/esm/models/outputsubagentservertoolitem.js

@@ -0,0 +1,54 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 9161bc044a98
+ */
+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 OutputSubagentServerToolItemType = {
+    OpenrouterSubagent: "openrouter:subagent",
+};
+/** @internal */
+export const OutputSubagentServerToolItemType$inboundSchema = z.enum(OutputSubagentServerToolItemType);
+/** @internal */
+export const OutputSubagentServerToolItemType$outboundSchema = OutputSubagentServerToolItemType$inboundSchema;
+/** @internal */
+export const OutputSubagentServerToolItem$inboundSchema = z.object({
+    error: z.string().optional(),
+    id: z.string().optional(),
+    model: z.string().optional(),
+    outcome: z.string().optional(),
+    status: ToolCallStatus$inboundSchema,
+    task_description: z.string().optional(),
+    task_name: z.string().optional(),
+    type: OutputSubagentServerToolItemType$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "task_description": "taskDescription",
+        "task_name": "taskName",
+    });
+});
+/** @internal */
+export const OutputSubagentServerToolItem$outboundSchema = z.object({
+    error: z.string().optional(),
+    id: z.string().optional(),
+    model: z.string().optional(),
+    outcome: z.string().optional(),
+    status: ToolCallStatus$outboundSchema,
+    taskDescription: z.string().optional(),
+    taskName: z.string().optional(),
+    type: OutputSubagentServerToolItemType$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        taskDescription: "task_description",
+        taskName: "task_name",
+    });
+});
+export function outputSubagentServerToolItemToJSON(outputSubagentServerToolItem) {
+    return JSON.stringify(OutputSubagentServerToolItem$outboundSchema.parse(outputSubagentServerToolItem));
+}
+export function outputSubagentServerToolItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputSubagentServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputSubagentServerToolItem' from JSON`);
+}
+//# sourceMappingURL=outputsubagentservertoolitem.js.map

package/esm/models/outputwebsearchcallitem.d.ts

@@ -26,7 +26,7 @@ export declare const TypeWebSearchCall: {
 };
 export type TypeWebSearchCall = ClosedEnum<typeof TypeWebSearchCall>;
 export type OutputWebSearchCallItem = {
-    action: OutputWebSearchCallItemActionSearch | ActionOpenPage | ActionFindInPage | discriminatedUnionTypes.Unknown<"type">;
+    action?: OutputWebSearchCallItemActionSearch | ActionOpenPage | ActionFindInPage | discriminatedUnionTypes.Unknown<"type"> | undefined;
     id: string;
     status: WebSearchStatus;
     type: TypeWebSearchCall;
@@ -83,7 +83,7 @@ export declare const TypeWebSearchCall$outboundSchema: z.ZodEnum<typeof TypeWebS
 export declare const OutputWebSearchCallItem$inboundSchema: z.ZodType<OutputWebSearchCallItem, unknown>;
 /** @internal */
 export type OutputWebSearchCallItem$Outbound = {
-    action: OutputWebSearchCallItemActionSearch$Outbound | ActionOpenPage$Outbound | ActionFindInPage$Outbound;
+    action?: OutputWebSearchCallItemActionSearch$Outbound | ActionOpenPage$Outbound | ActionFindInPage$Outbound | undefined;
     id: string;
     status: string;
     type: string;

package/esm/models/outputwebsearchcallitem.js

@@ -93,7 +93,7 @@ export const OutputWebSearchCallItem$inboundSchema = z.object({
         search: z.lazy(() => OutputWebSearchCallItemActionSearch$inboundSchema),
         open_page: z.lazy(() => ActionOpenPage$inboundSchema),
         find_in_page: z.lazy(() => ActionFindInPage$inboundSchema),
-    }),
+    }).optional(),
     id: z.string(),
     status: WebSearchStatus$inboundSchema,
     type: TypeWebSearchCall$inboundSchema,
@@ -104,7 +104,7 @@ export const OutputWebSearchCallItem$outboundSchema = z.object({
         z.lazy(() => OutputWebSearchCallItemActionSearch$outboundSchema),
         z.lazy(() => ActionOpenPage$outboundSchema),
         z.lazy(() => ActionFindInPage$outboundSchema),
-    ]),
+    ]).optional(),
     id: z.string(),
     status: WebSearchStatus$outboundSchema,
     type: TypeWebSearchCall$outboundSchema,

package/esm/models/outputwebsearchservertoolitem.d.ts

@@ -7,7 +7,7 @@ export declare const OutputWebSearchServerToolItemTypeURL: {
     readonly Url: "url";
 };
 export type OutputWebSearchServerToolItemTypeURL = ClosedEnum<typeof OutputWebSearchServerToolItemTypeURL>;
-export type Source = {
+export type OutputWebSearchServerToolItemSource = {
     type: OutputWebSearchServerToolItemTypeURL;
     url: string;
 };
@@ -20,7 +20,7 @@ export type OutputWebSearchServerToolItemTypeSearch = ClosedEnum<typeof OutputWe
  */
 export type OutputWebSearchServerToolItemAction = {
     query: string;
-    sources?: Array<Source> | undefined;
+    sources?: Array<OutputWebSearchServerToolItemSource> | undefined;
     type: OutputWebSearchServerToolItemTypeSearch;
 };
 export declare const OutputWebSearchServerToolItemTypeOpenrouterWebSearch: {
@@ -44,16 +44,16 @@ export declare const OutputWebSearchServerToolItemTypeURL$inboundSchema: z.ZodEn
 /** @internal */
 export declare const OutputWebSearchServerToolItemTypeURL$outboundSchema: z.ZodEnum<typeof OutputWebSearchServerToolItemTypeURL>;
 /** @internal */
-export declare const Source$inboundSchema: z.ZodType<Source, unknown>;
+export declare const OutputWebSearchServerToolItemSource$inboundSchema: z.ZodType<OutputWebSearchServerToolItemSource, unknown>;
 /** @internal */
-export type Source$Outbound = {
+export type OutputWebSearchServerToolItemSource$Outbound = {
     type: string;
     url: string;
 };
 /** @internal */
-export declare const Source$outboundSchema: z.ZodType<Source$Outbound, Source>;
-export declare function sourceToJSON(source: Source): string;
-export declare function sourceFromJSON(jsonString: string): SafeParseResult<Source, SDKValidationError>;
+export declare const OutputWebSearchServerToolItemSource$outboundSchema: z.ZodType<OutputWebSearchServerToolItemSource$Outbound, OutputWebSearchServerToolItemSource>;
+export declare function outputWebSearchServerToolItemSourceToJSON(outputWebSearchServerToolItemSource: OutputWebSearchServerToolItemSource): string;
+export declare function outputWebSearchServerToolItemSourceFromJSON(jsonString: string): SafeParseResult<OutputWebSearchServerToolItemSource, SDKValidationError>;
 /** @internal */
 export declare const OutputWebSearchServerToolItemTypeSearch$inboundSchema: z.ZodEnum<typeof OutputWebSearchServerToolItemTypeSearch>;
 /** @internal */
@@ -63,7 +63,7 @@ export declare const OutputWebSearchServerToolItemAction$inboundSchema: z.ZodTyp
 /** @internal */
 export type OutputWebSearchServerToolItemAction$Outbound = {
     query: string;
-    sources?: Array<Source$Outbound> | undefined;
+    sources?: Array<OutputWebSearchServerToolItemSource$Outbound> | undefined;
     type: string;
 };
 /** @internal */

package/esm/models/outputwebsearchservertoolitem.js

@@ -19,21 +19,20 @@ export const OutputWebSearchServerToolItemTypeURL$inboundSchema = z.enum(OutputW
 /** @internal */
 export const OutputWebSearchServerToolItemTypeURL$outboundSchema = OutputWebSearchServerToolItemTypeURL$inboundSchema;
 /** @internal */
-export const Source$inboundSchema = z.object({
+export const OutputWebSearchServerToolItemSource$inboundSchema = z.object({
     type: OutputWebSearchServerToolItemTypeURL$inboundSchema,
     url: z.string(),
 });
 /** @internal */
-export const Source$outboundSchema = z
-    .object({
+export const OutputWebSearchServerToolItemSource$outboundSchema = z.object({
     type: OutputWebSearchServerToolItemTypeURL$outboundSchema,
     url: z.string(),
 });
-export function sourceToJSON(source) {
-    return JSON.stringify(Source$outboundSchema.parse(source));
+export function outputWebSearchServerToolItemSourceToJSON(outputWebSearchServerToolItemSource) {
+    return JSON.stringify(OutputWebSearchServerToolItemSource$outboundSchema.parse(outputWebSearchServerToolItemSource));
 }
-export function sourceFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => Source$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Source' from JSON`);
+export function outputWebSearchServerToolItemSourceFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputWebSearchServerToolItemSource$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputWebSearchServerToolItemSource' from JSON`);
 }
 /** @internal */
 export const OutputWebSearchServerToolItemTypeSearch$inboundSchema = z.enum(OutputWebSearchServerToolItemTypeSearch);
@@ -42,13 +41,13 @@ export const OutputWebSearchServerToolItemTypeSearch$outboundSchema = OutputWebS
 /** @internal */
 export const OutputWebSearchServerToolItemAction$inboundSchema = z.object({
     query: z.string(),
-    sources: z.array(z.lazy(() => Source$inboundSchema)).optional(),
+    sources: z.array(z.lazy(() => OutputWebSearchServerToolItemSource$inboundSchema)).optional(),
     type: OutputWebSearchServerToolItemTypeSearch$inboundSchema,
 });
 /** @internal */
 export const OutputWebSearchServerToolItemAction$outboundSchema = z.object({
     query: z.string(),
-    sources: z.array(z.lazy(() => Source$outboundSchema)).optional(),
+    sources: z.array(z.lazy(() => OutputWebSearchServerToolItemSource$outboundSchema)).optional(),
     type: OutputWebSearchServerToolItemTypeSearch$outboundSchema,
 });
 export function outputWebSearchServerToolItemActionToJSON(outputWebSearchServerToolItemAction) {

package/esm/models/pipelinestage.d.ts

@@ -10,6 +10,7 @@ export type PipelineStage = {
     guardrailId?: string | undefined;
     guardrailScope?: string | undefined;
     name: string;
+    summary?: string | undefined;
     /**
      * Categorical kind of a pipeline stage. Multiple plugins can share a type (e.g. all guardrail-level plugins emit `guardrail`); the `name` field disambiguates which plugin emitted it.
      */

package/esm/models/pipelinestage.js

@@ -14,6 +14,7 @@ export const PipelineStage$inboundSchema = z
     guardrail_id: z.string().optional(),
     guardrail_scope: z.string().optional(),
     name: z.string(),
+    summary: z.string().optional(),
     type: PipelineStageType$inboundSchema,
 }).transform((v) => {
     return remap$(v, {

package/esm/models/preset.d.ts

@@ -0,0 +1,27 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { PresetStatus } from "./presetstatus.js";
+/**
+ * A preset without version details.
+ */
+export type Preset = {
+    createdAt: string;
+    creatorUserId: string | null;
+    description: string | null;
+    designatedVersionId: string | null;
+    id: string;
+    name: string;
+    slug: string;
+    /**
+     * The status of a preset.
+     */
+    status: PresetStatus;
+    statusUpdatedAt: string | null;
+    updatedAt: string;
+    workspaceId: string | null;
+};
+/** @internal */
+export declare const Preset$inboundSchema: z.ZodType<Preset, unknown>;
+export declare function presetFromJSON(jsonString: string): SafeParseResult<Preset, SDKValidationError>;
+//# sourceMappingURL=preset.d.ts.map

package/esm/models/preset.js

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: f9cbbbd64494
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { PresetStatus$inboundSchema } from "./presetstatus.js";
+/** @internal */
+export const Preset$inboundSchema = z.object({
+    created_at: z.string(),
+    creator_user_id: z.nullable(z.string()),
+    description: z.nullable(z.string()),
+    designated_version_id: z.nullable(z.string()),
+    id: z.string(),
+    name: z.string(),
+    slug: z.string(),
+    status: PresetStatus$inboundSchema,
+    status_updated_at: z.nullable(z.string()),
+    updated_at: z.string(),
+    workspace_id: z.nullable(z.string()),
+}).transform((v) => {
+    return remap$(v, {
+        "created_at": "createdAt",
+        "creator_user_id": "creatorUserId",
+        "designated_version_id": "designatedVersionId",
+        "status_updated_at": "statusUpdatedAt",
+        "updated_at": "updatedAt",
+        "workspace_id": "workspaceId",
+    });
+});
+export function presetFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Preset$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Preset' from JSON`);
+}
+//# sourceMappingURL=preset.js.map

package/esm/models/presetdesignatedversion.d.ts

@@ -0,0 +1,22 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * A specific version of a preset, containing config and optional system prompt.
+ */
+export type PresetDesignatedVersion = {
+    config: {
+        [k: string]: any | null;
+    };
+    createdAt: string;
+    creatorId: string;
+    id: string;
+    presetId: string;
+    systemPrompt: string | null;
+    updatedAt: string;
+    version: number;
+};
+/** @internal */
+export declare const PresetDesignatedVersion$inboundSchema: z.ZodType<PresetDesignatedVersion, unknown>;
+export declare function presetDesignatedVersionFromJSON(jsonString: string): SafeParseResult<PresetDesignatedVersion, SDKValidationError>;
+//# sourceMappingURL=presetdesignatedversion.d.ts.map

package/esm/models/presetdesignatedversion.js

@@ -0,0 +1,30 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 259a18622bbe
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const PresetDesignatedVersion$inboundSchema = z.object({
+    config: z.record(z.string(), z.nullable(z.any())),
+    created_at: z.string(),
+    creator_id: z.string(),
+    id: z.string(),
+    preset_id: z.string(),
+    system_prompt: z.nullable(z.string()),
+    updated_at: z.string(),
+    version: z.int(),
+}).transform((v) => {
+    return remap$(v, {
+        "created_at": "createdAt",
+        "creator_id": "creatorId",
+        "preset_id": "presetId",
+        "system_prompt": "systemPrompt",
+        "updated_at": "updatedAt",
+    });
+});
+export function presetDesignatedVersionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => PresetDesignatedVersion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'PresetDesignatedVersion' from JSON`);
+}
+//# sourceMappingURL=presetdesignatedversion.js.map