@openrouter/sdk 0.0.1-beta.1 → 0.0.1-beta.10

package/esm/models/openresponsesnonstreamingresponse.d.ts

@@ -0,0 +1,230 @@
+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 { OpenAIResponsesIncompleteDetails, OpenAIResponsesIncompleteDetails$Outbound } from "./openairesponsesincompletedetails.js";
+import { OpenAIResponsesInputUnion, OpenAIResponsesInputUnion$Outbound } from "./openairesponsesinputunion.js";
+import { OpenAIResponsesPrompt, OpenAIResponsesPrompt$Outbound } from "./openairesponsesprompt.js";
+import { OpenAIResponsesReasoningConfig, OpenAIResponsesReasoningConfig$Outbound } from "./openairesponsesreasoningconfig.js";
+import { OpenAIResponsesResponseStatus } from "./openairesponsesresponsestatus.js";
+import { OpenAIResponsesServiceTier } from "./openairesponsesservicetier.js";
+import { OpenAIResponsesToolChoiceUnion, OpenAIResponsesToolChoiceUnion$Outbound } from "./openairesponsestoolchoiceunion.js";
+import { OpenAIResponsesTruncation } from "./openairesponsestruncation.js";
+import { OpenResponsesUsage, OpenResponsesUsage$Outbound } from "./openresponsesusage.js";
+import { OpenResponsesWebSearch20250826Tool, OpenResponsesWebSearch20250826Tool$Outbound } from "./openresponseswebsearch20250826tool.js";
+import { OpenResponsesWebSearchPreview20250311Tool, OpenResponsesWebSearchPreview20250311Tool$Outbound } from "./openresponseswebsearchpreview20250311tool.js";
+import { OpenResponsesWebSearchPreviewTool, OpenResponsesWebSearchPreviewTool$Outbound } from "./openresponseswebsearchpreviewtool.js";
+import { OpenResponsesWebSearchTool, OpenResponsesWebSearchTool$Outbound } from "./openresponseswebsearchtool.js";
+import { ResponsesErrorField, ResponsesErrorField$Outbound } from "./responseserrorfield.js";
+import { ResponsesOutputItem, ResponsesOutputItem$Outbound } from "./responsesoutputitem.js";
+import { ResponseTextConfig, ResponseTextConfig$Outbound } from "./responsetextconfig.js";
+export declare const ObjectT: {
+    readonly Response: "response";
+};
+export type ObjectT = ClosedEnum<typeof ObjectT>;
+export declare const OpenResponsesNonStreamingResponseType: {
+    readonly Function: "function";
+};
+export type OpenResponsesNonStreamingResponseType = ClosedEnum<typeof OpenResponsesNonStreamingResponseType>;
+/**
+ * Function tool definition
+ */
+export type OpenResponsesNonStreamingResponseToolFunction = {
+    type: OpenResponsesNonStreamingResponseType;
+    name: string;
+    description?: string | null | undefined;
+    strict?: boolean | null | undefined;
+    parameters: {
+        [k: string]: any | null;
+    } | null;
+};
+export type ToolUnion = OpenResponsesNonStreamingResponseToolFunction | OpenResponsesWebSearchPreviewTool | OpenResponsesWebSearchPreview20250311Tool | OpenResponsesWebSearchTool | OpenResponsesWebSearch20250826Tool;
+/**
+ * Complete non-streaming response from the Responses API
+ */
+export type OpenResponsesNonStreamingResponse = {
+    id: string;
+    object: ObjectT;
+    createdAt: number;
+    model: string;
+    status?: OpenAIResponsesResponseStatus | undefined;
+    output: Array<ResponsesOutputItem>;
+    user?: string | null | undefined;
+    outputText?: string | undefined;
+    promptCacheKey?: string | null | undefined;
+    safetyIdentifier?: string | null | undefined;
+    /**
+     * Error information returned from the API
+     */
+    error: ResponsesErrorField | null;
+    incompleteDetails: OpenAIResponsesIncompleteDetails | null;
+    /**
+     * Token usage information for the response
+     */
+    usage?: OpenResponsesUsage | undefined;
+    maxToolCalls?: number | null | undefined;
+    topLogprobs?: number | undefined;
+    maxOutputTokens?: number | null | undefined;
+    temperature: number | null;
+    topP: number | null;
+    instructions?: OpenAIResponsesInputUnion | null | undefined;
+    /**
+     * Metadata key-value pairs for the request. Keys must be ≤64 characters and cannot contain brackets. Values must be ≤512 characters. Maximum 16 pairs allowed.
+     */
+    metadata: {
+        [k: string]: string;
+    } | null;
+    tools: Array<OpenResponsesNonStreamingResponseToolFunction | OpenResponsesWebSearchPreviewTool | OpenResponsesWebSearchPreview20250311Tool | OpenResponsesWebSearchTool | OpenResponsesWebSearch20250826Tool>;
+    toolChoice: OpenAIResponsesToolChoiceUnion;
+    parallelToolCalls: boolean;
+    prompt?: OpenAIResponsesPrompt | null | undefined;
+    background?: boolean | null | undefined;
+    previousResponseId?: string | null | undefined;
+    reasoning?: OpenAIResponsesReasoningConfig | null | undefined;
+    serviceTier?: OpenAIResponsesServiceTier | null | undefined;
+    store?: boolean | undefined;
+    truncation?: OpenAIResponsesTruncation | null | undefined;
+    /**
+     * Text output configuration including format and verbosity
+     */
+    text?: ResponseTextConfig | undefined;
+};
+/** @internal */
+export declare const ObjectT$inboundSchema: z.ZodEnum<typeof ObjectT>;
+/** @internal */
+export declare const ObjectT$outboundSchema: z.ZodEnum<typeof ObjectT>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ObjectT$ {
+    /** @deprecated use `ObjectT$inboundSchema` instead. */
+    const inboundSchema: z.ZodEnum<{
+        readonly Response: "response";
+    }>;
+    /** @deprecated use `ObjectT$outboundSchema` instead. */
+    const outboundSchema: z.ZodEnum<{
+        readonly Response: "response";
+    }>;
+}
+/** @internal */
+export declare const OpenResponsesNonStreamingResponseType$inboundSchema: z.ZodEnum<typeof OpenResponsesNonStreamingResponseType>;
+/** @internal */
+export declare const OpenResponsesNonStreamingResponseType$outboundSchema: z.ZodEnum<typeof OpenResponsesNonStreamingResponseType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace OpenResponsesNonStreamingResponseType$ {
+    /** @deprecated use `OpenResponsesNonStreamingResponseType$inboundSchema` instead. */
+    const inboundSchema: z.ZodEnum<{
+        readonly Function: "function";
+    }>;
+    /** @deprecated use `OpenResponsesNonStreamingResponseType$outboundSchema` instead. */
+    const outboundSchema: z.ZodEnum<{
+        readonly Function: "function";
+    }>;
+}
+/** @internal */
+export declare const OpenResponsesNonStreamingResponseToolFunction$inboundSchema: z.ZodType<OpenResponsesNonStreamingResponseToolFunction, unknown>;
+/** @internal */
+export type OpenResponsesNonStreamingResponseToolFunction$Outbound = {
+    type: string;
+    name: string;
+    description?: string | null | undefined;
+    strict?: boolean | null | undefined;
+    parameters: {
+        [k: string]: any | null;
+    } | null;
+};
+/** @internal */
+export declare const OpenResponsesNonStreamingResponseToolFunction$outboundSchema: z.ZodType<OpenResponsesNonStreamingResponseToolFunction$Outbound, OpenResponsesNonStreamingResponseToolFunction>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace OpenResponsesNonStreamingResponseToolFunction$ {
+    /** @deprecated use `OpenResponsesNonStreamingResponseToolFunction$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<OpenResponsesNonStreamingResponseToolFunction, unknown, z.core.$ZodTypeInternals<OpenResponsesNonStreamingResponseToolFunction, unknown>>;
+    /** @deprecated use `OpenResponsesNonStreamingResponseToolFunction$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<OpenResponsesNonStreamingResponseToolFunction$Outbound, OpenResponsesNonStreamingResponseToolFunction, z.core.$ZodTypeInternals<OpenResponsesNonStreamingResponseToolFunction$Outbound, OpenResponsesNonStreamingResponseToolFunction>>;
+    /** @deprecated use `OpenResponsesNonStreamingResponseToolFunction$Outbound` instead. */
+    type Outbound = OpenResponsesNonStreamingResponseToolFunction$Outbound;
+}
+export declare function openResponsesNonStreamingResponseToolFunctionToJSON(openResponsesNonStreamingResponseToolFunction: OpenResponsesNonStreamingResponseToolFunction): string;
+export declare function openResponsesNonStreamingResponseToolFunctionFromJSON(jsonString: string): SafeParseResult<OpenResponsesNonStreamingResponseToolFunction, SDKValidationError>;
+/** @internal */
+export declare const ToolUnion$inboundSchema: z.ZodType<ToolUnion, unknown>;
+/** @internal */
+export type ToolUnion$Outbound = OpenResponsesNonStreamingResponseToolFunction$Outbound | OpenResponsesWebSearchPreviewTool$Outbound | OpenResponsesWebSearchPreview20250311Tool$Outbound | OpenResponsesWebSearchTool$Outbound | OpenResponsesWebSearch20250826Tool$Outbound;
+/** @internal */
+export declare const ToolUnion$outboundSchema: z.ZodType<ToolUnion$Outbound, ToolUnion>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ToolUnion$ {
+    /** @deprecated use `ToolUnion$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ToolUnion, unknown, z.core.$ZodTypeInternals<ToolUnion, unknown>>;
+    /** @deprecated use `ToolUnion$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ToolUnion$Outbound, ToolUnion, z.core.$ZodTypeInternals<ToolUnion$Outbound, ToolUnion>>;
+    /** @deprecated use `ToolUnion$Outbound` instead. */
+    type Outbound = ToolUnion$Outbound;
+}
+export declare function toolUnionToJSON(toolUnion: ToolUnion): string;
+export declare function toolUnionFromJSON(jsonString: string): SafeParseResult<ToolUnion, SDKValidationError>;
+/** @internal */
+export declare const OpenResponsesNonStreamingResponse$inboundSchema: z.ZodType<OpenResponsesNonStreamingResponse, unknown>;
+/** @internal */
+export type OpenResponsesNonStreamingResponse$Outbound = {
+    id: string;
+    object: string;
+    created_at: number;
+    model: string;
+    status?: string | undefined;
+    output: Array<ResponsesOutputItem$Outbound>;
+    user?: string | null | undefined;
+    output_text?: string | undefined;
+    prompt_cache_key?: string | null | undefined;
+    safety_identifier?: string | null | undefined;
+    error: ResponsesErrorField$Outbound | null;
+    incomplete_details: OpenAIResponsesIncompleteDetails$Outbound | null;
+    usage?: OpenResponsesUsage$Outbound | undefined;
+    max_tool_calls?: number | null | undefined;
+    top_logprobs?: number | undefined;
+    max_output_tokens?: number | null | undefined;
+    temperature: number | null;
+    top_p: number | null;
+    instructions?: OpenAIResponsesInputUnion$Outbound | null | undefined;
+    metadata: {
+        [k: string]: string;
+    } | null;
+    tools: Array<OpenResponsesNonStreamingResponseToolFunction$Outbound | OpenResponsesWebSearchPreviewTool$Outbound | OpenResponsesWebSearchPreview20250311Tool$Outbound | OpenResponsesWebSearchTool$Outbound | OpenResponsesWebSearch20250826Tool$Outbound>;
+    tool_choice: OpenAIResponsesToolChoiceUnion$Outbound;
+    parallel_tool_calls: boolean;
+    prompt?: OpenAIResponsesPrompt$Outbound | null | undefined;
+    background?: boolean | null | undefined;
+    previous_response_id?: string | null | undefined;
+    reasoning?: OpenAIResponsesReasoningConfig$Outbound | null | undefined;
+    service_tier?: string | null | undefined;
+    store?: boolean | undefined;
+    truncation?: string | null | undefined;
+    text?: ResponseTextConfig$Outbound | undefined;
+};
+/** @internal */
+export declare const OpenResponsesNonStreamingResponse$outboundSchema: z.ZodType<OpenResponsesNonStreamingResponse$Outbound, OpenResponsesNonStreamingResponse>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace OpenResponsesNonStreamingResponse$ {
+    /** @deprecated use `OpenResponsesNonStreamingResponse$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<OpenResponsesNonStreamingResponse, unknown, z.core.$ZodTypeInternals<OpenResponsesNonStreamingResponse, unknown>>;
+    /** @deprecated use `OpenResponsesNonStreamingResponse$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<OpenResponsesNonStreamingResponse$Outbound, OpenResponsesNonStreamingResponse, z.core.$ZodTypeInternals<OpenResponsesNonStreamingResponse$Outbound, OpenResponsesNonStreamingResponse>>;
+    /** @deprecated use `OpenResponsesNonStreamingResponse$Outbound` instead. */
+    type Outbound = OpenResponsesNonStreamingResponse$Outbound;
+}
+export declare function openResponsesNonStreamingResponseToJSON(openResponsesNonStreamingResponse: OpenResponsesNonStreamingResponse): string;
+export declare function openResponsesNonStreamingResponseFromJSON(jsonString: string): SafeParseResult<OpenResponsesNonStreamingResponse, SDKValidationError>;
+//# sourceMappingURL=openresponsesnonstreamingresponse.d.ts.map

package/esm/models/openresponsesnonstreamingresponse.js

@@ -0,0 +1,256 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { OpenAIResponsesIncompleteDetails$inboundSchema, OpenAIResponsesIncompleteDetails$outboundSchema, } from "./openairesponsesincompletedetails.js";
+import { OpenAIResponsesInputUnion$inboundSchema, OpenAIResponsesInputUnion$outboundSchema, } from "./openairesponsesinputunion.js";
+import { OpenAIResponsesPrompt$inboundSchema, OpenAIResponsesPrompt$outboundSchema, } from "./openairesponsesprompt.js";
+import { OpenAIResponsesReasoningConfig$inboundSchema, OpenAIResponsesReasoningConfig$outboundSchema, } from "./openairesponsesreasoningconfig.js";
+import { OpenAIResponsesResponseStatus$inboundSchema, OpenAIResponsesResponseStatus$outboundSchema, } from "./openairesponsesresponsestatus.js";
+import { OpenAIResponsesServiceTier$inboundSchema, OpenAIResponsesServiceTier$outboundSchema, } from "./openairesponsesservicetier.js";
+import { OpenAIResponsesToolChoiceUnion$inboundSchema, OpenAIResponsesToolChoiceUnion$outboundSchema, } from "./openairesponsestoolchoiceunion.js";
+import { OpenAIResponsesTruncation$inboundSchema, OpenAIResponsesTruncation$outboundSchema, } from "./openairesponsestruncation.js";
+import { OpenResponsesUsage$inboundSchema, OpenResponsesUsage$outboundSchema, } from "./openresponsesusage.js";
+import { OpenResponsesWebSearch20250826Tool$inboundSchema, OpenResponsesWebSearch20250826Tool$outboundSchema, } from "./openresponseswebsearch20250826tool.js";
+import { OpenResponsesWebSearchPreview20250311Tool$inboundSchema, OpenResponsesWebSearchPreview20250311Tool$outboundSchema, } from "./openresponseswebsearchpreview20250311tool.js";
+import { OpenResponsesWebSearchPreviewTool$inboundSchema, OpenResponsesWebSearchPreviewTool$outboundSchema, } from "./openresponseswebsearchpreviewtool.js";
+import { OpenResponsesWebSearchTool$inboundSchema, OpenResponsesWebSearchTool$outboundSchema, } from "./openresponseswebsearchtool.js";
+import { ResponsesErrorField$inboundSchema, ResponsesErrorField$outboundSchema, } from "./responseserrorfield.js";
+import { ResponsesOutputItem$inboundSchema, ResponsesOutputItem$outboundSchema, } from "./responsesoutputitem.js";
+import { ResponseTextConfig$inboundSchema, ResponseTextConfig$outboundSchema, } from "./responsetextconfig.js";
+export const ObjectT = {
+    Response: "response",
+};
+export const OpenResponsesNonStreamingResponseType = {
+    Function: "function",
+};
+/** @internal */
+export const ObjectT$inboundSchema = z.enum(ObjectT);
+/** @internal */
+export const ObjectT$outboundSchema = ObjectT$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var ObjectT$;
+(function (ObjectT$) {
+    /** @deprecated use `ObjectT$inboundSchema` instead. */
+    ObjectT$.inboundSchema = ObjectT$inboundSchema;
+    /** @deprecated use `ObjectT$outboundSchema` instead. */
+    ObjectT$.outboundSchema = ObjectT$outboundSchema;
+})(ObjectT$ || (ObjectT$ = {}));
+/** @internal */
+export const OpenResponsesNonStreamingResponseType$inboundSchema = z.enum(OpenResponsesNonStreamingResponseType);
+/** @internal */
+export const OpenResponsesNonStreamingResponseType$outboundSchema = OpenResponsesNonStreamingResponseType$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseType$;
+(function (OpenResponsesNonStreamingResponseType$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseType$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseType$.inboundSchema = OpenResponsesNonStreamingResponseType$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseType$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseType$.outboundSchema = OpenResponsesNonStreamingResponseType$outboundSchema;
+})(OpenResponsesNonStreamingResponseType$ || (OpenResponsesNonStreamingResponseType$ = {}));
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolFunction$inboundSchema = z.object({
+    type: OpenResponsesNonStreamingResponseType$inboundSchema,
+    name: z.string(),
+    description: z.nullable(z.string()).optional(),
+    strict: z.nullable(z.boolean()).optional(),
+    parameters: z.nullable(z.record(z.string(), z.nullable(z.any()))),
+});
+/** @internal */
+export const OpenResponsesNonStreamingResponseToolFunction$outboundSchema = z.object({
+    type: OpenResponsesNonStreamingResponseType$outboundSchema,
+    name: z.string(),
+    description: z.nullable(z.string()).optional(),
+    strict: z.nullable(z.boolean()).optional(),
+    parameters: z.nullable(z.record(z.string(), z.nullable(z.any()))),
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponseToolFunction$;
+(function (OpenResponsesNonStreamingResponseToolFunction$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponseToolFunction$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponseToolFunction$.inboundSchema = OpenResponsesNonStreamingResponseToolFunction$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponseToolFunction$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponseToolFunction$.outboundSchema = OpenResponsesNonStreamingResponseToolFunction$outboundSchema;
+})(OpenResponsesNonStreamingResponseToolFunction$ || (OpenResponsesNonStreamingResponseToolFunction$ = {}));
+export function openResponsesNonStreamingResponseToolFunctionToJSON(openResponsesNonStreamingResponseToolFunction) {
+    return JSON.stringify(OpenResponsesNonStreamingResponseToolFunction$outboundSchema.parse(openResponsesNonStreamingResponseToolFunction));
+}
+export function openResponsesNonStreamingResponseToolFunctionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesNonStreamingResponseToolFunction$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesNonStreamingResponseToolFunction' from JSON`);
+}
+/** @internal */
+export const ToolUnion$inboundSchema = z.union([
+    z.lazy(() => OpenResponsesNonStreamingResponseToolFunction$inboundSchema),
+    OpenResponsesWebSearchPreviewTool$inboundSchema,
+    OpenResponsesWebSearchPreview20250311Tool$inboundSchema,
+    OpenResponsesWebSearchTool$inboundSchema,
+    OpenResponsesWebSearch20250826Tool$inboundSchema,
+]);
+/** @internal */
+export const ToolUnion$outboundSchema = z.union([
+    z.lazy(() => OpenResponsesNonStreamingResponseToolFunction$outboundSchema),
+    OpenResponsesWebSearchPreviewTool$outboundSchema,
+    OpenResponsesWebSearchPreview20250311Tool$outboundSchema,
+    OpenResponsesWebSearchTool$outboundSchema,
+    OpenResponsesWebSearch20250826Tool$outboundSchema,
+]);
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var ToolUnion$;
+(function (ToolUnion$) {
+    /** @deprecated use `ToolUnion$inboundSchema` instead. */
+    ToolUnion$.inboundSchema = ToolUnion$inboundSchema;
+    /** @deprecated use `ToolUnion$outboundSchema` instead. */
+    ToolUnion$.outboundSchema = ToolUnion$outboundSchema;
+})(ToolUnion$ || (ToolUnion$ = {}));
+export function toolUnionToJSON(toolUnion) {
+    return JSON.stringify(ToolUnion$outboundSchema.parse(toolUnion));
+}
+export function toolUnionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ToolUnion$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ToolUnion' from JSON`);
+}
+/** @internal */
+export const OpenResponsesNonStreamingResponse$inboundSchema = z.object({
+    id: z.string(),
+    object: ObjectT$inboundSchema,
+    created_at: z.number(),
+    model: z.string(),
+    status: OpenAIResponsesResponseStatus$inboundSchema.optional(),
+    output: z.array(ResponsesOutputItem$inboundSchema),
+    user: z.nullable(z.string()).optional(),
+    output_text: z.string().optional(),
+    prompt_cache_key: z.nullable(z.string()).optional(),
+    safety_identifier: z.nullable(z.string()).optional(),
+    error: z.nullable(ResponsesErrorField$inboundSchema),
+    incomplete_details: z.nullable(OpenAIResponsesIncompleteDetails$inboundSchema),
+    usage: OpenResponsesUsage$inboundSchema.optional(),
+    max_tool_calls: z.nullable(z.number()).optional(),
+    top_logprobs: z.number().optional(),
+    max_output_tokens: z.nullable(z.number()).optional(),
+    temperature: z.nullable(z.number()),
+    top_p: z.nullable(z.number()),
+    instructions: z.nullable(OpenAIResponsesInputUnion$inboundSchema).optional(),
+    metadata: z.nullable(z.record(z.string(), z.string())),
+    tools: z.array(z.union([
+        z.lazy(() => OpenResponsesNonStreamingResponseToolFunction$inboundSchema),
+        OpenResponsesWebSearchPreviewTool$inboundSchema,
+        OpenResponsesWebSearchPreview20250311Tool$inboundSchema,
+        OpenResponsesWebSearchTool$inboundSchema,
+        OpenResponsesWebSearch20250826Tool$inboundSchema,
+    ])),
+    tool_choice: OpenAIResponsesToolChoiceUnion$inboundSchema,
+    parallel_tool_calls: z.boolean(),
+    prompt: z.nullable(OpenAIResponsesPrompt$inboundSchema).optional(),
+    background: z.nullable(z.boolean()).optional(),
+    previous_response_id: z.nullable(z.string()).optional(),
+    reasoning: z.nullable(OpenAIResponsesReasoningConfig$inboundSchema)
+        .optional(),
+    service_tier: z.nullable(OpenAIResponsesServiceTier$inboundSchema).optional(),
+    store: z.boolean().optional(),
+    truncation: z.nullable(OpenAIResponsesTruncation$inboundSchema).optional(),
+    text: ResponseTextConfig$inboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "created_at": "createdAt",
+        "output_text": "outputText",
+        "prompt_cache_key": "promptCacheKey",
+        "safety_identifier": "safetyIdentifier",
+        "incomplete_details": "incompleteDetails",
+        "max_tool_calls": "maxToolCalls",
+        "top_logprobs": "topLogprobs",
+        "max_output_tokens": "maxOutputTokens",
+        "top_p": "topP",
+        "tool_choice": "toolChoice",
+        "parallel_tool_calls": "parallelToolCalls",
+        "previous_response_id": "previousResponseId",
+        "service_tier": "serviceTier",
+    });
+});
+/** @internal */
+export const OpenResponsesNonStreamingResponse$outboundSchema = z.object({
+    id: z.string(),
+    object: ObjectT$outboundSchema,
+    createdAt: z.number(),
+    model: z.string(),
+    status: OpenAIResponsesResponseStatus$outboundSchema.optional(),
+    output: z.array(ResponsesOutputItem$outboundSchema),
+    user: z.nullable(z.string()).optional(),
+    outputText: z.string().optional(),
+    promptCacheKey: z.nullable(z.string()).optional(),
+    safetyIdentifier: z.nullable(z.string()).optional(),
+    error: z.nullable(ResponsesErrorField$outboundSchema),
+    incompleteDetails: z.nullable(OpenAIResponsesIncompleteDetails$outboundSchema),
+    usage: OpenResponsesUsage$outboundSchema.optional(),
+    maxToolCalls: z.nullable(z.number()).optional(),
+    topLogprobs: z.number().optional(),
+    maxOutputTokens: z.nullable(z.number()).optional(),
+    temperature: z.nullable(z.number()),
+    topP: z.nullable(z.number()),
+    instructions: z.nullable(OpenAIResponsesInputUnion$outboundSchema).optional(),
+    metadata: z.nullable(z.record(z.string(), z.string())),
+    tools: z.array(z.union([
+        z.lazy(() => OpenResponsesNonStreamingResponseToolFunction$outboundSchema),
+        OpenResponsesWebSearchPreviewTool$outboundSchema,
+        OpenResponsesWebSearchPreview20250311Tool$outboundSchema,
+        OpenResponsesWebSearchTool$outboundSchema,
+        OpenResponsesWebSearch20250826Tool$outboundSchema,
+    ])),
+    toolChoice: OpenAIResponsesToolChoiceUnion$outboundSchema,
+    parallelToolCalls: z.boolean(),
+    prompt: z.nullable(OpenAIResponsesPrompt$outboundSchema).optional(),
+    background: z.nullable(z.boolean()).optional(),
+    previousResponseId: z.nullable(z.string()).optional(),
+    reasoning: z.nullable(OpenAIResponsesReasoningConfig$outboundSchema)
+        .optional(),
+    serviceTier: z.nullable(OpenAIResponsesServiceTier$outboundSchema).optional(),
+    store: z.boolean().optional(),
+    truncation: z.nullable(OpenAIResponsesTruncation$outboundSchema).optional(),
+    text: ResponseTextConfig$outboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        createdAt: "created_at",
+        outputText: "output_text",
+        promptCacheKey: "prompt_cache_key",
+        safetyIdentifier: "safety_identifier",
+        incompleteDetails: "incomplete_details",
+        maxToolCalls: "max_tool_calls",
+        topLogprobs: "top_logprobs",
+        maxOutputTokens: "max_output_tokens",
+        topP: "top_p",
+        toolChoice: "tool_choice",
+        parallelToolCalls: "parallel_tool_calls",
+        previousResponseId: "previous_response_id",
+        serviceTier: "service_tier",
+    });
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesNonStreamingResponse$;
+(function (OpenResponsesNonStreamingResponse$) {
+    /** @deprecated use `OpenResponsesNonStreamingResponse$inboundSchema` instead. */
+    OpenResponsesNonStreamingResponse$.inboundSchema = OpenResponsesNonStreamingResponse$inboundSchema;
+    /** @deprecated use `OpenResponsesNonStreamingResponse$outboundSchema` instead. */
+    OpenResponsesNonStreamingResponse$.outboundSchema = OpenResponsesNonStreamingResponse$outboundSchema;
+})(OpenResponsesNonStreamingResponse$ || (OpenResponsesNonStreamingResponse$ = {}));
+export function openResponsesNonStreamingResponseToJSON(openResponsesNonStreamingResponse) {
+    return JSON.stringify(OpenResponsesNonStreamingResponse$outboundSchema.parse(openResponsesNonStreamingResponse));
+}
+export function openResponsesNonStreamingResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesNonStreamingResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesNonStreamingResponse' from JSON`);
+}
+//# sourceMappingURL=openresponsesnonstreamingresponse.js.map

package/esm/models/openresponsesreasoningdeltaevent.d.ts

@@ -0,0 +1,65 @@
+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 OpenResponsesReasoningDeltaEventType: {
+    readonly ResponseReasoningTextDelta: "response.reasoning_text.delta";
+};
+export type OpenResponsesReasoningDeltaEventType = ClosedEnum<typeof OpenResponsesReasoningDeltaEventType>;
+/**
+ * Event emitted when reasoning text delta is streamed
+ */
+export type OpenResponsesReasoningDeltaEvent = {
+    type: OpenResponsesReasoningDeltaEventType;
+    outputIndex: number;
+    itemId: string;
+    contentIndex: number;
+    delta: string;
+    sequenceNumber: number;
+};
+/** @internal */
+export declare const OpenResponsesReasoningDeltaEventType$inboundSchema: z.ZodEnum<typeof OpenResponsesReasoningDeltaEventType>;
+/** @internal */
+export declare const OpenResponsesReasoningDeltaEventType$outboundSchema: z.ZodEnum<typeof OpenResponsesReasoningDeltaEventType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace OpenResponsesReasoningDeltaEventType$ {
+    /** @deprecated use `OpenResponsesReasoningDeltaEventType$inboundSchema` instead. */
+    const inboundSchema: z.ZodEnum<{
+        readonly ResponseReasoningTextDelta: "response.reasoning_text.delta";
+    }>;
+    /** @deprecated use `OpenResponsesReasoningDeltaEventType$outboundSchema` instead. */
+    const outboundSchema: z.ZodEnum<{
+        readonly ResponseReasoningTextDelta: "response.reasoning_text.delta";
+    }>;
+}
+/** @internal */
+export declare const OpenResponsesReasoningDeltaEvent$inboundSchema: z.ZodType<OpenResponsesReasoningDeltaEvent, unknown>;
+/** @internal */
+export type OpenResponsesReasoningDeltaEvent$Outbound = {
+    type: string;
+    output_index: number;
+    item_id: string;
+    content_index: number;
+    delta: string;
+    sequence_number: number;
+};
+/** @internal */
+export declare const OpenResponsesReasoningDeltaEvent$outboundSchema: z.ZodType<OpenResponsesReasoningDeltaEvent$Outbound, OpenResponsesReasoningDeltaEvent>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace OpenResponsesReasoningDeltaEvent$ {
+    /** @deprecated use `OpenResponsesReasoningDeltaEvent$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<OpenResponsesReasoningDeltaEvent, unknown, z.core.$ZodTypeInternals<OpenResponsesReasoningDeltaEvent, unknown>>;
+    /** @deprecated use `OpenResponsesReasoningDeltaEvent$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<OpenResponsesReasoningDeltaEvent$Outbound, OpenResponsesReasoningDeltaEvent, z.core.$ZodTypeInternals<OpenResponsesReasoningDeltaEvent$Outbound, OpenResponsesReasoningDeltaEvent>>;
+    /** @deprecated use `OpenResponsesReasoningDeltaEvent$Outbound` instead. */
+    type Outbound = OpenResponsesReasoningDeltaEvent$Outbound;
+}
+export declare function openResponsesReasoningDeltaEventToJSON(openResponsesReasoningDeltaEvent: OpenResponsesReasoningDeltaEvent): string;
+export declare function openResponsesReasoningDeltaEventFromJSON(jsonString: string): SafeParseResult<OpenResponsesReasoningDeltaEvent, SDKValidationError>;
+//# sourceMappingURL=openresponsesreasoningdeltaevent.d.ts.map

package/esm/models/openresponsesreasoningdeltaevent.js

@@ -0,0 +1,74 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+export const OpenResponsesReasoningDeltaEventType = {
+    ResponseReasoningTextDelta: "response.reasoning_text.delta",
+};
+/** @internal */
+export const OpenResponsesReasoningDeltaEventType$inboundSchema = z.enum(OpenResponsesReasoningDeltaEventType);
+/** @internal */
+export const OpenResponsesReasoningDeltaEventType$outboundSchema = OpenResponsesReasoningDeltaEventType$inboundSchema;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesReasoningDeltaEventType$;
+(function (OpenResponsesReasoningDeltaEventType$) {
+    /** @deprecated use `OpenResponsesReasoningDeltaEventType$inboundSchema` instead. */
+    OpenResponsesReasoningDeltaEventType$.inboundSchema = OpenResponsesReasoningDeltaEventType$inboundSchema;
+    /** @deprecated use `OpenResponsesReasoningDeltaEventType$outboundSchema` instead. */
+    OpenResponsesReasoningDeltaEventType$.outboundSchema = OpenResponsesReasoningDeltaEventType$outboundSchema;
+})(OpenResponsesReasoningDeltaEventType$ || (OpenResponsesReasoningDeltaEventType$ = {}));
+/** @internal */
+export const OpenResponsesReasoningDeltaEvent$inboundSchema = z.object({
+    type: OpenResponsesReasoningDeltaEventType$inboundSchema,
+    output_index: z.number(),
+    item_id: z.string(),
+    content_index: z.number(),
+    delta: z.string(),
+    sequence_number: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        "output_index": "outputIndex",
+        "item_id": "itemId",
+        "content_index": "contentIndex",
+        "sequence_number": "sequenceNumber",
+    });
+});
+/** @internal */
+export const OpenResponsesReasoningDeltaEvent$outboundSchema = z.object({
+    type: OpenResponsesReasoningDeltaEventType$outboundSchema,
+    outputIndex: z.number(),
+    itemId: z.string(),
+    contentIndex: z.number(),
+    delta: z.string(),
+    sequenceNumber: z.number(),
+}).transform((v) => {
+    return remap$(v, {
+        outputIndex: "output_index",
+        itemId: "item_id",
+        contentIndex: "content_index",
+        sequenceNumber: "sequence_number",
+    });
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var OpenResponsesReasoningDeltaEvent$;
+(function (OpenResponsesReasoningDeltaEvent$) {
+    /** @deprecated use `OpenResponsesReasoningDeltaEvent$inboundSchema` instead. */
+    OpenResponsesReasoningDeltaEvent$.inboundSchema = OpenResponsesReasoningDeltaEvent$inboundSchema;
+    /** @deprecated use `OpenResponsesReasoningDeltaEvent$outboundSchema` instead. */
+    OpenResponsesReasoningDeltaEvent$.outboundSchema = OpenResponsesReasoningDeltaEvent$outboundSchema;
+})(OpenResponsesReasoningDeltaEvent$ || (OpenResponsesReasoningDeltaEvent$ = {}));
+export function openResponsesReasoningDeltaEventToJSON(openResponsesReasoningDeltaEvent) {
+    return JSON.stringify(OpenResponsesReasoningDeltaEvent$outboundSchema.parse(openResponsesReasoningDeltaEvent));
+}
+export function openResponsesReasoningDeltaEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesReasoningDeltaEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesReasoningDeltaEvent' from JSON`);
+}
+//# sourceMappingURL=openresponsesreasoningdeltaevent.js.map