@openrouter/sdk 0.12.35 → 0.12.79

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

package/esm/models/mcpcallitem.d.ts

@@ -0,0 +1,34 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+export declare const McpCallItemType: {
+    readonly McpCall: "mcp_call";
+};
+export type McpCallItemType = ClosedEnum<typeof McpCallItemType>;
+/**
+ * An MCP tool call with its output or error
+ */
+export type McpCallItem = {
+    arguments: string;
+    error?: string | null | undefined;
+    id: string;
+    name: string;
+    output?: string | null | undefined;
+    serverLabel: string;
+    type: McpCallItemType;
+};
+/** @internal */
+export declare const McpCallItemType$outboundSchema: z.ZodEnum<typeof McpCallItemType>;
+/** @internal */
+export type McpCallItem$Outbound = {
+    arguments: string;
+    error?: string | null | undefined;
+    id: string;
+    name: string;
+    output?: string | null | undefined;
+    server_label: string;
+    type: string;
+};
+/** @internal */
+export declare const McpCallItem$outboundSchema: z.ZodType<McpCallItem$Outbound, McpCallItem>;
+export declare function mcpCallItemToJSON(mcpCallItem: McpCallItem): string;
+//# sourceMappingURL=mcpcallitem.d.ts.map

package/esm/models/mcpcallitem.js

@@ -0,0 +1,29 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 39bfed05b6dd
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+export const McpCallItemType = {
+    McpCall: "mcp_call",
+};
+/** @internal */
+export const McpCallItemType$outboundSchema = z.enum(McpCallItemType);
+/** @internal */
+export const McpCallItem$outboundSchema = z.object({
+    arguments: z.string(),
+    error: z.nullable(z.string()).optional(),
+    id: z.string(),
+    name: z.string(),
+    output: z.nullable(z.string()).optional(),
+    serverLabel: z.string(),
+    type: McpCallItemType$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        serverLabel: "server_label",
+    });
+});
+export function mcpCallItemToJSON(mcpCallItem) {
+    return JSON.stringify(McpCallItem$outboundSchema.parse(mcpCallItem));
+}
+//# sourceMappingURL=mcpcallitem.js.map

package/esm/models/mcplisttoolsitem.d.ts

@@ -0,0 +1,50 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+export type McpListToolsItemTool = {
+    annotations?: any | null | undefined;
+    description?: string | null | undefined;
+    inputSchema: {
+        [k: string]: any | null;
+    };
+    name: string;
+};
+export declare const McpListToolsItemType: {
+    readonly McpListTools: "mcp_list_tools";
+};
+export type McpListToolsItemType = ClosedEnum<typeof McpListToolsItemType>;
+/**
+ * List of available MCP tools from a server
+ */
+export type McpListToolsItem = {
+    error?: string | null | undefined;
+    id: string;
+    serverLabel: string;
+    tools: Array<McpListToolsItemTool>;
+    type: McpListToolsItemType;
+};
+/** @internal */
+export type McpListToolsItemTool$Outbound = {
+    annotations?: any | null | undefined;
+    description?: string | null | undefined;
+    input_schema: {
+        [k: string]: any | null;
+    };
+    name: string;
+};
+/** @internal */
+export declare const McpListToolsItemTool$outboundSchema: z.ZodType<McpListToolsItemTool$Outbound, McpListToolsItemTool>;
+export declare function mcpListToolsItemToolToJSON(mcpListToolsItemTool: McpListToolsItemTool): string;
+/** @internal */
+export declare const McpListToolsItemType$outboundSchema: z.ZodEnum<typeof McpListToolsItemType>;
+/** @internal */
+export type McpListToolsItem$Outbound = {
+    error?: string | null | undefined;
+    id: string;
+    server_label: string;
+    tools: Array<McpListToolsItemTool$Outbound>;
+    type: string;
+};
+/** @internal */
+export declare const McpListToolsItem$outboundSchema: z.ZodType<McpListToolsItem$Outbound, McpListToolsItem>;
+export declare function mcpListToolsItemToJSON(mcpListToolsItem: McpListToolsItem): string;
+//# sourceMappingURL=mcplisttoolsitem.d.ts.map

package/esm/models/mcplisttoolsitem.js

@@ -0,0 +1,41 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 3a1a2af50e51
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+export const McpListToolsItemType = {
+    McpListTools: "mcp_list_tools",
+};
+/** @internal */
+export const McpListToolsItemTool$outboundSchema = z.object({
+    annotations: z.nullable(z.any()).optional(),
+    description: z.nullable(z.string()).optional(),
+    inputSchema: z.record(z.string(), z.nullable(z.any())),
+    name: z.string(),
+}).transform((v) => {
+    return remap$(v, {
+        inputSchema: "input_schema",
+    });
+});
+export function mcpListToolsItemToolToJSON(mcpListToolsItemTool) {
+    return JSON.stringify(McpListToolsItemTool$outboundSchema.parse(mcpListToolsItemTool));
+}
+/** @internal */
+export const McpListToolsItemType$outboundSchema = z.enum(McpListToolsItemType);
+/** @internal */
+export const McpListToolsItem$outboundSchema = z.object({
+    error: z.nullable(z.string()).optional(),
+    id: z.string(),
+    serverLabel: z.string(),
+    tools: z.array(z.lazy(() => McpListToolsItemTool$outboundSchema)),
+    type: McpListToolsItemType$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        serverLabel: "server_label",
+    });
+});
+export function mcpListToolsItemToJSON(mcpListToolsItem) {
+    return JSON.stringify(McpListToolsItem$outboundSchema.parse(mcpListToolsItem));
+}
+//# sourceMappingURL=mcplisttoolsitem.js.map

package/esm/models/messagesadvisortoolresultblock.d.ts

@@ -0,0 +1,23 @@
+import * as z from "zod/v4";
+/**
+ * Advisor tool result from a prior assistant turn, replayed back to the model on the next turn. Mirrors the block Anthropic returns in assistant content when the `advisor_20260301` tool runs.
+ */
+export type MessagesAdvisorToolResultBlock = {
+    content: {
+        [k: string]: any | null;
+    };
+    toolUseId: string;
+    type: "advisor_tool_result";
+};
+/** @internal */
+export type MessagesAdvisorToolResultBlock$Outbound = {
+    content: {
+        [k: string]: any | null;
+    };
+    tool_use_id: string;
+    type: "advisor_tool_result";
+};
+/** @internal */
+export declare const MessagesAdvisorToolResultBlock$outboundSchema: z.ZodType<MessagesAdvisorToolResultBlock$Outbound, MessagesAdvisorToolResultBlock>;
+export declare function messagesAdvisorToolResultBlockToJSON(messagesAdvisorToolResultBlock: MessagesAdvisorToolResultBlock): string;
+//# sourceMappingURL=messagesadvisortoolresultblock.d.ts.map

package/esm/models/messagesadvisortoolresultblock.js

@@ -0,0 +1,20 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: fa2793939c81
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+/** @internal */
+export const MessagesAdvisorToolResultBlock$outboundSchema = z.object({
+    content: z.record(z.string(), z.nullable(z.any())),
+    toolUseId: z.string(),
+    type: z.literal("advisor_tool_result"),
+}).transform((v) => {
+    return remap$(v, {
+        toolUseId: "tool_use_id",
+    });
+});
+export function messagesAdvisorToolResultBlockToJSON(messagesAdvisorToolResultBlock) {
+    return JSON.stringify(MessagesAdvisorToolResultBlock$outboundSchema.parse(messagesAdvisorToolResultBlock));
+}
+//# sourceMappingURL=messagesadvisortoolresultblock.js.map