@orq-ai/node 4.8.0-rc.2 → 4.8.0-rc.28

package/src/models/operations/createrouterresponse.ts

@@ -0,0 +1,1496 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { EventStream } from "../../lib/event-streams.js";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.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 const TwoDetail = {
+  Auto: "auto",
+  Low: "low",
+  High: "high",
+} as const;
+/**
+ * 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 const InputRole = {
+  User: "user",
+  Assistant: "assistant",
+  System: "system",
+  Developer: "developer",
+} as const;
+/**
+ * The role of the message sender (for message items).
+ */
+export type InputRole = ClosedEnum<typeof InputRole>;
+
+/**
+ * The type of item.
+ */
+export const InputType = {
+  Message: "message",
+  FunctionCallOutput: "function_call_output",
+  ItemReference: "item_reference",
+} as const;
+/**
+ * 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 const Verbosity = {
+  Low: "low",
+  Medium: "medium",
+  High: "high",
+} as const;
+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 const CreateRouterResponseToolChoiceType = {
+  Function: "function",
+} as const;
+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 const Shorthand = {
+  Auto: "auto",
+  None: "none",
+  Required: "required",
+} as const;
+/**
+ * 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 const CreateRouterResponseToolsResponsesType = {
+  OrqCurrentDate: "orq:current_date",
+  OrqGoogleSearch: "orq:google_search",
+  OrqWebScraper: "orq:web_scraper",
+  OrqMcp: "orq:mcp",
+  OrqHttp: "orq:http",
+  OrqFunction: "orq:function",
+} as const;
+/**
+ * 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 const CreateRouterResponseType = {
+  ResponseQueued: "response.queued",
+  ResponseCreated: "response.created",
+  ResponseInProgress: "response.in_progress",
+  ResponseCompleted: "response.completed",
+  ResponseFailed: "response.failed",
+  ResponseIncomplete: "response.incomplete",
+  ResponseOutputItemAdded: "response.output_item.added",
+  ResponseOutputItemDone: "response.output_item.done",
+  ResponseContentPartAdded: "response.content_part.added",
+  ResponseContentPartDone: "response.content_part.done",
+  ResponseOutputTextDelta: "response.output_text.delta",
+  ResponseOutputTextDone: "response.output_text.done",
+  ResponseFunctionCallArgumentsDelta: "response.function_call_arguments.delta",
+  ResponseFunctionCallArgumentsDone: "response.function_call_arguments.done",
+  ResponseMcpCallInProgress: "response.mcp_call.in_progress",
+  ResponseMcpCallCompleted: "response.mcp_call.completed",
+  ResponseMcpCallFailed: "response.mcp_call.failed",
+  ResponseMcpCallArgumentsDelta: "response.mcp_call_arguments.delta",
+  ResponseMcpCallArgumentsDone: "response.mcp_call_arguments.done",
+  ResponseReasoningDelta: "response.reasoning.delta",
+  ResponseReasoningDone: "response.reasoning.done",
+  Error: "error",
+} as const;
+/**
+ * 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 const CreateRouterResponseServiceTier = {
+  Auto: "auto",
+  Default: "default",
+  Flex: "flex",
+  Priority: "priority",
+} as const;
+export type CreateRouterResponseServiceTier = ClosedEnum<
+  typeof CreateRouterResponseServiceTier
+>;
+
+export const CreateRouterResponseStatus = {
+  Queued: "queued",
+  InProgress: "in_progress",
+  Completed: "completed",
+  Failed: "failed",
+  Incomplete: "incomplete",
+  RequiresAction: "requires_action",
+} as const;
+export type CreateRouterResponseStatus = ClosedEnum<
+  typeof CreateRouterResponseStatus
+>;
+
+export const CreateRouterResponseTruncation = {
+  Disabled: "disabled",
+  Auto: "auto",
+} as const;
+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 const TwoFile$outboundSchema: z.ZodType<
+  TwoFile$Outbound,
+  z.ZodTypeDef,
+  TwoFile
+> = z.object({
+  fileData: z.string().optional(),
+  fileId: z.string().optional(),
+  fileUrl: z.string().optional(),
+  filename: z.string().optional(),
+  mimeType: z.string().optional(),
+  type: z.literal("input_file"),
+}).transform((v) => {
+  return remap$(v, {
+    fileData: "file_data",
+    fileId: "file_id",
+    fileUrl: "file_url",
+    mimeType: "mime_type",
+  });
+});
+
+export function twoFileToJSON(twoFile: TwoFile): string {
+  return JSON.stringify(TwoFile$outboundSchema.parse(twoFile));
+}
+
+/** @internal */
+export const TwoDetail$outboundSchema: z.ZodNativeEnum<typeof TwoDetail> = z
+  .nativeEnum(TwoDetail);
+
+/** @internal */
+export type Image$Outbound = {
+  detail?: string | undefined;
+  file_id?: string | undefined;
+  image_url?: string | undefined;
+  type: "input_image";
+};
+
+/** @internal */
+export const Image$outboundSchema: z.ZodType<
+  Image$Outbound,
+  z.ZodTypeDef,
+  Image
+> = z.object({
+  detail: TwoDetail$outboundSchema.optional(),
+  fileId: z.string().optional(),
+  imageUrl: z.string().optional(),
+  type: z.literal("input_image"),
+}).transform((v) => {
+  return remap$(v, {
+    fileId: "file_id",
+    imageUrl: "image_url",
+  });
+});
+
+export function imageToJSON(image: Image): string {
+  return JSON.stringify(Image$outboundSchema.parse(image));
+}
+
+/** @internal */
+export type TwoText$Outbound = {
+  text: string;
+  type: "input_text";
+};
+
+/** @internal */
+export const TwoText$outboundSchema: z.ZodType<
+  TwoText$Outbound,
+  z.ZodTypeDef,
+  TwoText
+> = z.object({
+  text: z.string(),
+  type: z.literal("input_text"),
+});
+
+export function twoTextToJSON(twoText: TwoText): string {
+  return JSON.stringify(TwoText$outboundSchema.parse(twoText));
+}
+
+/** @internal */
+export type CreateRouterResponseContent2$Outbound =
+  | TwoText$Outbound
+  | Image$Outbound
+  | TwoFile$Outbound;
+
+/** @internal */
+export const CreateRouterResponseContent2$outboundSchema: z.ZodType<
+  CreateRouterResponseContent2$Outbound,
+  z.ZodTypeDef,
+  CreateRouterResponseContent2
+> = z.union([
+  z.lazy(() => TwoText$outboundSchema),
+  z.lazy(() => Image$outboundSchema),
+  z.lazy(() => TwoFile$outboundSchema),
+]);
+
+export function createRouterResponseContent2ToJSON(
+  createRouterResponseContent2: CreateRouterResponseContent2,
+): string {
+  return JSON.stringify(
+    CreateRouterResponseContent2$outboundSchema.parse(
+      createRouterResponseContent2,
+    ),
+  );
+}
+
+/** @internal */
+export type InputContent$Outbound =
+  | string
+  | Array<TwoText$Outbound | Image$Outbound | TwoFile$Outbound>;
+
+/** @internal */
+export const InputContent$outboundSchema: z.ZodType<
+  InputContent$Outbound,
+  z.ZodTypeDef,
+  InputContent
+> = z.union([
+  z.string(),
+  z.array(z.union([
+    z.lazy(() => TwoText$outboundSchema),
+    z.lazy(() => Image$outboundSchema),
+    z.lazy(() => TwoFile$outboundSchema),
+  ])),
+]);
+
+export function inputContentToJSON(inputContent: InputContent): string {
+  return JSON.stringify(InputContent$outboundSchema.parse(inputContent));
+}
+
+/** @internal */
+export const InputRole$outboundSchema: z.ZodNativeEnum<typeof InputRole> = z
+  .nativeEnum(InputRole);
+
+/** @internal */
+export const InputType$outboundSchema: z.ZodNativeEnum<typeof InputType> = z
+  .nativeEnum(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 const CreateRouterResponseInput2$outboundSchema: z.ZodType<
+  CreateRouterResponseInput2$Outbound,
+  z.ZodTypeDef,
+  CreateRouterResponseInput2
+> = z.object({
+  callId: z.string().optional(),
+  content: z.union([
+    z.string(),
+    z.array(z.union([
+      z.lazy(() => TwoText$outboundSchema),
+      z.lazy(() => Image$outboundSchema),
+      z.lazy(() => TwoFile$outboundSchema),
+    ])),
+  ]).optional(),
+  id: z.string().optional(),
+  output: z.string().optional(),
+  role: InputRole$outboundSchema.optional(),
+  type: InputType$outboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    callId: "call_id",
+  });
+});
+
+export function createRouterResponseInput2ToJSON(
+  createRouterResponseInput2: CreateRouterResponseInput2,
+): string {
+  return JSON.stringify(
+    CreateRouterResponseInput2$outboundSchema.parse(createRouterResponseInput2),
+  );
+}
+
+/** @internal */
+export type CreateRouterResponseInput$Outbound =
+  | string
+  | Array<CreateRouterResponseInput2$Outbound>;
+
+/** @internal */
+export const CreateRouterResponseInput$outboundSchema: z.ZodType<
+  CreateRouterResponseInput$Outbound,
+  z.ZodTypeDef,
+  CreateRouterResponseInput
+> = z.union([
+  z.string(),
+  z.array(z.lazy(() => CreateRouterResponseInput2$outboundSchema)),
+]);
+
+export function createRouterResponseInputToJSON(
+  createRouterResponseInput: CreateRouterResponseInput,
+): string {
+  return JSON.stringify(
+    CreateRouterResponseInput$outboundSchema.parse(createRouterResponseInput),
+  );
+}
+
+/** @internal */
+export type FormatSchema$Outbound = {};
+
+/** @internal */
+export const FormatSchema$outboundSchema: z.ZodType<
+  FormatSchema$Outbound,
+  z.ZodTypeDef,
+  FormatSchema
+> = z.object({});
+
+export function formatSchemaToJSON(formatSchema: FormatSchema): string {
+  return JSON.stringify(FormatSchema$outboundSchema.parse(formatSchema));
+}
+
+/** @internal */
+export type FormatJSONSchema$Outbound = {
+  description?: string | undefined;
+  name?: string | undefined;
+  schema?: FormatSchema$Outbound | undefined;
+  strict?: boolean | undefined;
+  type: "json_schema";
+};
+
+/** @internal */
+export const FormatJSONSchema$outboundSchema: z.ZodType<
+  FormatJSONSchema$Outbound,
+  z.ZodTypeDef,
+  FormatJSONSchema
+> = z.object({
+  description: z.string().optional(),
+  name: z.string().optional(),
+  schema: z.lazy(() => FormatSchema$outboundSchema).optional(),
+  strict: z.boolean().optional(),
+  type: z.literal("json_schema"),
+});
+
+export function formatJSONSchemaToJSON(
+  formatJSONSchema: FormatJSONSchema,
+): string {
+  return JSON.stringify(
+    FormatJSONSchema$outboundSchema.parse(formatJSONSchema),
+  );
+}
+
+/** @internal */
+export type PlainText$Outbound = {
+  type: "text";
+};
+
+/** @internal */
+export const PlainText$outboundSchema: z.ZodType<
+  PlainText$Outbound,
+  z.ZodTypeDef,
+  PlainText
+> = z.object({
+  type: z.literal("text"),
+});
+
+export function plainTextToJSON(plainText: PlainText): string {
+  return JSON.stringify(PlainText$outboundSchema.parse(plainText));
+}
+
+/** @internal */
+export type CreateRouterResponseFormat$Outbound =
+  | PlainText$Outbound
+  | FormatJSONSchema$Outbound;
+
+/** @internal */
+export const CreateRouterResponseFormat$outboundSchema: z.ZodType<
+  CreateRouterResponseFormat$Outbound,
+  z.ZodTypeDef,
+  CreateRouterResponseFormat
+> = z.union([
+  z.lazy(() => PlainText$outboundSchema),
+  z.lazy(() => FormatJSONSchema$outboundSchema),
+]);
+
+export function createRouterResponseFormatToJSON(
+  createRouterResponseFormat: CreateRouterResponseFormat,
+): string {
+  return JSON.stringify(
+    CreateRouterResponseFormat$outboundSchema.parse(createRouterResponseFormat),
+  );
+}
+
+/** @internal */
+export const Verbosity$outboundSchema: z.ZodNativeEnum<typeof Verbosity> = z
+  .nativeEnum(Verbosity);
+
+/** @internal */
+export type CreateRouterResponseText$Outbound = {
+  format?: PlainText$Outbound | FormatJSONSchema$Outbound | undefined;
+  verbosity?: string | undefined;
+};
+
+/** @internal */
+export const CreateRouterResponseText$outboundSchema: z.ZodType<
+  CreateRouterResponseText$Outbound,
+  z.ZodTypeDef,
+  CreateRouterResponseText
+> = z.object({
+  format: z.union([
+    z.lazy(() => PlainText$outboundSchema),
+    z.lazy(() => FormatJSONSchema$outboundSchema),
+  ]).optional(),
+  verbosity: Verbosity$outboundSchema.optional(),
+});
+
+export function createRouterResponseTextToJSON(
+  createRouterResponseText: CreateRouterResponseText,
+): string {
+  return JSON.stringify(
+    CreateRouterResponseText$outboundSchema.parse(createRouterResponseText),
+  );
+}
+
+/** @internal */
+export const CreateRouterResponseToolChoiceType$outboundSchema: z.ZodNativeEnum<
+  typeof CreateRouterResponseToolChoiceType
+> = z.nativeEnum(CreateRouterResponseToolChoiceType);
+
+/** @internal */
+export type SpecificFunction$Outbound = {
+  name: string;
+  type: string;
+};
+
+/** @internal */
+export const SpecificFunction$outboundSchema: z.ZodType<
+  SpecificFunction$Outbound,
+  z.ZodTypeDef,
+  SpecificFunction
+> = z.object({
+  name: z.string(),
+  type: CreateRouterResponseToolChoiceType$outboundSchema,
+});
+
+export function specificFunctionToJSON(
+  specificFunction: SpecificFunction,
+): string {
+  return JSON.stringify(
+    SpecificFunction$outboundSchema.parse(specificFunction),
+  );
+}
+
+/** @internal */
+export const Shorthand$outboundSchema: z.ZodNativeEnum<typeof Shorthand> = z
+  .nativeEnum(Shorthand);
+
+/** @internal */
+export type CreateRouterResponseToolChoice$Outbound =
+  | SpecificFunction$Outbound
+  | string;
+
+/** @internal */
+export const CreateRouterResponseToolChoice$outboundSchema: z.ZodType<
+  CreateRouterResponseToolChoice$Outbound,
+  z.ZodTypeDef,
+  CreateRouterResponseToolChoice
+> = z.union([
+  z.lazy(() => SpecificFunction$outboundSchema),
+  Shorthand$outboundSchema,
+]);
+
+export function createRouterResponseToolChoiceToJSON(
+  createRouterResponseToolChoice: CreateRouterResponseToolChoice,
+): string {
+  return JSON.stringify(
+    CreateRouterResponseToolChoice$outboundSchema.parse(
+      createRouterResponseToolChoice,
+    ),
+  );
+}
+
+/** @internal */
+export type AllowedTools$Outbound = {
+  read_only?: boolean | undefined;
+  tool_names?: Array<string> | undefined;
+};
+
+/** @internal */
+export const AllowedTools$outboundSchema: z.ZodType<
+  AllowedTools$Outbound,
+  z.ZodTypeDef,
+  AllowedTools
+> = z.object({
+  readOnly: z.boolean().optional(),
+  toolNames: z.array(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    readOnly: "read_only",
+    toolNames: "tool_names",
+  });
+});
+
+export function allowedToolsToJSON(allowedTools: AllowedTools): string {
+  return JSON.stringify(AllowedTools$outboundSchema.parse(allowedTools));
+}
+
+/** @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 const ToolsMCPTool$outboundSchema: z.ZodType<
+  ToolsMCPTool$Outbound,
+  z.ZodTypeDef,
+  ToolsMCPTool
+> = z.object({
+  allowedTools: z.lazy(() => AllowedTools$outboundSchema).optional(),
+  headers: z.record(z.string()).optional(),
+  key: z.string().optional(),
+  serverDescription: z.string().optional(),
+  serverUrl: z.string().optional(),
+  type: z.literal("mcp"),
+}).transform((v) => {
+  return remap$(v, {
+    allowedTools: "allowed_tools",
+    serverDescription: "server_description",
+    serverUrl: "server_url",
+  });
+});
+
+export function toolsMCPToolToJSON(toolsMCPTool: ToolsMCPTool): string {
+  return JSON.stringify(ToolsMCPTool$outboundSchema.parse(toolsMCPTool));
+}
+
+/** @internal */
+export const CreateRouterResponseToolsResponsesType$outboundSchema:
+  z.ZodNativeEnum<typeof CreateRouterResponseToolsResponsesType> = z.nativeEnum(
+    CreateRouterResponseToolsResponsesType,
+  );
+
+/** @internal */
+export type OrqAiTool$Outbound = {
+  tool_id?: string | undefined;
+  type: string;
+};
+
+/** @internal */
+export const OrqAiTool$outboundSchema: z.ZodType<
+  OrqAiTool$Outbound,
+  z.ZodTypeDef,
+  OrqAiTool
+> = z.object({
+  toolId: z.string().optional(),
+  type: CreateRouterResponseToolsResponsesType$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    toolId: "tool_id",
+  });
+});
+
+export function orqAiToolToJSON(orqAiTool: OrqAiTool): string {
+  return JSON.stringify(OrqAiTool$outboundSchema.parse(orqAiTool));
+}
+
+/** @internal */
+export type ToolsParameters$Outbound = {};
+
+/** @internal */
+export const ToolsParameters$outboundSchema: z.ZodType<
+  ToolsParameters$Outbound,
+  z.ZodTypeDef,
+  ToolsParameters
+> = z.object({});
+
+export function toolsParametersToJSON(
+  toolsParameters: ToolsParameters,
+): string {
+  return JSON.stringify(ToolsParameters$outboundSchema.parse(toolsParameters));
+}
+
+/** @internal */
+export type ToolsFunction$Outbound = {
+  description?: string | undefined;
+  name: string;
+  parameters?: ToolsParameters$Outbound | undefined;
+  strict?: boolean | undefined;
+  type: "function";
+};
+
+/** @internal */
+export const ToolsFunction$outboundSchema: z.ZodType<
+  ToolsFunction$Outbound,
+  z.ZodTypeDef,
+  ToolsFunction
+> = z.object({
+  description: z.string().optional(),
+  name: z.string(),
+  parameters: z.lazy(() => ToolsParameters$outboundSchema).optional(),
+  strict: z.boolean().optional(),
+  type: z.literal("function"),
+});
+
+export function toolsFunctionToJSON(toolsFunction: ToolsFunction): string {
+  return JSON.stringify(ToolsFunction$outboundSchema.parse(toolsFunction));
+}
+
+/** @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 const CreateRouterResponseTools$outboundSchema: z.ZodType<
+  CreateRouterResponseTools$Outbound,
+  z.ZodTypeDef,
+  CreateRouterResponseTools
+> = z.union([
+  z.lazy(() => ToolsFunction$outboundSchema),
+  z.lazy(() => OrqAiTool$outboundSchema).and(
+    z.object({ type: z.literal("orq:current_date") }),
+  ),
+  z.lazy(() => OrqAiTool$outboundSchema).and(
+    z.object({ type: z.literal("orq:google_search") }),
+  ),
+  z.lazy(() => OrqAiTool$outboundSchema).and(
+    z.object({ type: z.literal("orq:web_scraper") }),
+  ),
+  z.lazy(() => OrqAiTool$outboundSchema).and(
+    z.object({ type: z.literal("orq:mcp") }),
+  ),
+  z.lazy(() => OrqAiTool$outboundSchema).and(
+    z.object({ type: z.literal("orq:http") }),
+  ),
+  z.lazy(() => OrqAiTool$outboundSchema).and(
+    z.object({ type: z.literal("orq:function") }),
+  ),
+  z.lazy(() => ToolsMCPTool$outboundSchema),
+]);
+
+export function createRouterResponseToolsToJSON(
+  createRouterResponseTools: CreateRouterResponseTools,
+): string {
+  return JSON.stringify(
+    CreateRouterResponseTools$outboundSchema.parse(createRouterResponseTools),
+  );
+}
+
+/** @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 const CreateRouterResponseRequestBody$outboundSchema: z.ZodType<
+  CreateRouterResponseRequestBody$Outbound,
+  z.ZodTypeDef,
+  CreateRouterResponseRequestBody
+> = z.object({
+  conversation: components.ConversationParam$outboundSchema.optional(),
+  fallbacks: z.nullable(z.array(components.FallbackConfig$outboundSchema))
+    .optional(),
+  frequencyPenalty: z.number().optional(),
+  identity: components.ResponseIdentity$outboundSchema.optional(),
+  input: z.union([
+    z.string(),
+    z.array(z.lazy(() => CreateRouterResponseInput2$outboundSchema)),
+  ]).optional(),
+  instructions: z.string().optional(),
+  maxOutputTokens: z.number().int().optional(),
+  maxToolCalls: z.number().int().optional(),
+  memory: components.MemoryParam$outboundSchema.optional(),
+  metadata: z.record(z.any()).optional(),
+  model: z.string().optional(),
+  parallelToolCalls: z.boolean().optional(),
+  presencePenalty: z.number().optional(),
+  previousResponseId: z.string().optional(),
+  promptCacheKey: z.string().optional(),
+  reasoning: components.ReasoningParam$outboundSchema.optional(),
+  retry: components.ResponseRetryConfig$outboundSchema.optional(),
+  safetyIdentifier: z.string().optional(),
+  store: z.boolean().optional(),
+  stream: z.boolean().optional(),
+  streamOptions: components.StreamOptions$outboundSchema.optional(),
+  temperature: z.number().optional(),
+  text: z.lazy(() => CreateRouterResponseText$outboundSchema).optional(),
+  thread: components.ResponseThread$outboundSchema.optional(),
+  toolChoice: z.union([
+    z.lazy(() => SpecificFunction$outboundSchema),
+    Shorthand$outboundSchema,
+  ]).optional(),
+  tools: z.array(
+    z.union([
+      z.lazy(() => ToolsFunction$outboundSchema),
+      z.lazy(() =>
+        OrqAiTool$outboundSchema
+      ).and(z.object({ type: z.literal("orq:current_date") })),
+      z.lazy(() =>
+        OrqAiTool$outboundSchema
+      ).and(z.object({ type: z.literal("orq:google_search") })),
+      z.lazy(() =>
+        OrqAiTool$outboundSchema
+      ).and(z.object({ type: z.literal("orq:web_scraper") })),
+      z.lazy(() =>
+        OrqAiTool$outboundSchema
+      ).and(z.object({ type: z.literal("orq:mcp") })),
+      z.lazy(() =>
+        OrqAiTool$outboundSchema
+      ).and(z.object({ type: z.literal("orq:http") })),
+      z.lazy(() =>
+        OrqAiTool$outboundSchema
+      ).and(z.object({ type: z.literal("orq:function") })),
+      z.lazy(() => ToolsMCPTool$outboundSchema),
+    ]),
+  ).optional(),
+  topLogprobs: z.number().int().optional(),
+  topP: z.number().optional(),
+  variables: z.record(z.any()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    frequencyPenalty: "frequency_penalty",
+    maxOutputTokens: "max_output_tokens",
+    maxToolCalls: "max_tool_calls",
+    parallelToolCalls: "parallel_tool_calls",
+    presencePenalty: "presence_penalty",
+    previousResponseId: "previous_response_id",
+    promptCacheKey: "prompt_cache_key",
+    safetyIdentifier: "safety_identifier",
+    streamOptions: "stream_options",
+    toolChoice: "tool_choice",
+    topLogprobs: "top_logprobs",
+    topP: "top_p",
+  });
+});
+
+export function createRouterResponseRequestBodyToJSON(
+  createRouterResponseRequestBody: CreateRouterResponseRequestBody,
+): string {
+  return JSON.stringify(
+    CreateRouterResponseRequestBody$outboundSchema.parse(
+      createRouterResponseRequestBody,
+    ),
+  );
+}
+
+/** @internal */
+export const CreateRouterResponseType$inboundSchema: z.ZodNativeEnum<
+  typeof CreateRouterResponseType
+> = z.nativeEnum(CreateRouterResponseType);
+
+/** @internal */
+export const CreateRouterResponseData$inboundSchema: z.ZodType<
+  CreateRouterResponseData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  sequence_number: z.number().int(),
+  type: CreateRouterResponseType$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "sequence_number": "sequenceNumber",
+  });
+});
+
+export function createRouterResponseDataFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateRouterResponseData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateRouterResponseData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateRouterResponseData' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateRouterResponseResponsesResponseBody$inboundSchema: z.ZodType<
+  CreateRouterResponseResponsesResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.string().optional().transform((v, ctx) => {
+    if (v === undefined) return undefined;
+    try {
+      return JSON.parse(v);
+    } catch (err) {
+      ctx.addIssue({ code: "custom", message: `malformed json: ${err}` });
+      return z.NEVER;
+    }
+  }).pipe(z.lazy(() => CreateRouterResponseData$inboundSchema).optional()),
+});
+
+export function createRouterResponseResponsesResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  CreateRouterResponseResponsesResponseBody,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateRouterResponseResponsesResponseBody$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'CreateRouterResponseResponsesResponseBody' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateRouterResponseServiceTier$inboundSchema: z.ZodNativeEnum<
+  typeof CreateRouterResponseServiceTier
+> = z.nativeEnum(CreateRouterResponseServiceTier);
+
+/** @internal */
+export const CreateRouterResponseStatus$inboundSchema: z.ZodNativeEnum<
+  typeof CreateRouterResponseStatus
+> = z.nativeEnum(CreateRouterResponseStatus);
+
+/** @internal */
+export const CreateRouterResponseTruncation$inboundSchema: z.ZodNativeEnum<
+  typeof CreateRouterResponseTruncation
+> = z.nativeEnum(CreateRouterResponseTruncation);
+
+/** @internal */
+export const CreateRouterResponseResponseBody$inboundSchema: z.ZodType<
+  CreateRouterResponseResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  background: z.boolean(),
+  completed_at: z.nullable(z.number().int()),
+  conversation: components.ConversationParam$inboundSchema.optional(),
+  created_at: z.number().int(),
+  error: components.ResponseError$inboundSchema,
+  frequency_penalty: z.number(),
+  id: z.string(),
+  incomplete_details: components.IncompleteDetails$inboundSchema,
+  input: z.nullable(z.array(z.any())),
+  instructions: z.nullable(z.string()),
+  max_output_tokens: z.nullable(z.number().int()),
+  max_tool_calls: z.nullable(z.number().int()),
+  memory: components.MemoryParam$inboundSchema.optional(),
+  metadata: z.record(z.any()),
+  model: z.string(),
+  object: z.string(),
+  output: z.nullable(z.array(z.any())),
+  parallel_tool_calls: z.boolean(),
+  presence_penalty: z.number(),
+  previous_response_id: z.nullable(z.string()),
+  prompt_cache_key: z.nullable(z.string()),
+  prompt_cache_retention: z.nullable(z.string()),
+  reasoning: components.Reasoning$inboundSchema,
+  safety_identifier: z.nullable(z.string()),
+  service_tier: CreateRouterResponseServiceTier$inboundSchema,
+  status: CreateRouterResponseStatus$inboundSchema,
+  store: z.boolean(),
+  temperature: z.number(),
+  text: z.any().optional(),
+  tool_choice: z.any().optional(),
+  tools: z.nullable(z.array(z.any())),
+  top_logprobs: z.number().int(),
+  top_p: z.number(),
+  truncation: CreateRouterResponseTruncation$inboundSchema,
+  usage: components.PublicUsage$inboundSchema,
+  user: z.nullable(z.string()),
+  variables: z.record(z.any()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "completed_at": "completedAt",
+    "created_at": "createdAt",
+    "frequency_penalty": "frequencyPenalty",
+    "incomplete_details": "incompleteDetails",
+    "max_output_tokens": "maxOutputTokens",
+    "max_tool_calls": "maxToolCalls",
+    "parallel_tool_calls": "parallelToolCalls",
+    "presence_penalty": "presencePenalty",
+    "previous_response_id": "previousResponseId",
+    "prompt_cache_key": "promptCacheKey",
+    "prompt_cache_retention": "promptCacheRetention",
+    "safety_identifier": "safetyIdentifier",
+    "service_tier": "serviceTier",
+    "tool_choice": "toolChoice",
+    "top_logprobs": "topLogprobs",
+    "top_p": "topP",
+  });
+});
+
+export function createRouterResponseResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateRouterResponseResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateRouterResponseResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateRouterResponseResponseBody' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateRouterResponseResponse$inboundSchema: z.ZodType<
+  CreateRouterResponseResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => CreateRouterResponseResponseBody$inboundSchema),
+  z.instanceof(ReadableStream<Uint8Array>)
+    .transform(stream => {
+      return new EventStream(stream, rawEvent => {
+        if (rawEvent.data === "[DONE]") return { done: true, value: undefined };
+        return {
+          done: false,
+          value: z.lazy(() =>
+            CreateRouterResponseResponsesResponseBody$inboundSchema
+          ).parse(rawEvent),
+        };
+      }, { dataRequired: false });
+    }),
+]);
+
+export function createRouterResponseResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateRouterResponseResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateRouterResponseResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateRouterResponseResponse' from JSON`,
+  );
+}