@openrouter/sdk 0.10.2 → 0.11.2

package/esm/lib/stream-type-guards.d.ts

@@ -3,21 +3,21 @@ import type * as models from '../models/index.js';
  * Type guards for OpenResponses stream events
  * These enable proper TypeScript narrowing without type casts
  */
-export declare function isOutputTextDeltaEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesStreamEventResponseOutputTextDelta;
-export declare function isReasoningDeltaEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesReasoningDeltaEvent;
-export declare function isFunctionCallArgumentsDeltaEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesStreamEventResponseFunctionCallArgumentsDelta;
-export declare function isOutputItemAddedEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesStreamEventResponseOutputItemAdded;
-export declare function isOutputItemDoneEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesStreamEventResponseOutputItemDone;
-export declare function isResponseCompletedEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesStreamEventResponseCompleted;
-export declare function isResponseFailedEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesStreamEventResponseFailed;
-export declare function isResponseIncompleteEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesStreamEventResponseIncomplete;
-export declare function isFunctionCallArgumentsDoneEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesStreamEventResponseFunctionCallArgumentsDone;
-export declare function isOutputMessage(item: unknown): item is models.ResponsesOutputMessage;
-export declare function isFunctionCallItem(item: unknown): item is models.ResponsesOutputItemFunctionCall;
-export declare function isReasoningOutputItem(item: unknown): item is models.ResponsesOutputItemReasoning;
-export declare function isWebSearchCallOutputItem(item: unknown): item is models.ResponsesWebSearchCallOutput;
-export declare function isFileSearchCallOutputItem(item: unknown): item is models.ResponsesOutputItemFileSearchCall;
-export declare function isImageGenerationCallOutputItem(item: unknown): item is models.ResponsesImageGenerationCall;
+export declare function isOutputTextDeltaEvent(event: models.StreamEvents): event is models.TextDeltaEvent;
+export declare function isReasoningDeltaEvent(event: models.StreamEvents): event is models.ReasoningDeltaEvent;
+export declare function isFunctionCallArgumentsDeltaEvent(event: models.StreamEvents): event is models.FunctionCallArgsDeltaEvent;
+export declare function isOutputItemAddedEvent(event: models.StreamEvents): event is models.StreamEventsResponseOutputItemAdded;
+export declare function isOutputItemDoneEvent(event: models.StreamEvents): event is models.StreamEventsResponseOutputItemDone;
+export declare function isResponseCompletedEvent(event: models.StreamEvents): event is models.StreamEventsResponseCompleted;
+export declare function isResponseFailedEvent(event: models.StreamEvents): event is models.StreamEventsResponseFailed;
+export declare function isResponseIncompleteEvent(event: models.StreamEvents): event is models.StreamEventsResponseIncomplete;
+export declare function isFunctionCallArgumentsDoneEvent(event: models.StreamEvents): event is models.FunctionCallArgsDoneEvent;
+export declare function isOutputMessage(item: unknown): item is models.OutputMessage;
+export declare function isFunctionCallItem(item: unknown): item is models.OutputFunctionCallItem;
+export declare function isReasoningOutputItem(item: unknown): item is models.OutputReasoningItem;
+export declare function isWebSearchCallOutputItem(item: unknown): item is models.OutputWebSearchCallItem;
+export declare function isFileSearchCallOutputItem(item: unknown): item is models.OutputFileSearchCallItem;
+export declare function isImageGenerationCallOutputItem(item: unknown): item is models.OutputImageGenerationCallItem;
 export declare function isOutputTextPart(part: unknown): part is models.ResponseOutputText;
 export declare function isRefusalPart(part: unknown): part is models.OpenAIResponsesRefusalContent;
 export declare function isFileCitationAnnotation(annotation: unknown): annotation is models.FileCitation;

package/esm/lib/tool-orchestrator.d.ts

@@ -10,10 +10,10 @@ export interface ToolExecutionOptions {
  * Result of the tool execution loop
  */
 export interface ToolOrchestrationResult {
-    finalResponse: models.OpenResponsesNonStreamingResponse;
-    allResponses: models.OpenResponsesNonStreamingResponse[];
+    finalResponse: models.OpenResponsesResult;
+    allResponses: models.OpenResponsesResult[];
     toolExecutionResults: ToolExecutionResult<Tool>[];
-    conversationInput: models.OpenResponsesInputUnion;
+    conversationInput: models.InputsUnion;
 }
 /**
  * Execute tool calls and manage multi-turn conversations
@@ -27,7 +27,7 @@ export interface ToolOrchestrationResult {
  * @param options - Execution options
  * @returns Result containing final response and all execution data
  */
-export declare function executeToolLoop(sendRequest: (input: models.OpenResponsesInputUnion, tools: APITool[]) => Promise<models.OpenResponsesNonStreamingResponse>, initialInput: models.OpenResponsesInputUnion, initialRequest: models.OpenResponsesRequest, tools: Tool[], apiTools: APITool[], options?: ToolExecutionOptions): Promise<ToolOrchestrationResult>;
+export declare function executeToolLoop(sendRequest: (input: models.InputsUnion, tools: APITool[]) => Promise<models.OpenResponsesResult>, initialInput: models.InputsUnion, initialRequest: models.ResponsesRequest, tools: Tool[], apiTools: APITool[], options?: ToolExecutionOptions): Promise<ToolOrchestrationResult>;
 /**
  * Convert tool execution results to a map for easy lookup
  */

package/esm/lib/tool-orchestrator.js

@@ -65,7 +65,7 @@ export async function executeToolLoop(sendRequest, initialInput, initialRequest,
             if (!rawToolCall) {
                 throw new Error(`Could not find raw tool call for ${toolCall.id}`);
             }
-            // Convert to OpenResponsesFunctionToolCall format
+            // Convert to FunctionCallItem format
             const openResponsesToolCall = {
                 type: 'function_call',
                 callId: rawToolCall.callId,

package/esm/lib/tool-types.d.ts

@@ -1,6 +1,6 @@
 import type { $ZodObject, $ZodShape, $ZodType, infer as zodInfer } from 'zod/v4/core';
 import type * as models from '../models/index.js';
-import type { OpenResponsesStreamEvent } from '../models/index.js';
+import type { StreamEvents } from '../models/index.js';
 import type { ModelResult } from './model-result.js';
 /**
  * Tool type enum for enhanced tools
@@ -14,11 +14,11 @@ export declare enum ToolType {
  */
 export interface TurnContext {
     /** The specific tool call being executed (only available during tool execution) */
-    toolCall?: models.OpenResponsesFunctionToolCall;
+    toolCall?: models.FunctionCallItem;
     /** Number of tool execution turns so far (1-indexed: first turn = 1, 0 = initial request) */
     numberOfTurns: number;
     /** The full request being sent to the API (only available during tool execution) */
-    turnRequest?: models.OpenResponsesRequest;
+    turnRequest?: models.ResponsesRequest;
 }
 /**
  * Extract context schema type from a tool definition
@@ -83,7 +83,7 @@ export declare const SHARED_CONTEXT_KEY: "shared";
  */
 export type NextTurnParamsContext = {
     /** Current input (messages) */
-    input: models.OpenResponsesInputUnion;
+    input: models.InputsUnion;
     /** Current model selection */
     model: string;
     /** Current models array */
@@ -315,8 +315,8 @@ export interface StepResult<TTools extends readonly Tool[] = readonly Tool[]> {
     readonly text: string;
     readonly toolCalls: TypedToolCallUnion<TTools>[];
     readonly toolResults: ToolExecutionResultUnion<TTools>[];
-    readonly response: models.OpenResponsesNonStreamingResponse;
-    readonly usage?: models.OpenResponsesUsage | null | undefined;
+    readonly response: models.OpenResponsesResult;
+    readonly usage?: models.Usage | null | undefined;
     readonly finishReason?: string | undefined;
     readonly warnings?: Warning[] | undefined;
     readonly experimental_providerMetadata?: Record<string, unknown> | undefined;
@@ -347,7 +347,7 @@ export interface ExecuteToolsResult<TTools extends readonly Tool[]> {
 }
 /**
  * Standard tool format for OpenRouter API (JSON Schema based)
- * Matches OpenResponsesRequestToolFunction structure
+ * Matches ResponsesRequestToolFunction structure
  */
 export interface APITool {
     type: 'function';
@@ -381,6 +381,16 @@ export type ToolResultEvent<TResult = unknown, TPreliminaryResults = unknown> =
     timestamp: number;
     preliminaryResults?: TPreliminaryResults[];
 };
+/**
+ * Tool call output event carrying the fully-formed FunctionCallOutputItem.
+ * Broadcast by executeToolRound so passive consumers (getItemsStream) can yield
+ * tool results in real-time without owning tool execution.
+ */
+export type ToolCallOutputEvent = {
+    type: 'tool.call_output';
+    output: models.FunctionCallOutputItem;
+    timestamp: number;
+};
 /**
  * Turn start event emitted at the beginning of each API turn
  * Turn 0 is the initial request, subsequent turns follow tool execution
@@ -400,12 +410,12 @@ export type TurnEndEvent = {
 };
 /**
  * Enhanced stream event types for getFullResponsesStream
- * Extends OpenResponsesStreamEvent with tool preliminary results, tool results,
+ * Extends StreamEvents with tool preliminary results, tool results,
  * and turn delimiter events for multi-turn streaming
  * @template TEvent - The event type from generator tools
  * @template TResult - The result type from tool execution
  */
-export type ResponseStreamEvent<TEvent = unknown, TResult = unknown> = OpenResponsesStreamEvent | ToolPreliminaryResultEvent<TEvent> | ToolResultEvent<TResult, TEvent> | TurnStartEvent | TurnEndEvent;
+export type ResponseStreamEvent<TEvent = unknown, TResult = unknown> = StreamEvents | ToolPreliminaryResultEvent<TEvent> | ToolResultEvent<TResult, TEvent> | ToolCallOutputEvent | TurnStartEvent | TurnEndEvent;
 /**
  * Type guard to check if an event is a tool preliminary result event
  */
@@ -414,6 +424,10 @@ export declare function isToolPreliminaryResultEvent<TEvent = unknown>(event: Re
  * Type guard to check if an event is a tool result event
  */
 export declare function isToolResultEvent<TResult = unknown, TPreliminaryResults = unknown>(event: ResponseStreamEvent<TPreliminaryResults, TResult>): event is ToolResultEvent<TResult, TPreliminaryResults>;
+/**
+ * Type guard to check if an event is a tool call output event
+ */
+export declare function isToolCallOutputEvent(event: ResponseStreamEvent): event is ToolCallOutputEvent;
 /**
  * Type guard to check if an event is a turn start event
  */
@@ -445,14 +459,14 @@ export type ChatStreamEvent<TEvent = unknown> = {
     delta: string;
 } | {
     type: 'message.complete';
-    response: models.OpenResponsesNonStreamingResponse;
+    response: models.OpenResponsesResult;
 } | {
     type: 'tool.preliminary_result';
     toolCallId: string;
     result: TEvent;
 } | {
     type: string;
-    event: OpenResponsesStreamEvent;
+    event: StreamEvents;
 };
 /**
  * Result of a tool execution that hasn't been sent to the model yet
@@ -491,7 +505,7 @@ export interface ConversationState<TTools extends readonly Tool[] = readonly Too
     /** Unique identifier for this conversation */
     id: string;
     /** Full message history */
-    messages: models.OpenResponsesInputUnion;
+    messages: models.InputsUnion;
     /** Previous response ID for chaining (OpenRouter server-side optimization) */
     previousResponseId?: string;
     /** Tool calls awaiting human approval */

package/esm/lib/tool-types.js

@@ -46,6 +46,12 @@ export function isToolPreliminaryResultEvent(event) {
 export function isToolResultEvent(event) {
     return event.type === 'tool.result';
 }
+/**
+ * Type guard to check if an event is a tool call output event
+ */
+export function isToolCallOutputEvent(event) {
+    return event.type === 'tool.call_output';
+}
 /**
  * Type guard to check if an event is a turn start event
  */

package/esm/lib/turn-context.d.ts

@@ -7,9 +7,9 @@ export interface BuildTurnContextOptions {
     /** Number of turns so far (1-indexed for tool execution, 0 for initial request) */
     numberOfTurns: number;
     /** The specific tool call being executed (optional for initial/async resolution contexts) */
-    toolCall?: models.OpenResponsesFunctionToolCall;
+    toolCall?: models.FunctionCallItem;
     /** The full request being sent to the API (optional for initial/async resolution contexts) */
-    turnRequest?: models.OpenResponsesRequest;
+    turnRequest?: models.ResponsesRequest;
 }
 /**
  * Build a turn context for tool execution or async parameter resolution
@@ -46,5 +46,5 @@ export declare function buildTurnContext(options: BuildTurnContextOptions): Turn
  * // Returns: [{ role: "user", content: "Hello!" }]
  * ```
  */
-export declare function normalizeInputToArray(input: models.OpenResponsesInputUnion): Array<models.OpenResponsesInputUnion1>;
+export declare function normalizeInputToArray(input: models.InputsUnion): Array<models.BaseInputsUnion>;
 //# sourceMappingURL=turn-context.d.ts.map

package/esm/lib/turn-context.js

@@ -49,7 +49,7 @@ export function normalizeInputToArray(input) {
     if (typeof input === 'string') {
         // Construct object with all required fields - type is optional
         const message = {
-            role: models.OpenResponsesEasyInputMessageRoleUser.User,
+            role: models.EasyInputMessageRoleUser.User,
             content: input,
         };
         return [message];

package/esm/lib/url.js

@@ -6,7 +6,8 @@ const hasOwn = Object.prototype.hasOwnProperty;
 export function pathToFunc(pathPattern, options) {
     const paramRE = /\{([a-zA-Z0-9_][a-zA-Z0-9_-]*?)\}/g;
     return function buildURLPath(params = {}) {
-        return pathPattern.replace(paramRE, function (_, placeholder) {
+        return pathPattern
+            .replace(paramRE, function (_, placeholder) {
             if (!hasOwn.call(params, placeholder)) {
                 throw new Error(`Parameter '${placeholder}' is required`);
             }
@@ -17,7 +18,8 @@ export function pathToFunc(pathPattern, options) {
             return options?.charEncoding === "percent"
                 ? encodeURIComponent(`${value}`)
                 : `${value}`;
-        });
+        })
+            .replace(/^\/+/, "");
     };
 }
 //# sourceMappingURL=url.js.map

package/esm/models/annotationaddedevent.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";
+import { OpenAIResponsesAnnotation } from "./openairesponsesannotation.js";
+/**
+ * Event emitted when a text annotation is added to output
+ */
+export type AnnotationAddedEvent = {
+    type: "response.output_text.annotation.added";
+    outputIndex: number;
+    itemId: string;
+    contentIndex: number;
+    sequenceNumber: number;
+    annotationIndex: number;
+    annotation: OpenAIResponsesAnnotation;
+};
+/** @internal */
+export declare const AnnotationAddedEvent$inboundSchema: z.ZodType<AnnotationAddedEvent, unknown>;
+export declare function annotationAddedEventFromJSON(jsonString: string): SafeParseResult<AnnotationAddedEvent, SDKValidationError>;
+//# sourceMappingURL=annotationaddedevent.d.ts.map

package/esm/models/annotationaddedevent.js

@@ -0,0 +1,30 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: e5c5f2adf5f6
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { OpenAIResponsesAnnotation$inboundSchema, } from "./openairesponsesannotation.js";
+/** @internal */
+export const AnnotationAddedEvent$inboundSchema = z.object({
+    type: z.literal("response.output_text.annotation.added"),
+    output_index: z.number(),
+    item_id: z.string(),
+    content_index: z.number(),
+    sequence_number: z.number(),
+    annotation_index: z.number(),
+    annotation: OpenAIResponsesAnnotation$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "output_index": "outputIndex",
+        "item_id": "itemId",
+        "content_index": "contentIndex",
+        "sequence_number": "sequenceNumber",
+        "annotation_index": "annotationIndex",
+    });
+});
+export function annotationAddedEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnnotationAddedEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnnotationAddedEvent' from JSON`);
+}
+//# sourceMappingURL=annotationaddedevent.js.map

package/esm/models/applypatchservertool.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";
+/**
+ * Apply patch tool configuration
+ */
+export type ApplyPatchServerTool = {
+    type: "apply_patch";
+};
+/** @internal */
+export declare const ApplyPatchServerTool$inboundSchema: z.ZodType<ApplyPatchServerTool, unknown>;
+/** @internal */
+export type ApplyPatchServerTool$Outbound = {
+    type: "apply_patch";
+};
+/** @internal */
+export declare const ApplyPatchServerTool$outboundSchema: z.ZodType<ApplyPatchServerTool$Outbound, ApplyPatchServerTool>;
+export declare function applyPatchServerToolToJSON(applyPatchServerTool: ApplyPatchServerTool): string;
+export declare function applyPatchServerToolFromJSON(jsonString: string): SafeParseResult<ApplyPatchServerTool, SDKValidationError>;
+//# sourceMappingURL=applypatchservertool.d.ts.map

package/esm/models/applypatchservertool.js

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

package/esm/models/baseinputsunion.d.ts

@@ -0,0 +1,185 @@
+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 { InputAudio } from "./inputaudio.js";
+import { InputFile } from "./inputfile.js";
+import { InputImage } from "./inputimage.js";
+import { InputText } from "./inputtext.js";
+import { OutputItemImageGenerationCall } from "./outputitemimagegenerationcall.js";
+import { OutputMessage } from "./outputmessage.js";
+import { ToolCallStatusEnum } from "./toolcallstatusenum.js";
+export declare const BaseInputsTypeFunctionCall: {
+    readonly FunctionCall: "function_call";
+};
+export type BaseInputsTypeFunctionCall = ClosedEnum<typeof BaseInputsTypeFunctionCall>;
+export type BaseInputsFunctionCall = {
+    type: BaseInputsTypeFunctionCall;
+    callId: string;
+    name: string;
+    arguments: string;
+    id?: string | undefined;
+    status?: ToolCallStatusEnum | null | undefined;
+};
+export declare const BaseInputsTypeFunctionCallOutput: {
+    readonly FunctionCallOutput: "function_call_output";
+};
+export type BaseInputsTypeFunctionCallOutput = ClosedEnum<typeof BaseInputsTypeFunctionCallOutput>;
+export type BaseInputsOutput1 = InputText | (InputImage & {
+    type: "input_image";
+}) | InputFile;
+export type BaseInputsOutput2 = string | Array<InputText | (InputImage & {
+    type: "input_image";
+}) | InputFile>;
+export type BaseInputsFunctionCallOutput = {
+    type: BaseInputsTypeFunctionCallOutput;
+    id?: string | null | undefined;
+    callId: string;
+    output: string | Array<InputText | (InputImage & {
+        type: "input_image";
+    }) | InputFile>;
+    status?: ToolCallStatusEnum | null | undefined;
+};
+export declare const BaseInputsTypeMessage2: {
+    readonly Message: "message";
+};
+export type BaseInputsTypeMessage2 = ClosedEnum<typeof BaseInputsTypeMessage2>;
+export declare const BaseInputsRoleDeveloper2: {
+    readonly Developer: "developer";
+};
+export type BaseInputsRoleDeveloper2 = ClosedEnum<typeof BaseInputsRoleDeveloper2>;
+export declare const BaseInputsRoleSystem2: {
+    readonly System: "system";
+};
+export type BaseInputsRoleSystem2 = ClosedEnum<typeof BaseInputsRoleSystem2>;
+export declare const BaseInputsRoleUser2: {
+    readonly User: "user";
+};
+export type BaseInputsRoleUser2 = ClosedEnum<typeof BaseInputsRoleUser2>;
+export type BaseInputsRoleUnion2 = BaseInputsRoleUser2 | BaseInputsRoleSystem2 | BaseInputsRoleDeveloper2;
+export type BaseInputsContent3 = InputText | (InputImage & {
+    type: "input_image";
+}) | InputFile | InputAudio;
+export type BaseInputsMessage2 = {
+    id: string;
+    type?: BaseInputsTypeMessage2 | undefined;
+    role: BaseInputsRoleUser2 | BaseInputsRoleSystem2 | BaseInputsRoleDeveloper2;
+    content: Array<InputText | (InputImage & {
+        type: "input_image";
+    }) | InputFile | InputAudio>;
+};
+export declare const BaseInputsTypeMessage1: {
+    readonly Message: "message";
+};
+export type BaseInputsTypeMessage1 = ClosedEnum<typeof BaseInputsTypeMessage1>;
+export declare const BaseInputsRoleDeveloper1: {
+    readonly Developer: "developer";
+};
+export type BaseInputsRoleDeveloper1 = ClosedEnum<typeof BaseInputsRoleDeveloper1>;
+export declare const BaseInputsRoleAssistant: {
+    readonly Assistant: "assistant";
+};
+export type BaseInputsRoleAssistant = ClosedEnum<typeof BaseInputsRoleAssistant>;
+export declare const BaseInputsRoleSystem1: {
+    readonly System: "system";
+};
+export type BaseInputsRoleSystem1 = ClosedEnum<typeof BaseInputsRoleSystem1>;
+export declare const BaseInputsRoleUser1: {
+    readonly User: "user";
+};
+export type BaseInputsRoleUser1 = ClosedEnum<typeof BaseInputsRoleUser1>;
+export type BaseInputsRoleUnion1 = BaseInputsRoleUser1 | BaseInputsRoleSystem1 | BaseInputsRoleAssistant | BaseInputsRoleDeveloper1;
+export type BaseInputsContent1 = InputText | (InputImage & {
+    type: "input_image";
+}) | InputFile | InputAudio;
+export type BaseInputsContent2 = Array<InputText | (InputImage & {
+    type: "input_image";
+}) | InputFile | InputAudio> | string;
+export declare const BaseInputsPhaseFinalAnswer: {
+    readonly FinalAnswer: "final_answer";
+};
+export type BaseInputsPhaseFinalAnswer = ClosedEnum<typeof BaseInputsPhaseFinalAnswer>;
+export declare const BaseInputsPhaseCommentary: {
+    readonly Commentary: "commentary";
+};
+export type BaseInputsPhaseCommentary = ClosedEnum<typeof BaseInputsPhaseCommentary>;
+export type BaseInputsPhaseUnion = BaseInputsPhaseCommentary | BaseInputsPhaseFinalAnswer | any;
+export type BaseInputsMessage1 = {
+    type?: BaseInputsTypeMessage1 | undefined;
+    role: BaseInputsRoleUser1 | BaseInputsRoleSystem1 | BaseInputsRoleAssistant | BaseInputsRoleDeveloper1;
+    content: Array<InputText | (InputImage & {
+        type: "input_image";
+    }) | InputFile | InputAudio> | string;
+    phase?: BaseInputsPhaseCommentary | BaseInputsPhaseFinalAnswer | any | null | undefined;
+};
+export type BaseInputsUnion1 = BaseInputsFunctionCall | OutputMessage | BaseInputsMessage2 | BaseInputsFunctionCallOutput | OutputItemImageGenerationCall | BaseInputsMessage1;
+export type BaseInputsUnion = string | Array<BaseInputsFunctionCall | OutputMessage | BaseInputsMessage2 | BaseInputsFunctionCallOutput | OutputItemImageGenerationCall | BaseInputsMessage1> | any;
+/** @internal */
+export declare const BaseInputsTypeFunctionCall$inboundSchema: z.ZodEnum<typeof BaseInputsTypeFunctionCall>;
+/** @internal */
+export declare const BaseInputsFunctionCall$inboundSchema: z.ZodType<BaseInputsFunctionCall, unknown>;
+export declare function baseInputsFunctionCallFromJSON(jsonString: string): SafeParseResult<BaseInputsFunctionCall, SDKValidationError>;
+/** @internal */
+export declare const BaseInputsTypeFunctionCallOutput$inboundSchema: z.ZodEnum<typeof BaseInputsTypeFunctionCallOutput>;
+/** @internal */
+export declare const BaseInputsOutput1$inboundSchema: z.ZodType<BaseInputsOutput1, unknown>;
+export declare function baseInputsOutput1FromJSON(jsonString: string): SafeParseResult<BaseInputsOutput1, SDKValidationError>;
+/** @internal */
+export declare const BaseInputsOutput2$inboundSchema: z.ZodType<BaseInputsOutput2, unknown>;
+export declare function baseInputsOutput2FromJSON(jsonString: string): SafeParseResult<BaseInputsOutput2, SDKValidationError>;
+/** @internal */
+export declare const BaseInputsFunctionCallOutput$inboundSchema: z.ZodType<BaseInputsFunctionCallOutput, unknown>;
+export declare function baseInputsFunctionCallOutputFromJSON(jsonString: string): SafeParseResult<BaseInputsFunctionCallOutput, SDKValidationError>;
+/** @internal */
+export declare const BaseInputsTypeMessage2$inboundSchema: z.ZodEnum<typeof BaseInputsTypeMessage2>;
+/** @internal */
+export declare const BaseInputsRoleDeveloper2$inboundSchema: z.ZodEnum<typeof BaseInputsRoleDeveloper2>;
+/** @internal */
+export declare const BaseInputsRoleSystem2$inboundSchema: z.ZodEnum<typeof BaseInputsRoleSystem2>;
+/** @internal */
+export declare const BaseInputsRoleUser2$inboundSchema: z.ZodEnum<typeof BaseInputsRoleUser2>;
+/** @internal */
+export declare const BaseInputsRoleUnion2$inboundSchema: z.ZodType<BaseInputsRoleUnion2, unknown>;
+export declare function baseInputsRoleUnion2FromJSON(jsonString: string): SafeParseResult<BaseInputsRoleUnion2, SDKValidationError>;
+/** @internal */
+export declare const BaseInputsContent3$inboundSchema: z.ZodType<BaseInputsContent3, unknown>;
+export declare function baseInputsContent3FromJSON(jsonString: string): SafeParseResult<BaseInputsContent3, SDKValidationError>;
+/** @internal */
+export declare const BaseInputsMessage2$inboundSchema: z.ZodType<BaseInputsMessage2, unknown>;
+export declare function baseInputsMessage2FromJSON(jsonString: string): SafeParseResult<BaseInputsMessage2, SDKValidationError>;
+/** @internal */
+export declare const BaseInputsTypeMessage1$inboundSchema: z.ZodEnum<typeof BaseInputsTypeMessage1>;
+/** @internal */
+export declare const BaseInputsRoleDeveloper1$inboundSchema: z.ZodEnum<typeof BaseInputsRoleDeveloper1>;
+/** @internal */
+export declare const BaseInputsRoleAssistant$inboundSchema: z.ZodEnum<typeof BaseInputsRoleAssistant>;
+/** @internal */
+export declare const BaseInputsRoleSystem1$inboundSchema: z.ZodEnum<typeof BaseInputsRoleSystem1>;
+/** @internal */
+export declare const BaseInputsRoleUser1$inboundSchema: z.ZodEnum<typeof BaseInputsRoleUser1>;
+/** @internal */
+export declare const BaseInputsRoleUnion1$inboundSchema: z.ZodType<BaseInputsRoleUnion1, unknown>;
+export declare function baseInputsRoleUnion1FromJSON(jsonString: string): SafeParseResult<BaseInputsRoleUnion1, SDKValidationError>;
+/** @internal */
+export declare const BaseInputsContent1$inboundSchema: z.ZodType<BaseInputsContent1, unknown>;
+export declare function baseInputsContent1FromJSON(jsonString: string): SafeParseResult<BaseInputsContent1, SDKValidationError>;
+/** @internal */
+export declare const BaseInputsContent2$inboundSchema: z.ZodType<BaseInputsContent2, unknown>;
+export declare function baseInputsContent2FromJSON(jsonString: string): SafeParseResult<BaseInputsContent2, SDKValidationError>;
+/** @internal */
+export declare const BaseInputsPhaseFinalAnswer$inboundSchema: z.ZodEnum<typeof BaseInputsPhaseFinalAnswer>;
+/** @internal */
+export declare const BaseInputsPhaseCommentary$inboundSchema: z.ZodEnum<typeof BaseInputsPhaseCommentary>;
+/** @internal */
+export declare const BaseInputsPhaseUnion$inboundSchema: z.ZodType<BaseInputsPhaseUnion, unknown>;
+export declare function baseInputsPhaseUnionFromJSON(jsonString: string): SafeParseResult<BaseInputsPhaseUnion, SDKValidationError>;
+/** @internal */
+export declare const BaseInputsMessage1$inboundSchema: z.ZodType<BaseInputsMessage1, unknown>;
+export declare function baseInputsMessage1FromJSON(jsonString: string): SafeParseResult<BaseInputsMessage1, SDKValidationError>;
+/** @internal */
+export declare const BaseInputsUnion1$inboundSchema: z.ZodType<BaseInputsUnion1, unknown>;
+export declare function baseInputsUnion1FromJSON(jsonString: string): SafeParseResult<BaseInputsUnion1, SDKValidationError>;
+/** @internal */
+export declare const BaseInputsUnion$inboundSchema: z.ZodType<BaseInputsUnion, unknown>;
+export declare function baseInputsUnionFromJSON(jsonString: string): SafeParseResult<BaseInputsUnion, SDKValidationError>;
+//# sourceMappingURL=baseinputsunion.d.ts.map