@orq-ai/node 4.8.0-rc.3 → 4.8.0-rc.30

package/models/operations/createrouterresponse.d.ts

@@ -0,0 +1,823 @@
+import * as z from "zod/v3";
+import { EventStream } from "../../lib/event-streams.js";
+import { ClosedEnum } from "../../types/enums.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as components from "../components/index.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+/**
+ * A file content part. Provide file_id, file_data (base64), or file_url.
+ */
+export type TwoFile = {
+    /**
+     * Base64-encoded file content.
+     */
+    fileData?: string | undefined;
+    /**
+     * The ID of a previously uploaded file.
+     */
+    fileId?: string | undefined;
+    /**
+     * A URL to fetch the file from.
+     */
+    fileUrl?: string | undefined;
+    /**
+     * The name of the file.
+     */
+    filename?: string | undefined;
+    /**
+     * The MIME type of the file (e.g., application/pdf).
+     */
+    mimeType?: string | undefined;
+    type: "input_file";
+};
+/**
+ * The detail level for image understanding.
+ */
+export declare const TwoDetail: {
+    readonly Auto: "auto";
+    readonly Low: "low";
+    readonly High: "high";
+};
+/**
+ * The detail level for image understanding.
+ */
+export type TwoDetail = ClosedEnum<typeof TwoDetail>;
+/**
+ * An image content part.
+ */
+export type Image = {
+    /**
+     * The detail level for image understanding.
+     */
+    detail?: TwoDetail | undefined;
+    /**
+     * The ID of a previously uploaded file.
+     */
+    fileId?: string | undefined;
+    /**
+     * The URL of the image.
+     */
+    imageUrl?: string | undefined;
+    type: "input_image";
+};
+/**
+ * A text content part.
+ */
+export type TwoText = {
+    /**
+     * The text content.
+     */
+    text: string;
+    type: "input_text";
+};
+/**
+ * A content part within a message.
+ */
+export type CreateRouterResponseContent2 = TwoText | Image | TwoFile;
+/**
+ * The content of the item: a string or an array of content parts.
+ */
+export type InputContent = string | Array<TwoText | Image | TwoFile>;
+/**
+ * The role of the message sender (for message items).
+ */
+export declare const InputRole: {
+    readonly User: "user";
+    readonly Assistant: "assistant";
+    readonly System: "system";
+    readonly Developer: "developer";
+};
+/**
+ * The role of the message sender (for message items).
+ */
+export type InputRole = ClosedEnum<typeof InputRole>;
+/**
+ * The type of item.
+ */
+export declare const InputType: {
+    readonly Message: "message";
+    readonly FunctionCallOutput: "function_call_output";
+    readonly ItemReference: "item_reference";
+};
+/**
+ * The type of item.
+ */
+export type InputType = ClosedEnum<typeof InputType>;
+/**
+ * An input item. The "type" field determines the item kind: "message", "function_call_output", "item_reference", etc.
+ */
+export type CreateRouterResponseInput2 = {
+    /**
+     * The ID of the function call being responded to (for function_call_output type).
+     */
+    callId?: string | undefined;
+    /**
+     * The content of the item: a string or an array of content parts.
+     */
+    content?: string | Array<TwoText | Image | TwoFile> | undefined;
+    /**
+     * The ID of the item (for item_reference type).
+     */
+    id?: string | undefined;
+    /**
+     * The output of the function call (for function_call_output type).
+     */
+    output?: string | undefined;
+    /**
+     * The role of the message sender (for message items).
+     */
+    role?: InputRole | undefined;
+    /**
+     * The type of item.
+     */
+    type?: InputType | undefined;
+};
+/**
+ * Input to the model: a string or an array of input items (messages, files, etc.).
+ */
+export type CreateRouterResponseInput = string | Array<CreateRouterResponseInput2>;
+/**
+ * The JSON Schema the output must conform to.
+ */
+export type FormatSchema = {};
+export type FormatJSONSchema = {
+    description?: string | undefined;
+    name?: string | undefined;
+    /**
+     * The JSON Schema the output must conform to.
+     */
+    schema?: FormatSchema | undefined;
+    strict?: boolean | undefined;
+    type: "json_schema";
+};
+export type PlainText = {
+    type: "text";
+};
+/**
+ * The output format: plain text or structured JSON schema.
+ */
+export type CreateRouterResponseFormat = PlainText | FormatJSONSchema;
+export declare const Verbosity: {
+    readonly Low: "low";
+    readonly Medium: "medium";
+    readonly High: "high";
+};
+export type Verbosity = ClosedEnum<typeof Verbosity>;
+/**
+ * Configuration for text output.
+ */
+export type CreateRouterResponseText = {
+    /**
+     * The output format: plain text or structured JSON schema.
+     */
+    format?: PlainText | FormatJSONSchema | undefined;
+    verbosity?: Verbosity | undefined;
+};
+export declare const CreateRouterResponseToolChoiceType: {
+    readonly Function: "function";
+};
+export type CreateRouterResponseToolChoiceType = ClosedEnum<typeof CreateRouterResponseToolChoiceType>;
+/**
+ * Select a specific function tool by name.
+ */
+export type SpecificFunction = {
+    /**
+     * The name of the function to call.
+     */
+    name: string;
+    type: CreateRouterResponseToolChoiceType;
+};
+/**
+ * Shorthand: "auto" lets the model decide, "none" disables tools, "required" forces tool use.
+ */
+export declare const Shorthand: {
+    readonly Auto: "auto";
+    readonly None: "none";
+    readonly Required: "required";
+};
+/**
+ * Shorthand: "auto" lets the model decide, "none" disables tools, "required" forces tool use.
+ */
+export type Shorthand = ClosedEnum<typeof Shorthand>;
+/**
+ * How the model should use the provided tools. Can be a string shorthand or a specific function selector.
+ */
+export type CreateRouterResponseToolChoice = SpecificFunction | Shorthand;
+/**
+ * Filter which tools from the MCP server are exposed.
+ */
+export type AllowedTools = {
+    /**
+     * Only expose tools with readOnlyHint annotation.
+     */
+    readOnly?: boolean | undefined;
+    /**
+     * List of allowed tool names.
+     */
+    toolNames?: Array<string> | undefined;
+};
+/**
+ * An MCP (Model Context Protocol) server tool. Provide server_url for inline mode, or key to reference a pre-configured MCP server.
+ */
+export type ToolsMCPTool = {
+    /**
+     * Filter which tools from the MCP server are exposed.
+     */
+    allowedTools?: AllowedTools | undefined;
+    /**
+     * Custom headers to send with MCP requests. Values support {{variable}} templates.
+     */
+    headers?: {
+        [k: string]: string;
+    } | undefined;
+    /**
+     * Unique identifier. Required for pre-configured MCP servers (lookup key). For inline servers, used as a trace/display label.
+     */
+    key?: string | undefined;
+    /**
+     * Human-readable description of the server.
+     */
+    serverDescription?: string | undefined;
+    /**
+     * The MCP server endpoint URL (inline mode).
+     */
+    serverUrl?: string | undefined;
+    type: "mcp";
+};
+/**
+ * The orq.ai tool type.
+ */
+export declare const CreateRouterResponseToolsResponsesType: {
+    readonly OrqCurrentDate: "orq:current_date";
+    readonly OrqGoogleSearch: "orq:google_search";
+    readonly OrqWebScraper: "orq:web_scraper";
+    readonly OrqMcp: "orq:mcp";
+    readonly OrqHttp: "orq:http";
+    readonly OrqFunction: "orq:function";
+};
+/**
+ * The orq.ai tool type.
+ */
+export type CreateRouterResponseToolsResponsesType = ClosedEnum<typeof CreateRouterResponseToolsResponsesType>;
+/**
+ * An orq.ai platform tool reference. For MCP tools, prefer type 'mcp' with 'key' instead of 'orq:mcp' with 'tool_id'.
+ */
+export type OrqAiTool = {
+    /**
+     * The tool ID (for orq:mcp, orq:http, orq:function).
+     */
+    toolId?: string | undefined;
+    /**
+     * The orq.ai tool type.
+     */
+    type: CreateRouterResponseToolsResponsesType;
+};
+/**
+ * The parameters the function accepts, as a JSON Schema object.
+ */
+export type ToolsParameters = {};
+/**
+ * A function tool the model can call.
+ */
+export type ToolsFunction = {
+    /**
+     * A description of what the function does.
+     */
+    description?: string | undefined;
+    /**
+     * The name of the function.
+     */
+    name: string;
+    /**
+     * The parameters the function accepts, as a JSON Schema object.
+     */
+    parameters?: ToolsParameters | undefined;
+    /**
+     * Whether to enforce strict parameter validation.
+     */
+    strict?: boolean | undefined;
+    type: "function";
+};
+/**
+ * A tool definition. The "type" field determines the tool kind.
+ */
+export type CreateRouterResponseTools = ToolsFunction | (OrqAiTool & {
+    type: "orq:current_date";
+}) | (OrqAiTool & {
+    type: "orq:google_search";
+}) | (OrqAiTool & {
+    type: "orq:web_scraper";
+}) | (OrqAiTool & {
+    type: "orq:mcp";
+}) | (OrqAiTool & {
+    type: "orq:http";
+}) | (OrqAiTool & {
+    type: "orq:function";
+}) | ToolsMCPTool;
+export type CreateRouterResponseRequestBody = {
+    conversation?: components.ConversationParam | undefined;
+    /**
+     * Fallback models to try if the primary model fails. Each entry specifies a model in provider/model format.
+     */
+    fallbacks?: Array<components.FallbackConfig> | null | undefined;
+    /**
+     * Penalize new tokens based on their frequency in the text so far. Between -2.0 and 2.0.
+     */
+    frequencyPenalty?: number | undefined;
+    identity?: components.ResponseIdentity | undefined;
+    /**
+     * Input to the model: a string or an array of input items (messages, files, etc.).
+     */
+    input?: string | Array<CreateRouterResponseInput2> | undefined;
+    /**
+     * System prompt / instructions for the model.
+     */
+    instructions?: string | undefined;
+    /**
+     * Maximum number of tokens in the response output.
+     */
+    maxOutputTokens?: number | undefined;
+    /**
+     * Maximum number of tool call rounds in the agentic loop.
+     */
+    maxToolCalls?: number | undefined;
+    memory?: components.MemoryParam | undefined;
+    /**
+     * Developer-defined key-value pairs attached to the response.
+     */
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+    /**
+     * The model to use in provider/model format (e.g. openai/gpt-4o). Use agent/<key> to invoke a pre-configured agent from the orq.ai platform.
+     */
+    model?: string | undefined;
+    /**
+     * Whether to allow parallel tool calls.
+     */
+    parallelToolCalls?: boolean | undefined;
+    /**
+     * Penalize new tokens based on their presence in the text so far. Between -2.0 and 2.0.
+     */
+    presencePenalty?: number | undefined;
+    /**
+     * The ID of a previous response to continue from. Requires store to be true (default) on the original response.
+     */
+    previousResponseId?: string | undefined;
+    /**
+     * Key for prompt caching across requests.
+     */
+    promptCacheKey?: string | undefined;
+    reasoning?: components.ReasoningParam | undefined;
+    retry?: components.ResponseRetryConfig | undefined;
+    /**
+     * Safety identifier for content filtering.
+     */
+    safetyIdentifier?: string | undefined;
+    /**
+     * Whether to persist the response (default: true). When false, the response cannot be retrieved later and previous_response_id will not work for follow-up requests.
+     */
+    store?: boolean | undefined;
+    /**
+     * If true, returns a stream of server-sent events.
+     */
+    stream?: boolean | undefined;
+    streamOptions?: components.StreamOptions | undefined;
+    /**
+     * Sampling temperature between 0 and 2.
+     */
+    temperature?: number | undefined;
+    /**
+     * Configuration for text output.
+     */
+    text?: CreateRouterResponseText | undefined;
+    thread?: components.ResponseThread | undefined;
+    /**
+     * How the model should use the provided tools. Can be a string shorthand or a specific function selector.
+     */
+    toolChoice?: SpecificFunction | Shorthand | undefined;
+    /**
+     * Tools available to the model.
+     */
+    tools?: Array<ToolsFunction | (OrqAiTool & {
+        type: "orq:current_date";
+    }) | (OrqAiTool & {
+        type: "orq:google_search";
+    }) | (OrqAiTool & {
+        type: "orq:web_scraper";
+    }) | (OrqAiTool & {
+        type: "orq:mcp";
+    }) | (OrqAiTool & {
+        type: "orq:http";
+    }) | (OrqAiTool & {
+        type: "orq:function";
+    }) | ToolsMCPTool> | undefined;
+    /**
+     * Number of most likely tokens to return at each position.
+     */
+    topLogprobs?: number | undefined;
+    /**
+     * Nucleus sampling parameter.
+     */
+    topP?: number | undefined;
+    /**
+     * Template variables for prompt substitution. Plain values fill {{variable}} placeholders in instructions. For secrets, use {"secret": true, "value": "sensitive-data"} — secrets are automatically passed to platform tools (Python, HTTP, MCP) and redacted from traces.
+     */
+    variables?: {
+        [k: string]: any;
+    } | undefined;
+};
+/**
+ * The event type.
+ */
+export declare const CreateRouterResponseType: {
+    readonly ResponseQueued: "response.queued";
+    readonly ResponseCreated: "response.created";
+    readonly ResponseInProgress: "response.in_progress";
+    readonly ResponseCompleted: "response.completed";
+    readonly ResponseFailed: "response.failed";
+    readonly ResponseIncomplete: "response.incomplete";
+    readonly ResponseOutputItemAdded: "response.output_item.added";
+    readonly ResponseOutputItemDone: "response.output_item.done";
+    readonly ResponseContentPartAdded: "response.content_part.added";
+    readonly ResponseContentPartDone: "response.content_part.done";
+    readonly ResponseOutputTextDelta: "response.output_text.delta";
+    readonly ResponseOutputTextDone: "response.output_text.done";
+    readonly ResponseFunctionCallArgumentsDelta: "response.function_call_arguments.delta";
+    readonly ResponseFunctionCallArgumentsDone: "response.function_call_arguments.done";
+    readonly ResponseMcpCallInProgress: "response.mcp_call.in_progress";
+    readonly ResponseMcpCallCompleted: "response.mcp_call.completed";
+    readonly ResponseMcpCallFailed: "response.mcp_call.failed";
+    readonly ResponseMcpCallArgumentsDelta: "response.mcp_call_arguments.delta";
+    readonly ResponseMcpCallArgumentsDone: "response.mcp_call_arguments.done";
+    readonly ResponseReasoningDelta: "response.reasoning.delta";
+    readonly ResponseReasoningDone: "response.reasoning.done";
+    readonly Error: "error";
+};
+/**
+ * The event type.
+ */
+export type CreateRouterResponseType = ClosedEnum<typeof CreateRouterResponseType>;
+/**
+ * A server-sent event in the response stream.
+ */
+export type CreateRouterResponseData = {
+    /**
+     * Monotonically increasing sequence number for ordering events.
+     */
+    sequenceNumber: number;
+    /**
+     * The event type.
+     */
+    type: CreateRouterResponseType;
+};
+/**
+ * A server-sent event in the response stream.
+ */
+export type CreateRouterResponseResponsesResponseBody = {
+    /**
+     * A server-sent event in the response stream.
+     */
+    data?: CreateRouterResponseData | undefined;
+};
+export declare const CreateRouterResponseServiceTier: {
+    readonly Auto: "auto";
+    readonly Default: "default";
+    readonly Flex: "flex";
+    readonly Priority: "priority";
+};
+export type CreateRouterResponseServiceTier = ClosedEnum<typeof CreateRouterResponseServiceTier>;
+export declare const CreateRouterResponseStatus: {
+    readonly Queued: "queued";
+    readonly InProgress: "in_progress";
+    readonly Completed: "completed";
+    readonly Failed: "failed";
+    readonly Incomplete: "incomplete";
+    readonly RequiresAction: "requires_action";
+};
+export type CreateRouterResponseStatus = ClosedEnum<typeof CreateRouterResponseStatus>;
+export declare const CreateRouterResponseTruncation: {
+    readonly Disabled: "disabled";
+    readonly Auto: "auto";
+};
+export type CreateRouterResponseTruncation = ClosedEnum<typeof CreateRouterResponseTruncation>;
+/**
+ * Returns a response object or a stream of events.
+ */
+export type CreateRouterResponseResponseBody = {
+    background: boolean;
+    completedAt: number | null;
+    conversation?: components.ConversationParam | undefined;
+    createdAt: number;
+    error: components.ResponseError;
+    frequencyPenalty: number;
+    id: string;
+    incompleteDetails: components.IncompleteDetails;
+    /**
+     * Array of input items (messages, function call outputs, etc.)
+     */
+    input: Array<any> | null;
+    instructions: string | null;
+    maxOutputTokens: number | null;
+    maxToolCalls: number | null;
+    memory?: components.MemoryParam | undefined;
+    metadata: {
+        [k: string]: any;
+    };
+    model: string;
+    /**
+     * Always "response"
+     */
+    object: string;
+    /**
+     * Array of output items (messages, function calls, reasoning, etc.)
+     */
+    output: Array<any> | null;
+    parallelToolCalls: boolean;
+    presencePenalty: number;
+    previousResponseId: string | null;
+    promptCacheKey: string | null;
+    promptCacheRetention: string | null;
+    reasoning: components.Reasoning;
+    safetyIdentifier: string | null;
+    serviceTier: CreateRouterResponseServiceTier;
+    status: CreateRouterResponseStatus;
+    store: boolean;
+    temperature: number;
+    /**
+     * Text output configuration including format and verbosity
+     */
+    text?: any | undefined;
+    /**
+     * Tool choice setting: "auto", "none", "required", or a specific function
+     */
+    toolChoice?: any | undefined;
+    /**
+     * Array of tool configurations used in this response
+     */
+    tools: Array<any> | null;
+    topLogprobs: number;
+    topP: number;
+    truncation: CreateRouterResponseTruncation;
+    usage: components.PublicUsage;
+    user: string | null;
+    variables?: {
+        [k: string]: any;
+    } | undefined;
+};
+export type CreateRouterResponseResponse = CreateRouterResponseResponseBody | EventStream<CreateRouterResponseResponsesResponseBody>;
+/** @internal */
+export type TwoFile$Outbound = {
+    file_data?: string | undefined;
+    file_id?: string | undefined;
+    file_url?: string | undefined;
+    filename?: string | undefined;
+    mime_type?: string | undefined;
+    type: "input_file";
+};
+/** @internal */
+export declare const TwoFile$outboundSchema: z.ZodType<TwoFile$Outbound, z.ZodTypeDef, TwoFile>;
+export declare function twoFileToJSON(twoFile: TwoFile): string;
+/** @internal */
+export declare const TwoDetail$outboundSchema: z.ZodNativeEnum<typeof TwoDetail>;
+/** @internal */
+export type Image$Outbound = {
+    detail?: string | undefined;
+    file_id?: string | undefined;
+    image_url?: string | undefined;
+    type: "input_image";
+};
+/** @internal */
+export declare const Image$outboundSchema: z.ZodType<Image$Outbound, z.ZodTypeDef, Image>;
+export declare function imageToJSON(image: Image): string;
+/** @internal */
+export type TwoText$Outbound = {
+    text: string;
+    type: "input_text";
+};
+/** @internal */
+export declare const TwoText$outboundSchema: z.ZodType<TwoText$Outbound, z.ZodTypeDef, TwoText>;
+export declare function twoTextToJSON(twoText: TwoText): string;
+/** @internal */
+export type CreateRouterResponseContent2$Outbound = TwoText$Outbound | Image$Outbound | TwoFile$Outbound;
+/** @internal */
+export declare const CreateRouterResponseContent2$outboundSchema: z.ZodType<CreateRouterResponseContent2$Outbound, z.ZodTypeDef, CreateRouterResponseContent2>;
+export declare function createRouterResponseContent2ToJSON(createRouterResponseContent2: CreateRouterResponseContent2): string;
+/** @internal */
+export type InputContent$Outbound = string | Array<TwoText$Outbound | Image$Outbound | TwoFile$Outbound>;
+/** @internal */
+export declare const InputContent$outboundSchema: z.ZodType<InputContent$Outbound, z.ZodTypeDef, InputContent>;
+export declare function inputContentToJSON(inputContent: InputContent): string;
+/** @internal */
+export declare const InputRole$outboundSchema: z.ZodNativeEnum<typeof InputRole>;
+/** @internal */
+export declare const InputType$outboundSchema: z.ZodNativeEnum<typeof InputType>;
+/** @internal */
+export type CreateRouterResponseInput2$Outbound = {
+    call_id?: string | undefined;
+    content?: string | Array<TwoText$Outbound | Image$Outbound | TwoFile$Outbound> | undefined;
+    id?: string | undefined;
+    output?: string | undefined;
+    role?: string | undefined;
+    type?: string | undefined;
+};
+/** @internal */
+export declare const CreateRouterResponseInput2$outboundSchema: z.ZodType<CreateRouterResponseInput2$Outbound, z.ZodTypeDef, CreateRouterResponseInput2>;
+export declare function createRouterResponseInput2ToJSON(createRouterResponseInput2: CreateRouterResponseInput2): string;
+/** @internal */
+export type CreateRouterResponseInput$Outbound = string | Array<CreateRouterResponseInput2$Outbound>;
+/** @internal */
+export declare const CreateRouterResponseInput$outboundSchema: z.ZodType<CreateRouterResponseInput$Outbound, z.ZodTypeDef, CreateRouterResponseInput>;
+export declare function createRouterResponseInputToJSON(createRouterResponseInput: CreateRouterResponseInput): string;
+/** @internal */
+export type FormatSchema$Outbound = {};
+/** @internal */
+export declare const FormatSchema$outboundSchema: z.ZodType<FormatSchema$Outbound, z.ZodTypeDef, FormatSchema>;
+export declare function formatSchemaToJSON(formatSchema: FormatSchema): string;
+/** @internal */
+export type FormatJSONSchema$Outbound = {
+    description?: string | undefined;
+    name?: string | undefined;
+    schema?: FormatSchema$Outbound | undefined;
+    strict?: boolean | undefined;
+    type: "json_schema";
+};
+/** @internal */
+export declare const FormatJSONSchema$outboundSchema: z.ZodType<FormatJSONSchema$Outbound, z.ZodTypeDef, FormatJSONSchema>;
+export declare function formatJSONSchemaToJSON(formatJSONSchema: FormatJSONSchema): string;
+/** @internal */
+export type PlainText$Outbound = {
+    type: "text";
+};
+/** @internal */
+export declare const PlainText$outboundSchema: z.ZodType<PlainText$Outbound, z.ZodTypeDef, PlainText>;
+export declare function plainTextToJSON(plainText: PlainText): string;
+/** @internal */
+export type CreateRouterResponseFormat$Outbound = PlainText$Outbound | FormatJSONSchema$Outbound;
+/** @internal */
+export declare const CreateRouterResponseFormat$outboundSchema: z.ZodType<CreateRouterResponseFormat$Outbound, z.ZodTypeDef, CreateRouterResponseFormat>;
+export declare function createRouterResponseFormatToJSON(createRouterResponseFormat: CreateRouterResponseFormat): string;
+/** @internal */
+export declare const Verbosity$outboundSchema: z.ZodNativeEnum<typeof Verbosity>;
+/** @internal */
+export type CreateRouterResponseText$Outbound = {
+    format?: PlainText$Outbound | FormatJSONSchema$Outbound | undefined;
+    verbosity?: string | undefined;
+};
+/** @internal */
+export declare const CreateRouterResponseText$outboundSchema: z.ZodType<CreateRouterResponseText$Outbound, z.ZodTypeDef, CreateRouterResponseText>;
+export declare function createRouterResponseTextToJSON(createRouterResponseText: CreateRouterResponseText): string;
+/** @internal */
+export declare const CreateRouterResponseToolChoiceType$outboundSchema: z.ZodNativeEnum<typeof CreateRouterResponseToolChoiceType>;
+/** @internal */
+export type SpecificFunction$Outbound = {
+    name: string;
+    type: string;
+};
+/** @internal */
+export declare const SpecificFunction$outboundSchema: z.ZodType<SpecificFunction$Outbound, z.ZodTypeDef, SpecificFunction>;
+export declare function specificFunctionToJSON(specificFunction: SpecificFunction): string;
+/** @internal */
+export declare const Shorthand$outboundSchema: z.ZodNativeEnum<typeof Shorthand>;
+/** @internal */
+export type CreateRouterResponseToolChoice$Outbound = SpecificFunction$Outbound | string;
+/** @internal */
+export declare const CreateRouterResponseToolChoice$outboundSchema: z.ZodType<CreateRouterResponseToolChoice$Outbound, z.ZodTypeDef, CreateRouterResponseToolChoice>;
+export declare function createRouterResponseToolChoiceToJSON(createRouterResponseToolChoice: CreateRouterResponseToolChoice): string;
+/** @internal */
+export type AllowedTools$Outbound = {
+    read_only?: boolean | undefined;
+    tool_names?: Array<string> | undefined;
+};
+/** @internal */
+export declare const AllowedTools$outboundSchema: z.ZodType<AllowedTools$Outbound, z.ZodTypeDef, AllowedTools>;
+export declare function allowedToolsToJSON(allowedTools: AllowedTools): string;
+/** @internal */
+export type ToolsMCPTool$Outbound = {
+    allowed_tools?: AllowedTools$Outbound | undefined;
+    headers?: {
+        [k: string]: string;
+    } | undefined;
+    key?: string | undefined;
+    server_description?: string | undefined;
+    server_url?: string | undefined;
+    type: "mcp";
+};
+/** @internal */
+export declare const ToolsMCPTool$outboundSchema: z.ZodType<ToolsMCPTool$Outbound, z.ZodTypeDef, ToolsMCPTool>;
+export declare function toolsMCPToolToJSON(toolsMCPTool: ToolsMCPTool): string;
+/** @internal */
+export declare const CreateRouterResponseToolsResponsesType$outboundSchema: z.ZodNativeEnum<typeof CreateRouterResponseToolsResponsesType>;
+/** @internal */
+export type OrqAiTool$Outbound = {
+    tool_id?: string | undefined;
+    type: string;
+};
+/** @internal */
+export declare const OrqAiTool$outboundSchema: z.ZodType<OrqAiTool$Outbound, z.ZodTypeDef, OrqAiTool>;
+export declare function orqAiToolToJSON(orqAiTool: OrqAiTool): string;
+/** @internal */
+export type ToolsParameters$Outbound = {};
+/** @internal */
+export declare const ToolsParameters$outboundSchema: z.ZodType<ToolsParameters$Outbound, z.ZodTypeDef, ToolsParameters>;
+export declare function toolsParametersToJSON(toolsParameters: ToolsParameters): string;
+/** @internal */
+export type ToolsFunction$Outbound = {
+    description?: string | undefined;
+    name: string;
+    parameters?: ToolsParameters$Outbound | undefined;
+    strict?: boolean | undefined;
+    type: "function";
+};
+/** @internal */
+export declare const ToolsFunction$outboundSchema: z.ZodType<ToolsFunction$Outbound, z.ZodTypeDef, ToolsFunction>;
+export declare function toolsFunctionToJSON(toolsFunction: ToolsFunction): string;
+/** @internal */
+export type CreateRouterResponseTools$Outbound = ToolsFunction$Outbound | (OrqAiTool$Outbound & {
+    type: "orq:current_date";
+}) | (OrqAiTool$Outbound & {
+    type: "orq:google_search";
+}) | (OrqAiTool$Outbound & {
+    type: "orq:web_scraper";
+}) | (OrqAiTool$Outbound & {
+    type: "orq:mcp";
+}) | (OrqAiTool$Outbound & {
+    type: "orq:http";
+}) | (OrqAiTool$Outbound & {
+    type: "orq:function";
+}) | ToolsMCPTool$Outbound;
+/** @internal */
+export declare const CreateRouterResponseTools$outboundSchema: z.ZodType<CreateRouterResponseTools$Outbound, z.ZodTypeDef, CreateRouterResponseTools>;
+export declare function createRouterResponseToolsToJSON(createRouterResponseTools: CreateRouterResponseTools): string;
+/** @internal */
+export type CreateRouterResponseRequestBody$Outbound = {
+    conversation?: components.ConversationParam$Outbound | undefined;
+    fallbacks?: Array<components.FallbackConfig$Outbound> | null | undefined;
+    frequency_penalty?: number | undefined;
+    identity?: components.ResponseIdentity$Outbound | undefined;
+    input?: string | Array<CreateRouterResponseInput2$Outbound> | undefined;
+    instructions?: string | undefined;
+    max_output_tokens?: number | undefined;
+    max_tool_calls?: number | undefined;
+    memory?: components.MemoryParam$Outbound | undefined;
+    metadata?: {
+        [k: string]: any;
+    } | undefined;
+    model?: string | undefined;
+    parallel_tool_calls?: boolean | undefined;
+    presence_penalty?: number | undefined;
+    previous_response_id?: string | undefined;
+    prompt_cache_key?: string | undefined;
+    reasoning?: components.ReasoningParam$Outbound | undefined;
+    retry?: components.ResponseRetryConfig$Outbound | undefined;
+    safety_identifier?: string | undefined;
+    store?: boolean | undefined;
+    stream?: boolean | undefined;
+    stream_options?: components.StreamOptions$Outbound | undefined;
+    temperature?: number | undefined;
+    text?: CreateRouterResponseText$Outbound | undefined;
+    thread?: components.ResponseThread$Outbound | undefined;
+    tool_choice?: SpecificFunction$Outbound | string | undefined;
+    tools?: Array<ToolsFunction$Outbound | (OrqAiTool$Outbound & {
+        type: "orq:current_date";
+    }) | (OrqAiTool$Outbound & {
+        type: "orq:google_search";
+    }) | (OrqAiTool$Outbound & {
+        type: "orq:web_scraper";
+    }) | (OrqAiTool$Outbound & {
+        type: "orq:mcp";
+    }) | (OrqAiTool$Outbound & {
+        type: "orq:http";
+    }) | (OrqAiTool$Outbound & {
+        type: "orq:function";
+    }) | ToolsMCPTool$Outbound> | undefined;
+    top_logprobs?: number | undefined;
+    top_p?: number | undefined;
+    variables?: {
+        [k: string]: any;
+    } | undefined;
+};
+/** @internal */
+export declare const CreateRouterResponseRequestBody$outboundSchema: z.ZodType<CreateRouterResponseRequestBody$Outbound, z.ZodTypeDef, CreateRouterResponseRequestBody>;
+export declare function createRouterResponseRequestBodyToJSON(createRouterResponseRequestBody: CreateRouterResponseRequestBody): string;
+/** @internal */
+export declare const CreateRouterResponseType$inboundSchema: z.ZodNativeEnum<typeof CreateRouterResponseType>;
+/** @internal */
+export declare const CreateRouterResponseData$inboundSchema: z.ZodType<CreateRouterResponseData, z.ZodTypeDef, unknown>;
+export declare function createRouterResponseDataFromJSON(jsonString: string): SafeParseResult<CreateRouterResponseData, SDKValidationError>;
+/** @internal */
+export declare const CreateRouterResponseResponsesResponseBody$inboundSchema: z.ZodType<CreateRouterResponseResponsesResponseBody, z.ZodTypeDef, unknown>;
+export declare function createRouterResponseResponsesResponseBodyFromJSON(jsonString: string): SafeParseResult<CreateRouterResponseResponsesResponseBody, SDKValidationError>;
+/** @internal */
+export declare const CreateRouterResponseServiceTier$inboundSchema: z.ZodNativeEnum<typeof CreateRouterResponseServiceTier>;
+/** @internal */
+export declare const CreateRouterResponseStatus$inboundSchema: z.ZodNativeEnum<typeof CreateRouterResponseStatus>;
+/** @internal */
+export declare const CreateRouterResponseTruncation$inboundSchema: z.ZodNativeEnum<typeof CreateRouterResponseTruncation>;
+/** @internal */
+export declare const CreateRouterResponseResponseBody$inboundSchema: z.ZodType<CreateRouterResponseResponseBody, z.ZodTypeDef, unknown>;
+export declare function createRouterResponseResponseBodyFromJSON(jsonString: string): SafeParseResult<CreateRouterResponseResponseBody, SDKValidationError>;
+/** @internal */
+export declare const CreateRouterResponseResponse$inboundSchema: z.ZodType<CreateRouterResponseResponse, z.ZodTypeDef, unknown>;
+export declare function createRouterResponseResponseFromJSON(jsonString: string): SafeParseResult<CreateRouterResponseResponse, SDKValidationError>;
+//# sourceMappingURL=createrouterresponse.d.ts.map