@openrouter/sdk 0.9.11 → 0.11.2

package/esm/models/filesearchservertool.d.ts

@@ -0,0 +1,111 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { CompoundFilter, CompoundFilter$Outbound } from "./compoundfilter.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const FiltersType: {
+    readonly Eq: "eq";
+    readonly Ne: "ne";
+    readonly Gt: "gt";
+    readonly Gte: "gte";
+    readonly Lt: "lt";
+    readonly Lte: "lte";
+};
+export type FiltersType = OpenEnum<typeof FiltersType>;
+export type Value1 = string | number;
+export type Value2 = string | number | boolean | Array<string | number>;
+export type FileSearchServerToolFilters = {
+    key: string;
+    type: FiltersType;
+    value: string | number | boolean | Array<string | number>;
+};
+export type Filters = FileSearchServerToolFilters | CompoundFilter | any;
+export declare const Ranker: {
+    readonly Auto: "auto";
+    readonly Default20241115: "default-2024-11-15";
+};
+export type Ranker = OpenEnum<typeof Ranker>;
+export type RankingOptions = {
+    ranker?: Ranker | undefined;
+    scoreThreshold?: number | undefined;
+};
+/**
+ * File search tool configuration
+ */
+export type FileSearchServerTool = {
+    type: "file_search";
+    vectorStoreIds: Array<string>;
+    filters?: FileSearchServerToolFilters | CompoundFilter | any | null | undefined;
+    maxNumResults?: number | undefined;
+    rankingOptions?: RankingOptions | undefined;
+};
+/** @internal */
+export declare const FiltersType$inboundSchema: z.ZodType<FiltersType, unknown>;
+/** @internal */
+export declare const FiltersType$outboundSchema: z.ZodType<string, FiltersType>;
+/** @internal */
+export declare const Value1$inboundSchema: z.ZodType<Value1, unknown>;
+/** @internal */
+export type Value1$Outbound = string | number;
+/** @internal */
+export declare const Value1$outboundSchema: z.ZodType<Value1$Outbound, Value1>;
+export declare function value1ToJSON(value1: Value1): string;
+export declare function value1FromJSON(jsonString: string): SafeParseResult<Value1, SDKValidationError>;
+/** @internal */
+export declare const Value2$inboundSchema: z.ZodType<Value2, unknown>;
+/** @internal */
+export type Value2$Outbound = string | number | boolean | Array<string | number>;
+/** @internal */
+export declare const Value2$outboundSchema: z.ZodType<Value2$Outbound, Value2>;
+export declare function value2ToJSON(value2: Value2): string;
+export declare function value2FromJSON(jsonString: string): SafeParseResult<Value2, SDKValidationError>;
+/** @internal */
+export declare const FileSearchServerToolFilters$inboundSchema: z.ZodType<FileSearchServerToolFilters, unknown>;
+/** @internal */
+export type FileSearchServerToolFilters$Outbound = {
+    key: string;
+    type: string;
+    value: string | number | boolean | Array<string | number>;
+};
+/** @internal */
+export declare const FileSearchServerToolFilters$outboundSchema: z.ZodType<FileSearchServerToolFilters$Outbound, FileSearchServerToolFilters>;
+export declare function fileSearchServerToolFiltersToJSON(fileSearchServerToolFilters: FileSearchServerToolFilters): string;
+export declare function fileSearchServerToolFiltersFromJSON(jsonString: string): SafeParseResult<FileSearchServerToolFilters, SDKValidationError>;
+/** @internal */
+export declare const Filters$inboundSchema: z.ZodType<Filters, unknown>;
+/** @internal */
+export type Filters$Outbound = FileSearchServerToolFilters$Outbound | CompoundFilter$Outbound | any;
+/** @internal */
+export declare const Filters$outboundSchema: z.ZodType<Filters$Outbound, Filters>;
+export declare function filtersToJSON(filters: Filters): string;
+export declare function filtersFromJSON(jsonString: string): SafeParseResult<Filters, SDKValidationError>;
+/** @internal */
+export declare const Ranker$inboundSchema: z.ZodType<Ranker, unknown>;
+/** @internal */
+export declare const Ranker$outboundSchema: z.ZodType<string, Ranker>;
+/** @internal */
+export declare const RankingOptions$inboundSchema: z.ZodType<RankingOptions, unknown>;
+/** @internal */
+export type RankingOptions$Outbound = {
+    ranker?: string | undefined;
+    score_threshold?: number | undefined;
+};
+/** @internal */
+export declare const RankingOptions$outboundSchema: z.ZodType<RankingOptions$Outbound, RankingOptions>;
+export declare function rankingOptionsToJSON(rankingOptions: RankingOptions): string;
+export declare function rankingOptionsFromJSON(jsonString: string): SafeParseResult<RankingOptions, SDKValidationError>;
+/** @internal */
+export declare const FileSearchServerTool$inboundSchema: z.ZodType<FileSearchServerTool, unknown>;
+/** @internal */
+export type FileSearchServerTool$Outbound = {
+    type: "file_search";
+    vector_store_ids: Array<string>;
+    filters?: FileSearchServerToolFilters$Outbound | CompoundFilter$Outbound | any | null | undefined;
+    max_num_results?: number | undefined;
+    ranking_options?: RankingOptions$Outbound | undefined;
+};
+/** @internal */
+export declare const FileSearchServerTool$outboundSchema: z.ZodType<FileSearchServerTool$Outbound, FileSearchServerTool>;
+export declare function fileSearchServerToolToJSON(fileSearchServerTool: FileSearchServerTool): string;
+export declare function fileSearchServerToolFromJSON(jsonString: string): SafeParseResult<FileSearchServerTool, SDKValidationError>;
+//# sourceMappingURL=filesearchservertool.d.ts.map

package/esm/models/filesearchservertool.js

@@ -0,0 +1,180 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: e9b1dc2a101e
+ */
+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";
+import { CompoundFilter$inboundSchema, CompoundFilter$outboundSchema, } from "./compoundfilter.js";
+export const FiltersType = {
+    Eq: "eq",
+    Ne: "ne",
+    Gt: "gt",
+    Gte: "gte",
+    Lt: "lt",
+    Lte: "lte",
+};
+export const Ranker = {
+    Auto: "auto",
+    Default20241115: "default-2024-11-15",
+};
+/** @internal */
+export const FiltersType$inboundSchema = openEnums.inboundSchema(FiltersType);
+/** @internal */
+export const FiltersType$outboundSchema = openEnums.outboundSchema(FiltersType);
+/** @internal */
+export const Value1$inboundSchema = z.union([
+    z.string(),
+    z.number(),
+]);
+/** @internal */
+export const Value1$outboundSchema = z
+    .union([z.string(), z.number()]);
+export function value1ToJSON(value1) {
+    return JSON.stringify(Value1$outboundSchema.parse(value1));
+}
+export function value1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Value1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Value1' from JSON`);
+}
+/** @internal */
+export const Value2$inboundSchema = z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.array(z.union([z.string(), z.number()])),
+]);
+/** @internal */
+export const Value2$outboundSchema = z
+    .union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.array(z.union([z.string(), z.number()])),
+]);
+export function value2ToJSON(value2) {
+    return JSON.stringify(Value2$outboundSchema.parse(value2));
+}
+export function value2FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Value2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Value2' from JSON`);
+}
+/** @internal */
+export const FileSearchServerToolFilters$inboundSchema = z.object({
+    key: z.string(),
+    type: FiltersType$inboundSchema,
+    value: z.union([
+        z.string(),
+        z.number(),
+        z.boolean(),
+        z.array(z.union([z.string(), z.number()])),
+    ]),
+});
+/** @internal */
+export const FileSearchServerToolFilters$outboundSchema = z.object({
+    key: z.string(),
+    type: FiltersType$outboundSchema,
+    value: z.union([
+        z.string(),
+        z.number(),
+        z.boolean(),
+        z.array(z.union([z.string(), z.number()])),
+    ]),
+});
+export function fileSearchServerToolFiltersToJSON(fileSearchServerToolFilters) {
+    return JSON.stringify(FileSearchServerToolFilters$outboundSchema.parse(fileSearchServerToolFilters));
+}
+export function fileSearchServerToolFiltersFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FileSearchServerToolFilters$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FileSearchServerToolFilters' from JSON`);
+}
+/** @internal */
+export const Filters$inboundSchema = z.union([
+    z.lazy(() => FileSearchServerToolFilters$inboundSchema),
+    CompoundFilter$inboundSchema,
+    z.any(),
+]);
+/** @internal */
+export const Filters$outboundSchema = z
+    .union([
+    z.lazy(() => FileSearchServerToolFilters$outboundSchema),
+    CompoundFilter$outboundSchema,
+    z.any(),
+]);
+export function filtersToJSON(filters) {
+    return JSON.stringify(Filters$outboundSchema.parse(filters));
+}
+export function filtersFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Filters$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Filters' from JSON`);
+}
+/** @internal */
+export const Ranker$inboundSchema = openEnums
+    .inboundSchema(Ranker);
+/** @internal */
+export const Ranker$outboundSchema = openEnums
+    .outboundSchema(Ranker);
+/** @internal */
+export const RankingOptions$inboundSchema = z.object({
+    ranker: Ranker$inboundSchema.optional(),
+    score_threshold: z.number().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "score_threshold": "scoreThreshold",
+    });
+});
+/** @internal */
+export const RankingOptions$outboundSchema = z.object({
+    ranker: Ranker$outboundSchema.optional(),
+    scoreThreshold: z.number().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        scoreThreshold: "score_threshold",
+    });
+});
+export function rankingOptionsToJSON(rankingOptions) {
+    return JSON.stringify(RankingOptions$outboundSchema.parse(rankingOptions));
+}
+export function rankingOptionsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => RankingOptions$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'RankingOptions' from JSON`);
+}
+/** @internal */
+export const FileSearchServerTool$inboundSchema = z.object({
+    type: z.literal("file_search"),
+    vector_store_ids: z.array(z.string()),
+    filters: z.nullable(z.union([
+        z.lazy(() => FileSearchServerToolFilters$inboundSchema),
+        CompoundFilter$inboundSchema,
+        z.any(),
+    ])).optional(),
+    max_num_results: z.int().optional(),
+    ranking_options: z.lazy(() => RankingOptions$inboundSchema).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "vector_store_ids": "vectorStoreIds",
+        "max_num_results": "maxNumResults",
+        "ranking_options": "rankingOptions",
+    });
+});
+/** @internal */
+export const FileSearchServerTool$outboundSchema = z.object({
+    type: z.literal("file_search"),
+    vectorStoreIds: z.array(z.string()),
+    filters: z.nullable(z.union([
+        z.lazy(() => FileSearchServerToolFilters$outboundSchema),
+        CompoundFilter$outboundSchema,
+        z.any(),
+    ])).optional(),
+    maxNumResults: z.int().optional(),
+    rankingOptions: z.lazy(() => RankingOptions$outboundSchema).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        vectorStoreIds: "vector_store_ids",
+        maxNumResults: "max_num_results",
+        rankingOptions: "ranking_options",
+    });
+});
+export function fileSearchServerToolToJSON(fileSearchServerTool) {
+    return JSON.stringify(FileSearchServerTool$outboundSchema.parse(fileSearchServerTool));
+}
+export function fileSearchServerToolFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FileSearchServerTool$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FileSearchServerTool' from JSON`);
+}
+//# sourceMappingURL=filesearchservertool.js.map

package/esm/models/formatjsonobjectconfig.d.ts

@@ -0,0 +1,20 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * JSON object response format
+ */
+export type FormatJsonObjectConfig = {
+    type: "json_object";
+};
+/** @internal */
+export declare const FormatJsonObjectConfig$inboundSchema: z.ZodType<FormatJsonObjectConfig, unknown>;
+/** @internal */
+export type FormatJsonObjectConfig$Outbound = {
+    type: "json_object";
+};
+/** @internal */
+export declare const FormatJsonObjectConfig$outboundSchema: z.ZodType<FormatJsonObjectConfig$Outbound, FormatJsonObjectConfig>;
+export declare function formatJsonObjectConfigToJSON(formatJsonObjectConfig: FormatJsonObjectConfig): string;
+export declare function formatJsonObjectConfigFromJSON(jsonString: string): SafeParseResult<FormatJsonObjectConfig, SDKValidationError>;
+//# sourceMappingURL=formatjsonobjectconfig.d.ts.map

package/esm/models/formatjsonobjectconfig.js

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 18c9f55ddf22
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const FormatJsonObjectConfig$inboundSchema = z.object({
+    type: z.literal("json_object"),
+});
+/** @internal */
+export const FormatJsonObjectConfig$outboundSchema = z.object({
+    type: z.literal("json_object"),
+});
+export function formatJsonObjectConfigToJSON(formatJsonObjectConfig) {
+    return JSON.stringify(FormatJsonObjectConfig$outboundSchema.parse(formatJsonObjectConfig));
+}
+export function formatJsonObjectConfigFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FormatJsonObjectConfig$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FormatJsonObjectConfig' from JSON`);
+}
+//# sourceMappingURL=formatjsonobjectconfig.js.map

package/esm/models/formatjsonschemaconfig.d.ts

@@ -0,0 +1,32 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * JSON schema constrained response format
+ */
+export type FormatJsonSchemaConfig = {
+    type: "json_schema";
+    name: string;
+    description?: string | undefined;
+    strict?: boolean | null | undefined;
+    schema: {
+        [k: string]: any | null;
+    };
+};
+/** @internal */
+export declare const FormatJsonSchemaConfig$inboundSchema: z.ZodType<FormatJsonSchemaConfig, unknown>;
+/** @internal */
+export type FormatJsonSchemaConfig$Outbound = {
+    type: "json_schema";
+    name: string;
+    description?: string | undefined;
+    strict?: boolean | null | undefined;
+    schema: {
+        [k: string]: any | null;
+    };
+};
+/** @internal */
+export declare const FormatJsonSchemaConfig$outboundSchema: z.ZodType<FormatJsonSchemaConfig$Outbound, FormatJsonSchemaConfig>;
+export declare function formatJsonSchemaConfigToJSON(formatJsonSchemaConfig: FormatJsonSchemaConfig): string;
+export declare function formatJsonSchemaConfigFromJSON(jsonString: string): SafeParseResult<FormatJsonSchemaConfig, SDKValidationError>;
+//# sourceMappingURL=formatjsonschemaconfig.d.ts.map

package/esm/models/formatjsonschemaconfig.js

@@ -0,0 +1,29 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: dbec4c78c132
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const FormatJsonSchemaConfig$inboundSchema = z.object({
+    type: z.literal("json_schema"),
+    name: z.string(),
+    description: z.string().optional(),
+    strict: z.nullable(z.boolean()).optional(),
+    schema: z.record(z.string(), z.nullable(z.any())),
+});
+/** @internal */
+export const FormatJsonSchemaConfig$outboundSchema = z.object({
+    type: z.literal("json_schema"),
+    name: z.string(),
+    description: z.string().optional(),
+    strict: z.nullable(z.boolean()).optional(),
+    schema: z.record(z.string(), z.nullable(z.any())),
+});
+export function formatJsonSchemaConfigToJSON(formatJsonSchemaConfig) {
+    return JSON.stringify(FormatJsonSchemaConfig$outboundSchema.parse(formatJsonSchemaConfig));
+}
+export function formatJsonSchemaConfigFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FormatJsonSchemaConfig$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FormatJsonSchemaConfig' from JSON`);
+}
+//# sourceMappingURL=formatjsonschemaconfig.js.map

package/esm/models/formats.d.ts

@@ -0,0 +1,19 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { FormatJsonObjectConfig, FormatJsonObjectConfig$Outbound } from "./formatjsonobjectconfig.js";
+import { FormatJsonSchemaConfig, FormatJsonSchemaConfig$Outbound } from "./formatjsonschemaconfig.js";
+import { FormatTextConfig, FormatTextConfig$Outbound } from "./formattextconfig.js";
+/**
+ * Text response format configuration
+ */
+export type Formats = FormatTextConfig | FormatJsonObjectConfig | FormatJsonSchemaConfig;
+/** @internal */
+export declare const Formats$inboundSchema: z.ZodType<Formats, unknown>;
+/** @internal */
+export type Formats$Outbound = FormatTextConfig$Outbound | FormatJsonObjectConfig$Outbound | FormatJsonSchemaConfig$Outbound;
+/** @internal */
+export declare const Formats$outboundSchema: z.ZodType<Formats$Outbound, Formats>;
+export declare function formatsToJSON(formats: Formats): string;
+export declare function formatsFromJSON(jsonString: string): SafeParseResult<Formats, SDKValidationError>;
+//# sourceMappingURL=formats.d.ts.map

package/esm/models/formats.js

@@ -0,0 +1,29 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 6e4608e1920c
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { FormatJsonObjectConfig$inboundSchema, FormatJsonObjectConfig$outboundSchema, } from "./formatjsonobjectconfig.js";
+import { FormatJsonSchemaConfig$inboundSchema, FormatJsonSchemaConfig$outboundSchema, } from "./formatjsonschemaconfig.js";
+import { FormatTextConfig$inboundSchema, FormatTextConfig$outboundSchema, } from "./formattextconfig.js";
+/** @internal */
+export const Formats$inboundSchema = z.union([
+    FormatTextConfig$inboundSchema,
+    FormatJsonObjectConfig$inboundSchema,
+    FormatJsonSchemaConfig$inboundSchema,
+]);
+/** @internal */
+export const Formats$outboundSchema = z
+    .union([
+    FormatTextConfig$outboundSchema,
+    FormatJsonObjectConfig$outboundSchema,
+    FormatJsonSchemaConfig$outboundSchema,
+]);
+export function formatsToJSON(formats) {
+    return JSON.stringify(Formats$outboundSchema.parse(formats));
+}
+export function formatsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Formats$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Formats' from JSON`);
+}
+//# sourceMappingURL=formats.js.map

package/esm/models/formattextconfig.d.ts

@@ -0,0 +1,20 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Plain text response format
+ */
+export type FormatTextConfig = {
+    type: "text";
+};
+/** @internal */
+export declare const FormatTextConfig$inboundSchema: z.ZodType<FormatTextConfig, unknown>;
+/** @internal */
+export type FormatTextConfig$Outbound = {
+    type: "text";
+};
+/** @internal */
+export declare const FormatTextConfig$outboundSchema: z.ZodType<FormatTextConfig$Outbound, FormatTextConfig>;
+export declare function formatTextConfigToJSON(formatTextConfig: FormatTextConfig): string;
+export declare function formatTextConfigFromJSON(jsonString: string): SafeParseResult<FormatTextConfig, SDKValidationError>;
+//# sourceMappingURL=formattextconfig.d.ts.map

package/esm/models/formattextconfig.js

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 06c312c9c674
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const FormatTextConfig$inboundSchema = z.object({
+    type: z.literal("text"),
+});
+/** @internal */
+export const FormatTextConfig$outboundSchema = z.object({
+    type: z.literal("text"),
+});
+export function formatTextConfigToJSON(formatTextConfig) {
+    return JSON.stringify(FormatTextConfig$outboundSchema.parse(formatTextConfig));
+}
+export function formatTextConfigFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FormatTextConfig$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FormatTextConfig' from JSON`);
+}
+//# sourceMappingURL=formattextconfig.js.map

package/esm/models/functioncallargsdeltaevent.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";
+/**
+ * Event emitted when function call arguments are being streamed
+ */
+export type FunctionCallArgsDeltaEvent = {
+    type: "response.function_call_arguments.delta";
+    itemId: string;
+    outputIndex: number;
+    delta: string;
+    sequenceNumber: number;
+};
+/** @internal */
+export declare const FunctionCallArgsDeltaEvent$inboundSchema: z.ZodType<FunctionCallArgsDeltaEvent, unknown>;
+export declare function functionCallArgsDeltaEventFromJSON(jsonString: string): SafeParseResult<FunctionCallArgsDeltaEvent, SDKValidationError>;
+//# sourceMappingURL=functioncallargsdeltaevent.d.ts.map

package/esm/models/functioncallargsdeltaevent.js

@@ -0,0 +1,25 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 2f23b040fdad
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const FunctionCallArgsDeltaEvent$inboundSchema = z.object({
+    type: z.literal("response.function_call_arguments.delta"),
+    item_id: z.string(),
+    output_index: z.number(),
+    delta: z.string(),
+    sequence_number: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        "item_id": "itemId",
+        "output_index": "outputIndex",
+        "sequence_number": "sequenceNumber",
+    });
+});
+export function functionCallArgsDeltaEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FunctionCallArgsDeltaEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FunctionCallArgsDeltaEvent' from JSON`);
+}
+//# sourceMappingURL=functioncallargsdeltaevent.js.map

package/esm/models/functioncallargsdoneevent.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";
+/**
+ * Event emitted when function call arguments streaming is complete
+ */
+export type FunctionCallArgsDoneEvent = {
+    type: "response.function_call_arguments.done";
+    itemId: string;
+    outputIndex: number;
+    name: string;
+    arguments: string;
+    sequenceNumber: number;
+};
+/** @internal */
+export declare const FunctionCallArgsDoneEvent$inboundSchema: z.ZodType<FunctionCallArgsDoneEvent, unknown>;
+export declare function functionCallArgsDoneEventFromJSON(jsonString: string): SafeParseResult<FunctionCallArgsDoneEvent, SDKValidationError>;
+//# sourceMappingURL=functioncallargsdoneevent.d.ts.map

package/esm/models/functioncallargsdoneevent.js

@@ -0,0 +1,26 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: b2142af551f4
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const FunctionCallArgsDoneEvent$inboundSchema = z.object({
+    type: z.literal("response.function_call_arguments.done"),
+    item_id: z.string(),
+    output_index: z.number(),
+    name: z.string(),
+    arguments: z.string(),
+    sequence_number: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        "item_id": "itemId",
+        "output_index": "outputIndex",
+        "sequence_number": "sequenceNumber",
+    });
+});
+export function functionCallArgsDoneEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FunctionCallArgsDoneEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FunctionCallArgsDoneEvent' from JSON`);
+}
+//# sourceMappingURL=functioncallargsdoneevent.js.map

package/esm/models/functioncallitem.d.ts

@@ -0,0 +1,33 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { ToolCallStatusEnum } from "./toolcallstatusenum.js";
+export declare const FunctionCallItemType: {
+    readonly FunctionCall: "function_call";
+};
+export type FunctionCallItemType = ClosedEnum<typeof FunctionCallItemType>;
+/**
+ * A function call initiated by the model
+ */
+export type FunctionCallItem = {
+    type: FunctionCallItemType;
+    callId: string;
+    name: string;
+    arguments: string;
+    id: string;
+    status?: ToolCallStatusEnum | null | undefined;
+};
+/** @internal */
+export declare const FunctionCallItemType$outboundSchema: z.ZodEnum<typeof FunctionCallItemType>;
+/** @internal */
+export type FunctionCallItem$Outbound = {
+    type: string;
+    call_id: string;
+    name: string;
+    arguments: string;
+    id: string;
+    status?: string | null | undefined;
+};
+/** @internal */
+export declare const FunctionCallItem$outboundSchema: z.ZodType<FunctionCallItem$Outbound, FunctionCallItem>;
+export declare function functionCallItemToJSON(functionCallItem: FunctionCallItem): string;
+//# sourceMappingURL=functioncallitem.d.ts.map

package/esm/models/functioncallitem.js

@@ -0,0 +1,29 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 7e96e10e664b
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { ToolCallStatusEnum$outboundSchema, } from "./toolcallstatusenum.js";
+export const FunctionCallItemType = {
+    FunctionCall: "function_call",
+};
+/** @internal */
+export const FunctionCallItemType$outboundSchema = z.enum(FunctionCallItemType);
+/** @internal */
+export const FunctionCallItem$outboundSchema = z.object({
+    type: FunctionCallItemType$outboundSchema,
+    callId: z.string(),
+    name: z.string(),
+    arguments: z.string(),
+    id: z.string(),
+    status: z.nullable(ToolCallStatusEnum$outboundSchema).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        callId: "call_id",
+    });
+});
+export function functionCallItemToJSON(functionCallItem) {
+    return JSON.stringify(FunctionCallItem$outboundSchema.parse(functionCallItem));
+}
+//# sourceMappingURL=functioncallitem.js.map