@openrouter/sdk 0.10.2 → 0.12.0

package/esm/models/outputbashservertoolitem.js

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 8eeee25f4818
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
+/** @internal */
+export const OutputBashServerToolItem$inboundSchema = z.object({
+    command: z.string().optional(),
+    exitCode: z.int().optional(),
+    id: z.string().optional(),
+    status: ToolCallStatus$inboundSchema,
+    stderr: z.string().optional(),
+    stdout: z.string().optional(),
+    type: z.literal("openrouter:bash"),
+});
+export function outputBashServerToolItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputBashServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputBashServerToolItem' from JSON`);
+}
+//# sourceMappingURL=outputbashservertoolitem.js.map

package/esm/models/outputbrowseruseservertoolitem.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 { ToolCallStatus } from "./toolcallstatus.js";
+/**
+ * An openrouter:browser_use server tool output item
+ */
+export type OutputBrowserUseServerToolItem = {
+    action?: string | undefined;
+    id?: string | undefined;
+    screenshotB64?: string | undefined;
+    status: ToolCallStatus;
+    type: "openrouter:browser_use";
+};
+/** @internal */
+export declare const OutputBrowserUseServerToolItem$inboundSchema: z.ZodType<OutputBrowserUseServerToolItem, unknown>;
+export declare function outputBrowserUseServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputBrowserUseServerToolItem, SDKValidationError>;
+//# sourceMappingURL=outputbrowseruseservertoolitem.d.ts.map

package/esm/models/outputbrowseruseservertoolitem.js

@@ -0,0 +1,19 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 5ad5586d0533
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
+/** @internal */
+export const OutputBrowserUseServerToolItem$inboundSchema = z.object({
+    action: z.string().optional(),
+    id: z.string().optional(),
+    screenshotB64: z.string().optional(),
+    status: ToolCallStatus$inboundSchema,
+    type: z.literal("openrouter:browser_use"),
+});
+export function outputBrowserUseServerToolItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputBrowserUseServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputBrowserUseServerToolItem' from JSON`);
+}
+//# sourceMappingURL=outputbrowseruseservertoolitem.js.map

package/esm/models/outputcodeinterpretercallitem.d.ts

@@ -0,0 +1,38 @@
+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 { ToolCallStatus } from "./toolcallstatus.js";
+export type OutputLogs = {
+    logs: string;
+    type: "logs";
+};
+export type OutputImage = {
+    type: "image";
+    url: string;
+};
+export type OutputCodeInterpreterCallItemOutputUnion = OutputImage | OutputLogs | discriminatedUnionTypes.Unknown<"type">;
+/**
+ * A code interpreter execution call with outputs
+ */
+export type OutputCodeInterpreterCallItem = {
+    code: string | null;
+    containerId: string;
+    id: string;
+    outputs: Array<OutputImage | OutputLogs | discriminatedUnionTypes.Unknown<"type">> | null;
+    status: ToolCallStatus;
+    type: "code_interpreter_call";
+};
+/** @internal */
+export declare const OutputLogs$inboundSchema: z.ZodType<OutputLogs, unknown>;
+export declare function outputLogsFromJSON(jsonString: string): SafeParseResult<OutputLogs, SDKValidationError>;
+/** @internal */
+export declare const OutputImage$inboundSchema: z.ZodType<OutputImage, unknown>;
+export declare function outputImageFromJSON(jsonString: string): SafeParseResult<OutputImage, SDKValidationError>;
+/** @internal */
+export declare const OutputCodeInterpreterCallItemOutputUnion$inboundSchema: z.ZodType<OutputCodeInterpreterCallItemOutputUnion, unknown>;
+export declare function outputCodeInterpreterCallItemOutputUnionFromJSON(jsonString: string): SafeParseResult<OutputCodeInterpreterCallItemOutputUnion, SDKValidationError>;
+/** @internal */
+export declare const OutputCodeInterpreterCallItem$inboundSchema: z.ZodType<OutputCodeInterpreterCallItem, unknown>;
+export declare function outputCodeInterpreterCallItemFromJSON(jsonString: string): SafeParseResult<OutputCodeInterpreterCallItem, SDKValidationError>;
+//# sourceMappingURL=outputcodeinterpretercallitem.d.ts.map

package/esm/models/outputcodeinterpretercallitem.js

@@ -0,0 +1,55 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: ee080e2eccae
+ */
+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 { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
+/** @internal */
+export const OutputLogs$inboundSchema = z
+    .object({
+    logs: z.string(),
+    type: z.literal("logs"),
+});
+export function outputLogsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputLogs$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputLogs' from JSON`);
+}
+/** @internal */
+export const OutputImage$inboundSchema = z
+    .object({
+    type: z.literal("image"),
+    url: z.string(),
+});
+export function outputImageFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputImage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputImage' from JSON`);
+}
+/** @internal */
+export const OutputCodeInterpreterCallItemOutputUnion$inboundSchema = discriminatedUnion("type", {
+    image: z.lazy(() => OutputImage$inboundSchema),
+    logs: z.lazy(() => OutputLogs$inboundSchema),
+});
+export function outputCodeInterpreterCallItemOutputUnionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputCodeInterpreterCallItemOutputUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputCodeInterpreterCallItemOutputUnion' from JSON`);
+}
+/** @internal */
+export const OutputCodeInterpreterCallItem$inboundSchema = z.object({
+    code: z.nullable(z.string()),
+    container_id: z.string(),
+    id: z.string(),
+    outputs: z.nullable(z.array(discriminatedUnion("type", {
+        image: z.lazy(() => OutputImage$inboundSchema),
+        logs: z.lazy(() => OutputLogs$inboundSchema),
+    }))),
+    status: ToolCallStatus$inboundSchema,
+    type: z.literal("code_interpreter_call"),
+}).transform((v) => {
+    return remap$(v, {
+        "container_id": "containerId",
+    });
+});
+export function outputCodeInterpreterCallItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputCodeInterpreterCallItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputCodeInterpreterCallItem' from JSON`);
+}
+//# sourceMappingURL=outputcodeinterpretercallitem.js.map

package/esm/models/outputcodeinterpreterservertoolitem.d.ts

@@ -0,0 +1,21 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ToolCallStatus } from "./toolcallstatus.js";
+/**
+ * An openrouter:code_interpreter server tool output item
+ */
+export type OutputCodeInterpreterServerToolItem = {
+    code?: string | undefined;
+    exitCode?: number | undefined;
+    id?: string | undefined;
+    language?: string | undefined;
+    status: ToolCallStatus;
+    stderr?: string | undefined;
+    stdout?: string | undefined;
+    type: "openrouter:code_interpreter";
+};
+/** @internal */
+export declare const OutputCodeInterpreterServerToolItem$inboundSchema: z.ZodType<OutputCodeInterpreterServerToolItem, unknown>;
+export declare function outputCodeInterpreterServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputCodeInterpreterServerToolItem, SDKValidationError>;
+//# sourceMappingURL=outputcodeinterpreterservertoolitem.d.ts.map

package/esm/models/outputcodeinterpreterservertoolitem.js

@@ -0,0 +1,22 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 16f87f6046c4
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
+/** @internal */
+export const OutputCodeInterpreterServerToolItem$inboundSchema = z.object({
+    code: z.string().optional(),
+    exitCode: z.int().optional(),
+    id: z.string().optional(),
+    language: z.string().optional(),
+    status: ToolCallStatus$inboundSchema,
+    stderr: z.string().optional(),
+    stdout: z.string().optional(),
+    type: z.literal("openrouter:code_interpreter"),
+});
+export function outputCodeInterpreterServerToolItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputCodeInterpreterServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputCodeInterpreterServerToolItem' from JSON`);
+}
+//# sourceMappingURL=outputcodeinterpreterservertoolitem.js.map

package/esm/models/outputcomputercallitem.d.ts

@@ -0,0 +1,32 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type PendingSafetyCheck = {
+    code: string;
+    id: string;
+    message: string;
+};
+export declare const OutputComputerCallItemStatus: {
+    readonly Completed: "completed";
+    readonly Incomplete: "incomplete";
+    readonly InProgress: "in_progress";
+};
+export type OutputComputerCallItemStatus = OpenEnum<typeof OutputComputerCallItemStatus>;
+export type OutputComputerCallItem = {
+    action?: any | null | undefined;
+    callId: string;
+    id?: string | undefined;
+    pendingSafetyChecks: Array<PendingSafetyCheck>;
+    status: OutputComputerCallItemStatus;
+    type: "computer_call";
+};
+/** @internal */
+export declare const PendingSafetyCheck$inboundSchema: z.ZodType<PendingSafetyCheck, unknown>;
+export declare function pendingSafetyCheckFromJSON(jsonString: string): SafeParseResult<PendingSafetyCheck, SDKValidationError>;
+/** @internal */
+export declare const OutputComputerCallItemStatus$inboundSchema: z.ZodType<OutputComputerCallItemStatus, unknown>;
+/** @internal */
+export declare const OutputComputerCallItem$inboundSchema: z.ZodType<OutputComputerCallItem, unknown>;
+export declare function outputComputerCallItemFromJSON(jsonString: string): SafeParseResult<OutputComputerCallItem, SDKValidationError>;
+//# sourceMappingURL=outputcomputercallitem.d.ts.map

package/esm/models/outputcomputercallitem.js

@@ -0,0 +1,42 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: fd4439fdf358
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+export const OutputComputerCallItemStatus = {
+    Completed: "completed",
+    Incomplete: "incomplete",
+    InProgress: "in_progress",
+};
+/** @internal */
+export const PendingSafetyCheck$inboundSchema = z.object({
+    code: z.string(),
+    id: z.string(),
+    message: z.string(),
+});
+export function pendingSafetyCheckFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => PendingSafetyCheck$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'PendingSafetyCheck' from JSON`);
+}
+/** @internal */
+export const OutputComputerCallItemStatus$inboundSchema = openEnums.inboundSchema(OutputComputerCallItemStatus);
+/** @internal */
+export const OutputComputerCallItem$inboundSchema = z.object({
+    action: z.nullable(z.any()).optional(),
+    call_id: z.string(),
+    id: z.string().optional(),
+    pending_safety_checks: z.array(z.lazy(() => PendingSafetyCheck$inboundSchema)),
+    status: OutputComputerCallItemStatus$inboundSchema,
+    type: z.literal("computer_call"),
+}).transform((v) => {
+    return remap$(v, {
+        "call_id": "callId",
+        "pending_safety_checks": "pendingSafetyChecks",
+    });
+});
+export function outputComputerCallItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputComputerCallItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputComputerCallItem' from JSON`);
+}
+//# sourceMappingURL=outputcomputercallitem.js.map

package/esm/models/outputdatetimeitem.d.ts

@@ -0,0 +1,44 @@
+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 OutputDatetimeItemType: {
+    readonly OpenrouterDatetime: "openrouter:datetime";
+};
+export type OutputDatetimeItemType = ClosedEnum<typeof OutputDatetimeItemType>;
+/**
+ * An openrouter:datetime server tool output item
+ */
+export type OutputDatetimeItem = {
+    /**
+     * ISO 8601 datetime string
+     */
+    datetime: string;
+    id?: string | undefined;
+    status: ToolCallStatus;
+    /**
+     * IANA timezone name
+     */
+    timezone: string;
+    type: OutputDatetimeItemType;
+};
+/** @internal */
+export declare const OutputDatetimeItemType$inboundSchema: z.ZodEnum<typeof OutputDatetimeItemType>;
+/** @internal */
+export declare const OutputDatetimeItemType$outboundSchema: z.ZodEnum<typeof OutputDatetimeItemType>;
+/** @internal */
+export declare const OutputDatetimeItem$inboundSchema: z.ZodType<OutputDatetimeItem, unknown>;
+/** @internal */
+export type OutputDatetimeItem$Outbound = {
+    datetime: string;
+    id?: string | undefined;
+    status: string;
+    timezone: string;
+    type: string;
+};
+/** @internal */
+export declare const OutputDatetimeItem$outboundSchema: z.ZodType<OutputDatetimeItem$Outbound, OutputDatetimeItem>;
+export declare function outputDatetimeItemToJSON(outputDatetimeItem: OutputDatetimeItem): string;
+export declare function outputDatetimeItemFromJSON(jsonString: string): SafeParseResult<OutputDatetimeItem, SDKValidationError>;
+//# sourceMappingURL=outputdatetimeitem.d.ts.map

package/esm/models/outputdatetimeitem.js

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 0c1828e72f98
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { ToolCallStatus$inboundSchema, ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
+export const OutputDatetimeItemType = {
+    OpenrouterDatetime: "openrouter:datetime",
+};
+/** @internal */
+export const OutputDatetimeItemType$inboundSchema = z.enum(OutputDatetimeItemType);
+/** @internal */
+export const OutputDatetimeItemType$outboundSchema = OutputDatetimeItemType$inboundSchema;
+/** @internal */
+export const OutputDatetimeItem$inboundSchema = z.object({
+    datetime: z.string(),
+    id: z.string().optional(),
+    status: ToolCallStatus$inboundSchema,
+    timezone: z.string(),
+    type: OutputDatetimeItemType$inboundSchema,
+});
+/** @internal */
+export const OutputDatetimeItem$outboundSchema = z.object({
+    datetime: z.string(),
+    id: z.string().optional(),
+    status: ToolCallStatus$outboundSchema,
+    timezone: z.string(),
+    type: OutputDatetimeItemType$outboundSchema,
+});
+export function outputDatetimeItemToJSON(outputDatetimeItem) {
+    return JSON.stringify(OutputDatetimeItem$outboundSchema.parse(outputDatetimeItem));
+}
+export function outputDatetimeItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputDatetimeItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputDatetimeItem' from JSON`);
+}
+//# sourceMappingURL=outputdatetimeitem.js.map

package/esm/models/outputfilesearchcallitem.d.ts

@@ -0,0 +1,33 @@
+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 { WebSearchStatus } from "./websearchstatus.js";
+export declare const OutputFileSearchCallItemType: {
+    readonly FileSearchCall: "file_search_call";
+};
+export type OutputFileSearchCallItemType = ClosedEnum<typeof OutputFileSearchCallItemType>;
+export type OutputFileSearchCallItem = {
+    id: string;
+    queries: Array<string>;
+    status: WebSearchStatus;
+    type: OutputFileSearchCallItemType;
+};
+/** @internal */
+export declare const OutputFileSearchCallItemType$inboundSchema: z.ZodEnum<typeof OutputFileSearchCallItemType>;
+/** @internal */
+export declare const OutputFileSearchCallItemType$outboundSchema: z.ZodEnum<typeof OutputFileSearchCallItemType>;
+/** @internal */
+export declare const OutputFileSearchCallItem$inboundSchema: z.ZodType<OutputFileSearchCallItem, unknown>;
+/** @internal */
+export type OutputFileSearchCallItem$Outbound = {
+    id: string;
+    queries: Array<string>;
+    status: string;
+    type: string;
+};
+/** @internal */
+export declare const OutputFileSearchCallItem$outboundSchema: z.ZodType<OutputFileSearchCallItem$Outbound, OutputFileSearchCallItem>;
+export declare function outputFileSearchCallItemToJSON(outputFileSearchCallItem: OutputFileSearchCallItem): string;
+export declare function outputFileSearchCallItemFromJSON(jsonString: string): SafeParseResult<OutputFileSearchCallItem, SDKValidationError>;
+//# sourceMappingURL=outputfilesearchcallitem.d.ts.map

package/esm/models/outputfilesearchcallitem.js

@@ -0,0 +1,35 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: eafceec94b81
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { WebSearchStatus$inboundSchema, WebSearchStatus$outboundSchema, } from "./websearchstatus.js";
+export const OutputFileSearchCallItemType = {
+    FileSearchCall: "file_search_call",
+};
+/** @internal */
+export const OutputFileSearchCallItemType$inboundSchema = z.enum(OutputFileSearchCallItemType);
+/** @internal */
+export const OutputFileSearchCallItemType$outboundSchema = OutputFileSearchCallItemType$inboundSchema;
+/** @internal */
+export const OutputFileSearchCallItem$inboundSchema = z.object({
+    id: z.string(),
+    queries: z.array(z.string()),
+    status: WebSearchStatus$inboundSchema,
+    type: OutputFileSearchCallItemType$inboundSchema,
+});
+/** @internal */
+export const OutputFileSearchCallItem$outboundSchema = z.object({
+    id: z.string(),
+    queries: z.array(z.string()),
+    status: WebSearchStatus$outboundSchema,
+    type: OutputFileSearchCallItemType$outboundSchema,
+});
+export function outputFileSearchCallItemToJSON(outputFileSearchCallItem) {
+    return JSON.stringify(OutputFileSearchCallItem$outboundSchema.parse(outputFileSearchCallItem));
+}
+export function outputFileSearchCallItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputFileSearchCallItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputFileSearchCallItem' from JSON`);
+}
+//# sourceMappingURL=outputfilesearchcallitem.js.map

package/esm/models/outputfilesearchservertoolitem.d.ts

@@ -0,0 +1,17 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ToolCallStatus } from "./toolcallstatus.js";
+/**
+ * An openrouter:file_search server tool output item
+ */
+export type OutputFileSearchServerToolItem = {
+    id?: string | undefined;
+    queries?: Array<string> | undefined;
+    status: ToolCallStatus;
+    type: "openrouter:file_search";
+};
+/** @internal */
+export declare const OutputFileSearchServerToolItem$inboundSchema: z.ZodType<OutputFileSearchServerToolItem, unknown>;
+export declare function outputFileSearchServerToolItemFromJSON(jsonString: string): SafeParseResult<OutputFileSearchServerToolItem, SDKValidationError>;
+//# sourceMappingURL=outputfilesearchservertoolitem.d.ts.map

package/esm/models/outputfilesearchservertoolitem.js

@@ -0,0 +1,18 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 3e5afbd64572
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { ToolCallStatus$inboundSchema, } from "./toolcallstatus.js";
+/** @internal */
+export const OutputFileSearchServerToolItem$inboundSchema = z.object({
+    id: z.string().optional(),
+    queries: z.array(z.string()).optional(),
+    status: ToolCallStatus$inboundSchema,
+    type: z.literal("openrouter:file_search"),
+});
+export function outputFileSearchServerToolItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputFileSearchServerToolItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputFileSearchServerToolItem' from JSON`);
+}
+//# sourceMappingURL=outputfilesearchservertoolitem.js.map

package/esm/models/outputfunctioncallitem.d.ts

@@ -0,0 +1,69 @@
+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";
+export declare const OutputFunctionCallItemStatusInProgress: {
+    readonly InProgress: "in_progress";
+};
+export type OutputFunctionCallItemStatusInProgress = ClosedEnum<typeof OutputFunctionCallItemStatusInProgress>;
+export declare const OutputFunctionCallItemStatusIncomplete: {
+    readonly Incomplete: "incomplete";
+};
+export type OutputFunctionCallItemStatusIncomplete = ClosedEnum<typeof OutputFunctionCallItemStatusIncomplete>;
+export declare const OutputFunctionCallItemStatusCompleted: {
+    readonly Completed: "completed";
+};
+export type OutputFunctionCallItemStatusCompleted = ClosedEnum<typeof OutputFunctionCallItemStatusCompleted>;
+export type OutputFunctionCallItemStatusUnion = OutputFunctionCallItemStatusCompleted | OutputFunctionCallItemStatusIncomplete | OutputFunctionCallItemStatusInProgress;
+export declare const OutputFunctionCallItemType: {
+    readonly FunctionCall: "function_call";
+};
+export type OutputFunctionCallItemType = ClosedEnum<typeof OutputFunctionCallItemType>;
+export type OutputFunctionCallItem = {
+    arguments: string;
+    callId: string;
+    id?: string | undefined;
+    name: string;
+    status?: OutputFunctionCallItemStatusCompleted | OutputFunctionCallItemStatusIncomplete | OutputFunctionCallItemStatusInProgress | undefined;
+    type: OutputFunctionCallItemType;
+};
+/** @internal */
+export declare const OutputFunctionCallItemStatusInProgress$inboundSchema: z.ZodEnum<typeof OutputFunctionCallItemStatusInProgress>;
+/** @internal */
+export declare const OutputFunctionCallItemStatusInProgress$outboundSchema: z.ZodEnum<typeof OutputFunctionCallItemStatusInProgress>;
+/** @internal */
+export declare const OutputFunctionCallItemStatusIncomplete$inboundSchema: z.ZodEnum<typeof OutputFunctionCallItemStatusIncomplete>;
+/** @internal */
+export declare const OutputFunctionCallItemStatusIncomplete$outboundSchema: z.ZodEnum<typeof OutputFunctionCallItemStatusIncomplete>;
+/** @internal */
+export declare const OutputFunctionCallItemStatusCompleted$inboundSchema: z.ZodEnum<typeof OutputFunctionCallItemStatusCompleted>;
+/** @internal */
+export declare const OutputFunctionCallItemStatusCompleted$outboundSchema: z.ZodEnum<typeof OutputFunctionCallItemStatusCompleted>;
+/** @internal */
+export declare const OutputFunctionCallItemStatusUnion$inboundSchema: z.ZodType<OutputFunctionCallItemStatusUnion, unknown>;
+/** @internal */
+export type OutputFunctionCallItemStatusUnion$Outbound = string | string | string;
+/** @internal */
+export declare const OutputFunctionCallItemStatusUnion$outboundSchema: z.ZodType<OutputFunctionCallItemStatusUnion$Outbound, OutputFunctionCallItemStatusUnion>;
+export declare function outputFunctionCallItemStatusUnionToJSON(outputFunctionCallItemStatusUnion: OutputFunctionCallItemStatusUnion): string;
+export declare function outputFunctionCallItemStatusUnionFromJSON(jsonString: string): SafeParseResult<OutputFunctionCallItemStatusUnion, SDKValidationError>;
+/** @internal */
+export declare const OutputFunctionCallItemType$inboundSchema: z.ZodEnum<typeof OutputFunctionCallItemType>;
+/** @internal */
+export declare const OutputFunctionCallItemType$outboundSchema: z.ZodEnum<typeof OutputFunctionCallItemType>;
+/** @internal */
+export declare const OutputFunctionCallItem$inboundSchema: z.ZodType<OutputFunctionCallItem, unknown>;
+/** @internal */
+export type OutputFunctionCallItem$Outbound = {
+    arguments: string;
+    call_id: string;
+    id?: string | undefined;
+    name: string;
+    status?: string | string | string | undefined;
+    type: string;
+};
+/** @internal */
+export declare const OutputFunctionCallItem$outboundSchema: z.ZodType<OutputFunctionCallItem$Outbound, OutputFunctionCallItem>;
+export declare function outputFunctionCallItemToJSON(outputFunctionCallItem: OutputFunctionCallItem): string;
+export declare function outputFunctionCallItemFromJSON(jsonString: string): SafeParseResult<OutputFunctionCallItem, SDKValidationError>;
+//# sourceMappingURL=outputfunctioncallitem.d.ts.map

package/esm/models/outputfunctioncallitem.js

@@ -0,0 +1,94 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 9c462e9ff54b
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+export const OutputFunctionCallItemStatusInProgress = {
+    InProgress: "in_progress",
+};
+export const OutputFunctionCallItemStatusIncomplete = {
+    Incomplete: "incomplete",
+};
+export const OutputFunctionCallItemStatusCompleted = {
+    Completed: "completed",
+};
+export const OutputFunctionCallItemType = {
+    FunctionCall: "function_call",
+};
+/** @internal */
+export const OutputFunctionCallItemStatusInProgress$inboundSchema = z.enum(OutputFunctionCallItemStatusInProgress);
+/** @internal */
+export const OutputFunctionCallItemStatusInProgress$outboundSchema = OutputFunctionCallItemStatusInProgress$inboundSchema;
+/** @internal */
+export const OutputFunctionCallItemStatusIncomplete$inboundSchema = z.enum(OutputFunctionCallItemStatusIncomplete);
+/** @internal */
+export const OutputFunctionCallItemStatusIncomplete$outboundSchema = OutputFunctionCallItemStatusIncomplete$inboundSchema;
+/** @internal */
+export const OutputFunctionCallItemStatusCompleted$inboundSchema = z.enum(OutputFunctionCallItemStatusCompleted);
+/** @internal */
+export const OutputFunctionCallItemStatusCompleted$outboundSchema = OutputFunctionCallItemStatusCompleted$inboundSchema;
+/** @internal */
+export const OutputFunctionCallItemStatusUnion$inboundSchema = z.union([
+    OutputFunctionCallItemStatusCompleted$inboundSchema,
+    OutputFunctionCallItemStatusIncomplete$inboundSchema,
+    OutputFunctionCallItemStatusInProgress$inboundSchema,
+]);
+/** @internal */
+export const OutputFunctionCallItemStatusUnion$outboundSchema = z.union([
+    OutputFunctionCallItemStatusCompleted$outboundSchema,
+    OutputFunctionCallItemStatusIncomplete$outboundSchema,
+    OutputFunctionCallItemStatusInProgress$outboundSchema,
+]);
+export function outputFunctionCallItemStatusUnionToJSON(outputFunctionCallItemStatusUnion) {
+    return JSON.stringify(OutputFunctionCallItemStatusUnion$outboundSchema.parse(outputFunctionCallItemStatusUnion));
+}
+export function outputFunctionCallItemStatusUnionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputFunctionCallItemStatusUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputFunctionCallItemStatusUnion' from JSON`);
+}
+/** @internal */
+export const OutputFunctionCallItemType$inboundSchema = z.enum(OutputFunctionCallItemType);
+/** @internal */
+export const OutputFunctionCallItemType$outboundSchema = OutputFunctionCallItemType$inboundSchema;
+/** @internal */
+export const OutputFunctionCallItem$inboundSchema = z.object({
+    arguments: z.string(),
+    call_id: z.string(),
+    id: z.string().optional(),
+    name: z.string(),
+    status: z.union([
+        OutputFunctionCallItemStatusCompleted$inboundSchema,
+        OutputFunctionCallItemStatusIncomplete$inboundSchema,
+        OutputFunctionCallItemStatusInProgress$inboundSchema,
+    ]).optional(),
+    type: OutputFunctionCallItemType$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "call_id": "callId",
+    });
+});
+/** @internal */
+export const OutputFunctionCallItem$outboundSchema = z.object({
+    arguments: z.string(),
+    callId: z.string(),
+    id: z.string().optional(),
+    name: z.string(),
+    status: z.union([
+        OutputFunctionCallItemStatusCompleted$outboundSchema,
+        OutputFunctionCallItemStatusIncomplete$outboundSchema,
+        OutputFunctionCallItemStatusInProgress$outboundSchema,
+    ]).optional(),
+    type: OutputFunctionCallItemType$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        callId: "call_id",
+    });
+});
+export function outputFunctionCallItemToJSON(outputFunctionCallItem) {
+    return JSON.stringify(OutputFunctionCallItem$outboundSchema.parse(outputFunctionCallItem));
+}
+export function outputFunctionCallItemFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OutputFunctionCallItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OutputFunctionCallItem' from JSON`);
+}
+//# sourceMappingURL=outputfunctioncallitem.js.map