@openrouter/sdk 0.12.35 → 0.13.7

package/esm/models/inputsunion.js

@@ -4,26 +4,42 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
+import { ApplyPatchCallItem$outboundSchema, } from "./applypatchcallitem.js";
+import { ApplyPatchCallOutputItem$outboundSchema, } from "./applypatchcalloutputitem.js";
+import { CompactionItem$outboundSchema, } from "./compactionitem.js";
+import { CustomToolCallItem$outboundSchema, } from "./customtoolcallitem.js";
+import { CustomToolCallOutputItem$outboundSchema, } from "./customtoolcalloutputitem.js";
 import { EasyInputMessage$outboundSchema, } from "./easyinputmessage.js";
 import { FunctionCallItem$outboundSchema, } from "./functioncallitem.js";
 import { FunctionCallOutputItem$outboundSchema, } from "./functioncalloutputitem.js";
 import { InputMessageItem$outboundSchema, } from "./inputmessageitem.js";
+import { ItemReferenceItem$outboundSchema, } from "./itemreferenceitem.js";
+import { LocalShellCallItem$outboundSchema, } from "./localshellcallitem.js";
+import { LocalShellCallOutputItem$outboundSchema, } from "./localshellcalloutputitem.js";
+import { McpApprovalRequestItem$outboundSchema, } from "./mcpapprovalrequestitem.js";
+import { McpApprovalResponseItem$outboundSchema, } from "./mcpapprovalresponseitem.js";
+import { McpCallItem$outboundSchema, } from "./mcpcallitem.js";
+import { McpListToolsItem$outboundSchema, } from "./mcplisttoolsitem.js";
 import { OpenAIResponsesRefusalContent$outboundSchema, } from "./openairesponsesrefusalcontent.js";
+import { OutputAdvisorServerToolItem$outboundSchema, } from "./outputadvisorservertoolitem.js";
 import { OutputApplyPatchServerToolItem$outboundSchema, } from "./outputapplypatchservertoolitem.js";
 import { OutputBashServerToolItem$outboundSchema, } from "./outputbashservertoolitem.js";
 import { OutputBrowserUseServerToolItem$outboundSchema, } from "./outputbrowseruseservertoolitem.js";
 import { OutputCodeInterpreterCallItem$outboundSchema, } from "./outputcodeinterpretercallitem.js";
 import { OutputCodeInterpreterServerToolItem$outboundSchema, } from "./outputcodeinterpreterservertoolitem.js";
 import { OutputComputerCallItem$outboundSchema, } from "./outputcomputercallitem.js";
+import { OutputCustomToolCallItem$outboundSchema, } from "./outputcustomtoolcallitem.js";
 import { OutputDatetimeItem$outboundSchema, } from "./outputdatetimeitem.js";
 import { OutputFileSearchCallItem$outboundSchema, } from "./outputfilesearchcallitem.js";
 import { OutputFileSearchServerToolItem$outboundSchema, } from "./outputfilesearchservertoolitem.js";
 import { OutputFunctionCallItem$outboundSchema, } from "./outputfunctioncallitem.js";
+import { OutputFusionServerToolItem$outboundSchema, } from "./outputfusionservertoolitem.js";
 import { OutputImageGenerationCallItem$outboundSchema, } from "./outputimagegenerationcallitem.js";
 import { OutputImageGenerationServerToolItem$outboundSchema, } from "./outputimagegenerationservertoolitem.js";
 import { OutputMcpServerToolItem$outboundSchema, } from "./outputmcpservertoolitem.js";
 import { OutputMemoryServerToolItem$outboundSchema, } from "./outputmemoryservertoolitem.js";
 import { OutputSearchModelsServerToolItem$outboundSchema, } from "./outputsearchmodelsservertoolitem.js";
+import { OutputSubagentServerToolItem$outboundSchema, } from "./outputsubagentservertoolitem.js";
 import { OutputTextEditorServerToolItem$outboundSchema, } from "./outputtexteditorservertoolitem.js";
 import { OutputToolSearchServerToolItem$outboundSchema, } from "./outputtoolsearchservertoolitem.js";
 import { OutputWebFetchServerToolItem$outboundSchema, } from "./outputwebfetchservertoolitem.js";
@@ -34,6 +50,8 @@ import { ReasoningItem$outboundSchema, } from "./reasoningitem.js";
 import { ReasoningSummaryText$outboundSchema, } from "./reasoningsummarytext.js";
 import { ReasoningTextContent$outboundSchema, } from "./reasoningtextcontent.js";
 import { ResponseOutputText$outboundSchema, } from "./responseoutputtext.js";
+import { ShellCallItem$outboundSchema, } from "./shellcallitem.js";
+import { ShellCallOutputItem$outboundSchema, } from "./shellcalloutputitem.js";
 export const InputsStatusInProgress2 = {
     InProgress: "in_progress",
 };
@@ -189,16 +207,29 @@ export function inputsMessageToJSON(inputsMessage) {
 export const InputsUnion1$outboundSchema = z.union([
     OutputCodeInterpreterCallItem$outboundSchema,
     FunctionCallItem$outboundSchema,
+    LocalShellCallItem$outboundSchema,
+    McpApprovalRequestItem$outboundSchema,
+    McpCallItem$outboundSchema,
+    ApplyPatchCallItem$outboundSchema,
     z.lazy(() => InputsMessage$outboundSchema),
     OutputFunctionCallItem$outboundSchema,
-    OutputWebSearchCallItem$outboundSchema,
+    OutputCustomToolCallItem$outboundSchema,
     OutputFileSearchCallItem$outboundSchema,
     OutputComputerCallItem$outboundSchema,
     OutputDatetimeItem$outboundSchema,
+    McpListToolsItem$outboundSchema,
+    CustomToolCallItem$outboundSchema,
     ReasoningItem$outboundSchema,
     FunctionCallOutputItem$outboundSchema,
+    ApplyPatchCallOutputItem$outboundSchema,
     z.lazy(() => InputsReasoning$outboundSchema),
+    OutputWebSearchCallItem$outboundSchema,
     OutputImageGenerationCallItem$outboundSchema,
+    LocalShellCallOutputItem$outboundSchema,
+    ShellCallItem$outboundSchema,
+    ShellCallOutputItem$outboundSchema,
+    McpApprovalResponseItem$outboundSchema,
+    CustomToolCallOutputItem$outboundSchema,
     OutputWebSearchServerToolItem$outboundSchema,
     OutputCodeInterpreterServerToolItem$outboundSchema,
     OutputFileSearchServerToolItem$outboundSchema,
@@ -212,6 +243,11 @@ export const InputsUnion1$outboundSchema = z.union([
     OutputMemoryServerToolItem$outboundSchema,
     OutputMcpServerToolItem$outboundSchema,
     OutputSearchModelsServerToolItem$outboundSchema,
+    OutputFusionServerToolItem$outboundSchema,
+    OutputAdvisorServerToolItem$outboundSchema,
+    OutputSubagentServerToolItem$outboundSchema,
+    CompactionItem$outboundSchema,
+    ItemReferenceItem$outboundSchema,
     EasyInputMessage$outboundSchema,
     InputMessageItem$outboundSchema,
 ]);
@@ -224,16 +260,29 @@ export const InputsUnion$outboundSchema = z.union([
     z.array(z.union([
         OutputCodeInterpreterCallItem$outboundSchema,
         FunctionCallItem$outboundSchema,
+        LocalShellCallItem$outboundSchema,
+        McpApprovalRequestItem$outboundSchema,
+        McpCallItem$outboundSchema,
+        ApplyPatchCallItem$outboundSchema,
         z.lazy(() => InputsMessage$outboundSchema),
         OutputFunctionCallItem$outboundSchema,
-        OutputWebSearchCallItem$outboundSchema,
+        OutputCustomToolCallItem$outboundSchema,
         OutputFileSearchCallItem$outboundSchema,
         OutputComputerCallItem$outboundSchema,
         OutputDatetimeItem$outboundSchema,
+        McpListToolsItem$outboundSchema,
+        CustomToolCallItem$outboundSchema,
         ReasoningItem$outboundSchema,
         FunctionCallOutputItem$outboundSchema,
+        ApplyPatchCallOutputItem$outboundSchema,
         z.lazy(() => InputsReasoning$outboundSchema),
+        OutputWebSearchCallItem$outboundSchema,
         OutputImageGenerationCallItem$outboundSchema,
+        LocalShellCallOutputItem$outboundSchema,
+        ShellCallItem$outboundSchema,
+        ShellCallOutputItem$outboundSchema,
+        McpApprovalResponseItem$outboundSchema,
+        CustomToolCallOutputItem$outboundSchema,
         OutputWebSearchServerToolItem$outboundSchema,
         OutputCodeInterpreterServerToolItem$outboundSchema,
         OutputFileSearchServerToolItem$outboundSchema,
@@ -247,6 +296,11 @@ export const InputsUnion$outboundSchema = z.union([
         OutputMemoryServerToolItem$outboundSchema,
         OutputMcpServerToolItem$outboundSchema,
         OutputSearchModelsServerToolItem$outboundSchema,
+        OutputFusionServerToolItem$outboundSchema,
+        OutputAdvisorServerToolItem$outboundSchema,
+        OutputSubagentServerToolItem$outboundSchema,
+        CompactionItem$outboundSchema,
+        ItemReferenceItem$outboundSchema,
         EasyInputMessage$outboundSchema,
         InputMessageItem$outboundSchema,
     ])),

package/esm/models/itemreferenceitem.d.ts

@@ -0,0 +1,24 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+export declare const ItemReferenceItemType: {
+    readonly ItemReference: "item_reference";
+};
+export type ItemReferenceItemType = ClosedEnum<typeof ItemReferenceItemType>;
+/**
+ * A reference to a previous response item by ID
+ */
+export type ItemReferenceItem = {
+    id: string;
+    type: ItemReferenceItemType;
+};
+/** @internal */
+export declare const ItemReferenceItemType$outboundSchema: z.ZodEnum<typeof ItemReferenceItemType>;
+/** @internal */
+export type ItemReferenceItem$Outbound = {
+    id: string;
+    type: string;
+};
+/** @internal */
+export declare const ItemReferenceItem$outboundSchema: z.ZodType<ItemReferenceItem$Outbound, ItemReferenceItem>;
+export declare function itemReferenceItemToJSON(itemReferenceItem: ItemReferenceItem): string;
+//# sourceMappingURL=itemreferenceitem.d.ts.map

package/esm/models/itemreferenceitem.js

@@ -0,0 +1,19 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: ccbe6ae60edc
+ */
+import * as z from "zod/v4";
+export const ItemReferenceItemType = {
+    ItemReference: "item_reference",
+};
+/** @internal */
+export const ItemReferenceItemType$outboundSchema = z.enum(ItemReferenceItemType);
+/** @internal */
+export const ItemReferenceItem$outboundSchema = z.object({
+    id: z.string(),
+    type: ItemReferenceItemType$outboundSchema,
+});
+export function itemReferenceItemToJSON(itemReferenceItem) {
+    return JSON.stringify(ItemReferenceItem$outboundSchema.parse(itemReferenceItem));
+}
+//# sourceMappingURL=itemreferenceitem.js.map

package/esm/models/legacywebsearchservertool.d.ts

@@ -10,12 +10,12 @@ import { WebSearchUserLocation, WebSearchUserLocation$Outbound } from "./websear
  */
 export type LegacyWebSearchServerTool = {
     /**
-     * Which search engine to use. "auto" (default) uses native if the provider supports it, otherwise Exa. "native" forces the provider's built-in search. "exa" forces the Exa search API. "firecrawl" uses Firecrawl (requires BYOK). "parallel" uses the Parallel search API.
+     * Which search engine to use. "auto" (default) uses native if the provider supports it, otherwise Exa. "native" forces the provider's built-in search. "exa" forces the Exa search API. "firecrawl" uses Firecrawl (requires BYOK). "parallel" uses the Parallel search API. "perplexity" uses the Perplexity Search API (raw ranked results).
      */
     engine?: WebSearchEngineEnum | undefined;
     filters?: WebSearchDomainFilter | null | undefined;
     /**
-     * Maximum number of search results to return per search call. Defaults to 5. Applies to Exa, Firecrawl, and Parallel engines; ignored with native provider search.
+     * Maximum number of search results to return per search call. Defaults to 5. Applies to Exa, Firecrawl, Parallel, and Perplexity engines; ignored with native provider search.
      */
     maxResults?: number | undefined;
     /**

package/esm/models/listbyokkeysresponse.d.ts

@@ -0,0 +1,18 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { BYOKKey } from "./byokkey.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type ListBYOKKeysResponse = {
+    /**
+     * List of BYOK credentials.
+     */
+    data: Array<BYOKKey>;
+    /**
+     * Total number of BYOK credentials matching the filters.
+     */
+    totalCount: number;
+};
+/** @internal */
+export declare const ListBYOKKeysResponse$inboundSchema: z.ZodType<ListBYOKKeysResponse, unknown>;
+export declare function listBYOKKeysResponseFromJSON(jsonString: string): SafeParseResult<ListBYOKKeysResponse, SDKValidationError>;
+//# sourceMappingURL=listbyokkeysresponse.d.ts.map

package/esm/models/listbyokkeysresponse.js

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 58b401d42307
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { BYOKKey$inboundSchema } from "./byokkey.js";
+/** @internal */
+export const ListBYOKKeysResponse$inboundSchema = z.object({
+    data: z.array(BYOKKey$inboundSchema),
+    total_count: z.int(),
+}).transform((v) => {
+    return remap$(v, {
+        "total_count": "totalCount",
+    });
+});
+export function listBYOKKeysResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ListBYOKKeysResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ListBYOKKeysResponse' from JSON`);
+}
+//# sourceMappingURL=listbyokkeysresponse.js.map

package/esm/models/listobservabilitydestinationsresponse.d.ts

@@ -0,0 +1,18 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ObservabilityDestination } from "./observabilitydestination.js";
+export type ListObservabilityDestinationsResponse = {
+    /**
+     * List of observability destinations.
+     */
+    data: Array<ObservabilityDestination>;
+    /**
+     * Total number of destinations matching the filters.
+     */
+    totalCount: number;
+};
+/** @internal */
+export declare const ListObservabilityDestinationsResponse$inboundSchema: z.ZodType<ListObservabilityDestinationsResponse, unknown>;
+export declare function listObservabilityDestinationsResponseFromJSON(jsonString: string): SafeParseResult<ListObservabilityDestinationsResponse, SDKValidationError>;
+//# sourceMappingURL=listobservabilitydestinationsresponse.d.ts.map

package/esm/models/listobservabilitydestinationsresponse.js

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 5ce39dbed1ba
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ObservabilityDestination$inboundSchema, } from "./observabilitydestination.js";
+/** @internal */
+export const ListObservabilityDestinationsResponse$inboundSchema = z.object({
+    data: z.array(ObservabilityDestination$inboundSchema),
+    total_count: z.int(),
+}).transform((v) => {
+    return remap$(v, {
+        "total_count": "totalCount",
+    });
+});
+export function listObservabilityDestinationsResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ListObservabilityDestinationsResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ListObservabilityDestinationsResponse' from JSON`);
+}
+//# sourceMappingURL=listobservabilitydestinationsresponse.js.map

package/esm/models/listpresetsresponse.d.ts

@@ -0,0 +1,15 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { Preset } from "./preset.js";
+/**
+ * A paginated list of presets.
+ */
+export type ListPresetsResponse = {
+    data: Array<Preset>;
+    totalCount: number;
+};
+/** @internal */
+export declare const ListPresetsResponse$inboundSchema: z.ZodType<ListPresetsResponse, unknown>;
+export declare function listPresetsResponseFromJSON(jsonString: string): SafeParseResult<ListPresetsResponse, SDKValidationError>;
+//# sourceMappingURL=listpresetsresponse.d.ts.map

package/esm/models/listpresetsresponse.js

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: fa1eada5cc46
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { Preset$inboundSchema } from "./preset.js";
+/** @internal */
+export const ListPresetsResponse$inboundSchema = z.object({
+    data: z.array(Preset$inboundSchema),
+    total_count: z.int(),
+}).transform((v) => {
+    return remap$(v, {
+        "total_count": "totalCount",
+    });
+});
+export function listPresetsResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ListPresetsResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ListPresetsResponse' from JSON`);
+}
+//# sourceMappingURL=listpresetsresponse.js.map

package/esm/models/listpresetversionsresponse.d.ts

@@ -0,0 +1,15 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { PresetDesignatedVersion } from "./presetdesignatedversion.js";
+/**
+ * A paginated list of preset versions.
+ */
+export type ListPresetVersionsResponse = {
+    data: Array<PresetDesignatedVersion | null>;
+    totalCount: number;
+};
+/** @internal */
+export declare const ListPresetVersionsResponse$inboundSchema: z.ZodType<ListPresetVersionsResponse, unknown>;
+export declare function listPresetVersionsResponseFromJSON(jsonString: string): SafeParseResult<ListPresetVersionsResponse, SDKValidationError>;
+//# sourceMappingURL=listpresetversionsresponse.d.ts.map

package/esm/models/listpresetversionsresponse.js

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 071060ed138f
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { PresetDesignatedVersion$inboundSchema, } from "./presetdesignatedversion.js";
+/** @internal */
+export const ListPresetVersionsResponse$inboundSchema = z.object({
+    data: z.array(z.nullable(PresetDesignatedVersion$inboundSchema)),
+    total_count: z.int(),
+}).transform((v) => {
+    return remap$(v, {
+        "total_count": "totalCount",
+    });
+});
+export function listPresetVersionsResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ListPresetVersionsResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ListPresetVersionsResponse' from JSON`);
+}
+//# sourceMappingURL=listpresetversionsresponse.js.map

package/esm/models/localshellcallitem.d.ts

@@ -0,0 +1,61 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { ToolCallStatus } from "./toolcallstatus.js";
+export declare const TypeExec: {
+    readonly Exec: "exec";
+};
+export type TypeExec = ClosedEnum<typeof TypeExec>;
+export type LocalShellCallItemAction = {
+    command: Array<string>;
+    env: {
+        [k: string]: string;
+    };
+    timeoutMs?: number | null | undefined;
+    type: TypeExec;
+    user?: string | null | undefined;
+    workingDirectory?: string | null | undefined;
+};
+export declare const TypeLocalShellCall: {
+    readonly LocalShellCall: "local_shell_call";
+};
+export type TypeLocalShellCall = ClosedEnum<typeof TypeLocalShellCall>;
+/**
+ * A local shell command execution call
+ */
+export type LocalShellCallItem = {
+    action: LocalShellCallItemAction;
+    callId: string;
+    id: string;
+    status: ToolCallStatus;
+    type: TypeLocalShellCall;
+};
+/** @internal */
+export declare const TypeExec$outboundSchema: z.ZodEnum<typeof TypeExec>;
+/** @internal */
+export type LocalShellCallItemAction$Outbound = {
+    command: Array<string>;
+    env: {
+        [k: string]: string;
+    };
+    timeout_ms?: number | null | undefined;
+    type: string;
+    user?: string | null | undefined;
+    working_directory?: string | null | undefined;
+};
+/** @internal */
+export declare const LocalShellCallItemAction$outboundSchema: z.ZodType<LocalShellCallItemAction$Outbound, LocalShellCallItemAction>;
+export declare function localShellCallItemActionToJSON(localShellCallItemAction: LocalShellCallItemAction): string;
+/** @internal */
+export declare const TypeLocalShellCall$outboundSchema: z.ZodEnum<typeof TypeLocalShellCall>;
+/** @internal */
+export type LocalShellCallItem$Outbound = {
+    action: LocalShellCallItemAction$Outbound;
+    call_id: string;
+    id: string;
+    status: string;
+    type: string;
+};
+/** @internal */
+export declare const LocalShellCallItem$outboundSchema: z.ZodType<LocalShellCallItem$Outbound, LocalShellCallItem>;
+export declare function localShellCallItemToJSON(localShellCallItem: LocalShellCallItem): string;
+//# sourceMappingURL=localshellcallitem.d.ts.map

package/esm/models/localshellcallitem.js

@@ -0,0 +1,50 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 01cd50ccbc7a
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
+export const TypeExec = {
+    Exec: "exec",
+};
+export const TypeLocalShellCall = {
+    LocalShellCall: "local_shell_call",
+};
+/** @internal */
+export const TypeExec$outboundSchema = z.enum(TypeExec);
+/** @internal */
+export const LocalShellCallItemAction$outboundSchema = z.object({
+    command: z.array(z.string()),
+    env: z.record(z.string(), z.string()),
+    timeoutMs: z.nullable(z.int()).optional(),
+    type: TypeExec$outboundSchema,
+    user: z.nullable(z.string()).optional(),
+    workingDirectory: z.nullable(z.string()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        timeoutMs: "timeout_ms",
+        workingDirectory: "working_directory",
+    });
+});
+export function localShellCallItemActionToJSON(localShellCallItemAction) {
+    return JSON.stringify(LocalShellCallItemAction$outboundSchema.parse(localShellCallItemAction));
+}
+/** @internal */
+export const TypeLocalShellCall$outboundSchema = z.enum(TypeLocalShellCall);
+/** @internal */
+export const LocalShellCallItem$outboundSchema = z.object({
+    action: z.lazy(() => LocalShellCallItemAction$outboundSchema),
+    callId: z.string(),
+    id: z.string(),
+    status: ToolCallStatus$outboundSchema,
+    type: TypeLocalShellCall$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        callId: "call_id",
+    });
+});
+export function localShellCallItemToJSON(localShellCallItem) {
+    return JSON.stringify(LocalShellCallItem$outboundSchema.parse(localShellCallItem));
+}
+//# sourceMappingURL=localshellcallitem.js.map

package/esm/models/localshellcalloutputitem.d.ts

@@ -0,0 +1,36 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+export declare const LocalShellCallOutputItemStatus: {
+    readonly InProgress: "in_progress";
+    readonly Completed: "completed";
+    readonly Incomplete: "incomplete";
+};
+export type LocalShellCallOutputItemStatus = OpenEnum<typeof LocalShellCallOutputItemStatus>;
+export declare const LocalShellCallOutputItemType: {
+    readonly LocalShellCallOutput: "local_shell_call_output";
+};
+export type LocalShellCallOutputItemType = ClosedEnum<typeof LocalShellCallOutputItemType>;
+/**
+ * Output from a local shell command execution
+ */
+export type LocalShellCallOutputItem = {
+    id: string;
+    output: string;
+    status?: LocalShellCallOutputItemStatus | null | undefined;
+    type: LocalShellCallOutputItemType;
+};
+/** @internal */
+export declare const LocalShellCallOutputItemStatus$outboundSchema: z.ZodType<string, LocalShellCallOutputItemStatus>;
+/** @internal */
+export declare const LocalShellCallOutputItemType$outboundSchema: z.ZodEnum<typeof LocalShellCallOutputItemType>;
+/** @internal */
+export type LocalShellCallOutputItem$Outbound = {
+    id: string;
+    output: string;
+    status?: string | null | undefined;
+    type: string;
+};
+/** @internal */
+export declare const LocalShellCallOutputItem$outboundSchema: z.ZodType<LocalShellCallOutputItem$Outbound, LocalShellCallOutputItem>;
+export declare function localShellCallOutputItemToJSON(localShellCallOutputItem: LocalShellCallOutputItem): string;
+//# sourceMappingURL=localshellcalloutputitem.d.ts.map

package/esm/models/localshellcalloutputitem.js

@@ -0,0 +1,29 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 07d6199bf63f
+ */
+import * as z from "zod/v4";
+import * as openEnums from "../types/enums.js";
+export const LocalShellCallOutputItemStatus = {
+    InProgress: "in_progress",
+    Completed: "completed",
+    Incomplete: "incomplete",
+};
+export const LocalShellCallOutputItemType = {
+    LocalShellCallOutput: "local_shell_call_output",
+};
+/** @internal */
+export const LocalShellCallOutputItemStatus$outboundSchema = openEnums.outboundSchema(LocalShellCallOutputItemStatus);
+/** @internal */
+export const LocalShellCallOutputItemType$outboundSchema = z.enum(LocalShellCallOutputItemType);
+/** @internal */
+export const LocalShellCallOutputItem$outboundSchema = z.object({
+    id: z.string(),
+    output: z.string(),
+    status: z.nullable(LocalShellCallOutputItemStatus$outboundSchema).optional(),
+    type: LocalShellCallOutputItemType$outboundSchema,
+});
+export function localShellCallOutputItemToJSON(localShellCallOutputItem) {
+    return JSON.stringify(LocalShellCallOutputItem$outboundSchema.parse(localShellCallOutputItem));
+}
+//# sourceMappingURL=localshellcalloutputitem.js.map

package/esm/models/mcpapprovalrequestitem.d.ts

@@ -0,0 +1,30 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+export declare const McpApprovalRequestItemType: {
+    readonly McpApprovalRequest: "mcp_approval_request";
+};
+export type McpApprovalRequestItemType = ClosedEnum<typeof McpApprovalRequestItemType>;
+/**
+ * Request for approval to execute an MCP tool
+ */
+export type McpApprovalRequestItem = {
+    arguments: string;
+    id: string;
+    name: string;
+    serverLabel: string;
+    type: McpApprovalRequestItemType;
+};
+/** @internal */
+export declare const McpApprovalRequestItemType$outboundSchema: z.ZodEnum<typeof McpApprovalRequestItemType>;
+/** @internal */
+export type McpApprovalRequestItem$Outbound = {
+    arguments: string;
+    id: string;
+    name: string;
+    server_label: string;
+    type: string;
+};
+/** @internal */
+export declare const McpApprovalRequestItem$outboundSchema: z.ZodType<McpApprovalRequestItem$Outbound, McpApprovalRequestItem>;
+export declare function mcpApprovalRequestItemToJSON(mcpApprovalRequestItem: McpApprovalRequestItem): string;
+//# sourceMappingURL=mcpapprovalrequestitem.d.ts.map

package/esm/models/mcpapprovalrequestitem.js

@@ -0,0 +1,27 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 03d997756e6c
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+export const McpApprovalRequestItemType = {
+    McpApprovalRequest: "mcp_approval_request",
+};
+/** @internal */
+export const McpApprovalRequestItemType$outboundSchema = z.enum(McpApprovalRequestItemType);
+/** @internal */
+export const McpApprovalRequestItem$outboundSchema = z.object({
+    arguments: z.string(),
+    id: z.string(),
+    name: z.string(),
+    serverLabel: z.string(),
+    type: McpApprovalRequestItemType$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        serverLabel: "server_label",
+    });
+});
+export function mcpApprovalRequestItemToJSON(mcpApprovalRequestItem) {
+    return JSON.stringify(McpApprovalRequestItem$outboundSchema.parse(mcpApprovalRequestItem));
+}
+//# sourceMappingURL=mcpapprovalrequestitem.js.map

package/esm/models/mcpapprovalresponseitem.d.ts

@@ -0,0 +1,30 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+export declare const McpApprovalResponseItemType: {
+    readonly McpApprovalResponse: "mcp_approval_response";
+};
+export type McpApprovalResponseItemType = ClosedEnum<typeof McpApprovalResponseItemType>;
+/**
+ * User response to an MCP tool approval request
+ */
+export type McpApprovalResponseItem = {
+    approvalRequestId: string;
+    approve: boolean;
+    id?: string | null | undefined;
+    reason?: string | null | undefined;
+    type: McpApprovalResponseItemType;
+};
+/** @internal */
+export declare const McpApprovalResponseItemType$outboundSchema: z.ZodEnum<typeof McpApprovalResponseItemType>;
+/** @internal */
+export type McpApprovalResponseItem$Outbound = {
+    approval_request_id: string;
+    approve: boolean;
+    id?: string | null | undefined;
+    reason?: string | null | undefined;
+    type: string;
+};
+/** @internal */
+export declare const McpApprovalResponseItem$outboundSchema: z.ZodType<McpApprovalResponseItem$Outbound, McpApprovalResponseItem>;
+export declare function mcpApprovalResponseItemToJSON(mcpApprovalResponseItem: McpApprovalResponseItem): string;
+//# sourceMappingURL=mcpapprovalresponseitem.d.ts.map

package/esm/models/mcpapprovalresponseitem.js

@@ -0,0 +1,27 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 0d43249f80cc
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+export const McpApprovalResponseItemType = {
+    McpApprovalResponse: "mcp_approval_response",
+};
+/** @internal */
+export const McpApprovalResponseItemType$outboundSchema = z.enum(McpApprovalResponseItemType);
+/** @internal */
+export const McpApprovalResponseItem$outboundSchema = z.object({
+    approvalRequestId: z.string(),
+    approve: z.boolean(),
+    id: z.nullable(z.string()).optional(),
+    reason: z.nullable(z.string()).optional(),
+    type: McpApprovalResponseItemType$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        approvalRequestId: "approval_request_id",
+    });
+});
+export function mcpApprovalResponseItemToJSON(mcpApprovalResponseItem) {
+    return JSON.stringify(McpApprovalResponseItem$outboundSchema.parse(mcpApprovalResponseItem));
+}
+//# sourceMappingURL=mcpapprovalresponseitem.js.map