@orq-ai/node 4.12.0-rc.8 → 4.13.0-rc.0

package/src/models/operations/createagentrequest.ts

@@ -155,6 +155,7 @@ export type Modalities = ClosedEnum<typeof Modalities>;
  */
 export const Id1 = {
   OrqPiiDetection: "orq_pii_detection",
+  OrqSecretDetection: "orq_secret_detection",
   OrqSexualModeration: "orq_sexual_moderation",
   OrqHarmfulModeration: "orq_harmful_moderation",
 } as const;
@@ -632,6 +633,7 @@ export type FallbackModelConfigurationModalities = ClosedEnum<
  */
 export const CreateAgentRequestId1 = {
   OrqPiiDetection: "orq_pii_detection",
+  OrqSecretDetection: "orq_secret_detection",
   OrqSexualModeration: "orq_sexual_moderation",
   OrqHarmfulModeration: "orq_harmful_moderation",
 } as const;
@@ -979,545 +981,343 @@ export const ToolApprovalRequired = {
 export type ToolApprovalRequired = ClosedEnum<typeof ToolApprovalRequired>;
 
 /**
- * Provider-specific built-in tools that are passed through to the provider. Must be prefixed with the provider name (e.g., openai:web_search, anthropic:web_search_20250305, google:google_search).
+ * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
+ */
+export const CreateAgentRequestExecuteOn = {
+  Input: "input",
+  Output: "output",
+} as const;
+/**
+ * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
  */
-export type ProviderBuiltInTool = {
+export type CreateAgentRequestExecuteOn = ClosedEnum<
+  typeof CreateAgentRequestExecuteOn
+>;
+
+export type Evaluators = {
   /**
-   * Provider-prefixed tool type
+   * Unique key or identifier of the evaluator
    */
-  type: string;
+  id: string;
   /**
-   * Whether this tool requires approval before execution
+   * The percentage of executions to evaluate with this evaluator (1-100). For example, a value of 50 means the evaluator will run on approximately half of the executions.
    */
-  requiresApproval?: boolean | undefined;
+  sampleRate?: number | undefined;
   /**
-   * Static tool configuration set at design time. Merged over LLM-provided arguments at execution time.
+   * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
    */
-  configuration?: { [k: string]: any } | undefined;
+  executeOn: CreateAgentRequestExecuteOn;
 };
 
 /**
- * MCP tool type
+ * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
  */
-export const CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools17Type =
-  {
-    Mcp: "mcp",
-  } as const;
+export const CreateAgentRequestAgentsExecuteOn = {
+  Input: "input",
+  Output: "output",
+} as const;
 /**
- * MCP tool type
+ * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
  */
-export type CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools17Type =
-  ClosedEnum<
-    typeof CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools17Type
-  >;
+export type CreateAgentRequestAgentsExecuteOn = ClosedEnum<
+  typeof CreateAgentRequestAgentsExecuteOn
+>;
 
-/**
- * Executes tools from Model Context Protocol (MCP) servers. Specify the parent MCP tool using "key" or "id", and the specific nested tool using "tool_id".
- */
-export type MCPTool = {
-  /**
-   * MCP tool type
-   */
-  type?:
-    | CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools17Type
-    | undefined;
-  /**
-   * The key of the parent MCP tool
-   */
-  key?: string | undefined;
+export type CreateAgentRequestGuardrails = {
   /**
-   * The ID of the parent MCP tool
+   * Unique key or identifier of the evaluator
    */
-  id?: string | undefined;
+  id: string;
   /**
-   * The ID of the specific nested tool within the MCP server
+   * The percentage of executions to evaluate with this evaluator (1-100). For example, a value of 50 means the evaluator will run on approximately half of the executions.
    */
-  toolId: string;
+  sampleRate?: number | undefined;
   /**
-   * Whether this tool requires approval before execution
+   * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
    */
-  requiresApproval?: boolean | undefined;
+  executeOn: CreateAgentRequestAgentsExecuteOn;
 };
 
 /**
- * JSON Schema tool type
- */
-export const CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools16Type =
-  {
-    JsonSchema: "json_schema",
-  } as const;
-/**
- * JSON Schema tool type
- */
-export type CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools16Type =
-  ClosedEnum<
-    typeof CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools16Type
-  >;
-
-/**
- * Enforces structured output format using JSON Schema. Must reference a pre-created JSON Schema tool by key or id.
+ * Configuration settings for the agent's behavior
  */
-export type JSONSchemaTool = {
+export type Settings = {
   /**
-   * JSON Schema tool type
+   * Maximum iterations(llm calls) before the agent will stop executing.
    */
-  type?:
-    | CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools16Type
-    | undefined;
+  maxIterations?: number | undefined;
   /**
-   * The key of the pre-created JSON Schema tool
+   * Maximum time (in seconds) for the agent thinking process. This does not include the time for tool calls and sub agent calls. It will be loosely enforced, the in progress LLM calls will not be terminated and the last assistant message will be returned.
    */
-  key?: string | undefined;
+  maxExecutionTime?: number | undefined;
   /**
-   * The ID of the pre-created JSON Schema tool
+   * Maximum cost in USD for the agent execution. When the accumulated cost exceeds this limit, the agent will stop executing. Set to 0 for unlimited. Only supported in v3 responses
    */
-  id?: string | undefined;
+  maxCost?: number | undefined;
   /**
-   * Whether this tool requires approval before execution
+   * If all, the agent will require approval for all tools. If respect_tool, the agent will require approval for tools that have the requires_approval flag set to true. If none, the agent will not require approval for any tools.
    */
-  requiresApproval?: boolean | undefined;
-};
-
-/**
- * Function tool type
- */
-export const CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools15Type =
-  {
-    Function: "function",
-  } as const;
-/**
- * Function tool type
- */
-export type CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools15Type =
-  ClosedEnum<
-    typeof CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools15Type
-  >;
-
-/**
- * Calls custom function tools defined in the agent configuration. Must reference a pre-created function tool by key or id.
- */
-export type FunctionTool = {
+  toolApprovalRequired?: ToolApprovalRequired | undefined;
   /**
-   * Function tool type
+   * When enabled, this agent is exposed as a selectable target in AI Chat for users to consume.
    */
-  type?:
-    | CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools15Type
-    | undefined;
+  chatExposed?: boolean | undefined;
   /**
-   * The key of the pre-created function tool
+   * Tools available to the agent. Built-in tools only need a type, while custom tools (http, code, function) must reference pre-created tools by key or id.
    */
-  key?: string | undefined;
+  tools?: Array<components.AgentToolInputCRUD> | undefined;
   /**
-   * The ID of the pre-created function tool
+   * Configuration for an evaluator applied to the agent
    */
-  id?: string | undefined;
+  evaluators?: Array<Evaluators> | undefined;
   /**
-   * Whether this tool requires approval before execution
+   * Configuration for a guardrail applied to the agent
    */
-  requiresApproval?: boolean | undefined;
+  guardrails?: Array<CreateAgentRequestGuardrails> | undefined;
 };
 
-/**
- * Code execution tool type
- */
-export const CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools14Type =
-  {
-    Code: "code",
-  } as const;
-/**
- * Code execution tool type
- */
-export type CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools14Type =
-  ClosedEnum<
-    typeof CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools14Type
-  >;
-
-/**
- * Executes code snippets in a sandboxed environment. Must reference a pre-created code tool by key or id.
- */
-export type CodeExecutionTool = {
-  /**
-   * Code execution tool type
-   */
-  type?:
-    | CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools14Type
-    | undefined;
+export type KnowledgeBases = {
   /**
-   * The key of the pre-created code tool
+   * Unique identifier of the knowledge base to search
    */
-  key?: string | undefined;
+  knowledgeId: string;
+};
+
+export type TeamOfAgents = {
   /**
-   * The ID of the pre-created code tool
+   * The unique key of the agent within the workspace
    */
-  id?: string | undefined;
+  key: string;
   /**
-   * Whether this tool requires approval before execution
+   * The role of the agent in this context. This is used to give extra information to the leader to help it decide which agent to hand off to.
    */
-  requiresApproval?: boolean | undefined;
+  role?: string | undefined;
 };
 
-/**
- * HTTP tool type
- */
-export const CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools13Type =
-  {
-    Http: "http",
-  } as const;
-/**
- * HTTP tool type
- */
-export type CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools13Type =
-  ClosedEnum<
-    typeof CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools13Type
-  >;
+export const Source = {
+  Internal: "internal",
+  External: "external",
+  Experiment: "experiment",
+} as const;
+export type Source = ClosedEnum<typeof Source>;
 
-/**
- * Executes HTTP requests to interact with external APIs and web services. Must reference a pre-created HTTP tool by key or id.
- */
-export type HTTPTool = {
+export const Engine = {
+  Text: "text",
+  Jinja: "jinja",
+  Mustache: "mustache",
+} as const;
+export type Engine = ClosedEnum<typeof Engine>;
+
+export type CreateAgentRequestRequestBody = {
   /**
-   * HTTP tool type
+   * Unique identifier for the agent within the workspace
    */
-  type?:
-    | CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools13Type
-    | undefined;
+  key: string;
   /**
-   * The key of the pre-created HTTP tool
+   * agent display name within the workspace
    */
-  key?: string | undefined;
+  displayName?: string | undefined;
   /**
-   * The ID of the pre-created HTTP tool
+   * The role or function of the agent
    */
-  id?: string | undefined;
+  role: string;
   /**
-   * Whether this tool requires approval before execution
+   * A brief description of what the agent does
    */
-  requiresApproval?: boolean | undefined;
-};
-
-export const CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools12Type =
-  {
-    CodeInterpreter: "code_interpreter",
-  } as const;
-export type CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools12Type =
-  ClosedEnum<
-    typeof CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools12Type
-  >;
-
-/**
- * Executes model-written Python code. Uses provider-native code execution when the model supports it, otherwise a secure orq-managed sandbox.
- */
-export type CodeInterpreterTool = {
-  type:
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools12Type;
+  description: string;
   /**
-   * Whether this tool requires approval before execution
+   * Detailed instructions that guide the agent's behavior
    */
-  requiresApproval?: boolean | undefined;
+  instructions: string;
   /**
-   * Static tool configuration set at design time. Merged over LLM-provided arguments at execution time.
+   * A custom system prompt template for the agent. If omitted, the default template is used.
    */
-  configuration?: { [k: string]: any } | undefined;
-};
-
-export const CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools11Type =
-  {
-    CurrentDate: "current_date",
-  } as const;
-export type CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools11Type =
-  ClosedEnum<
-    typeof CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools11Type
-  >;
-
-/**
- * Returns the current date and time
- */
-export type CurrentDateTool = {
-  type:
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools11Type;
+  systemPrompt?: string | null | undefined;
   /**
-   * Whether this tool requires approval before execution
+   * The path where the agent will be stored in the project structure. The first element identifies the project, followed by nested folders (auto-created as needed).
+   *
+   * @remarks
+   *
+   * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
    */
-  requiresApproval?: boolean | undefined;
+  path: string;
   /**
-   * Static tool configuration set at design time. Merged over LLM-provided arguments at execution time.
+   * Model configuration for agent execution. Can be a simple model ID string or a configuration object with optional behavior parameters and retry settings.
    */
-  configuration?: { [k: string]: any } | undefined;
-};
-
-export const CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools10Type =
-  {
-    QueryKnowledgeBase: "query_knowledge_base",
-  } as const;
-export type CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools10Type =
-  ClosedEnum<
-    typeof CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools10Type
-  >;
-
-/**
- * Queries knowledge bases for information
- */
-export type QueryKnowledgeBaseTool = {
-  type:
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools10Type;
+  model: ModelConfiguration2 | string;
   /**
-   * Whether this tool requires approval before execution
+   * Optional array of fallback models used when the primary model fails. Fallbacks are attempted in order. All models must support tool calling.
    */
-  requiresApproval?: boolean | undefined;
+  fallbackModels?: Array<FallbackModelConfiguration2 | string> | undefined;
   /**
-   * Static tool configuration set at design time. Merged over LLM-provided arguments at execution time.
+   * Configuration settings for the agent's behavior
    */
-  configuration?: { [k: string]: any } | undefined;
-};
-
-export const CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools9Type =
-  {
-    RetrieveKnowledgeBases: "retrieve_knowledge_bases",
-  } as const;
-export type CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools9Type =
-  ClosedEnum<
-    typeof CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools9Type
-  >;
-
-/**
- * Lists available knowledge bases
- */
-export type RetrieveKnowledgeBasesTool = {
-  type:
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools9Type;
+  settings: Settings;
   /**
-   * Whether this tool requires approval before execution
+   * Optional array of memory store identifiers for the agent to access. Accepts both memory store IDs and keys.
    */
-  requiresApproval?: boolean | undefined;
+  memoryStores?: Array<string> | undefined;
   /**
-   * Static tool configuration set at design time. Merged over LLM-provided arguments at execution time.
+   * Optional array of knowledge base configurations for the agent to access
    */
-  configuration?: { [k: string]: any } | undefined;
-};
-
-export const CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools8Type =
-  {
-    DeleteMemoryDocument: "delete_memory_document",
-  } as const;
-export type CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools8Type =
-  ClosedEnum<
-    typeof CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools8Type
-  >;
-
-/**
- * Deletes documents from memory stores
- */
-export type DeleteMemoryDocumentTool = {
-  type:
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools8Type;
+  knowledgeBases?: Array<KnowledgeBases> | undefined;
   /**
-   * Whether this tool requires approval before execution
+   * The agents that are accessible to this orchestrator. The main agent can hand off to these agents to perform tasks.
    */
-  requiresApproval?: boolean | undefined;
+  teamOfAgents?: Array<TeamOfAgents> | undefined;
   /**
-   * Static tool configuration set at design time. Merged over LLM-provided arguments at execution time.
+   * List of skills that the agent can utilize. This field allows you to specify which skills the agent has access to, enabling more complex and dynamic behavior.
    */
-  configuration?: { [k: string]: any } | undefined;
+  skills?: Array<string> | null | undefined;
+  variables?: { [k: string]: any } | undefined;
+  source?: Source | undefined;
+  engine?: Engine | undefined;
 };
 
-export const CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsToolsType =
-  {
-    RetrieveMemoryStores: "retrieve_memory_stores",
-  } as const;
-export type CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsToolsType =
-  ClosedEnum<
-    typeof CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsToolsType
-  >;
-
 /**
- * Lists available memory stores
+ * The status of the agent. `Live` is the latest version of the agent. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
+ */
+export const CreateAgentRequestStatus = {
+  Live: "live",
+  Draft: "draft",
+  Pending: "pending",
+  Published: "published",
+} as const;
+/**
+ * The status of the agent. `Live` is the latest version of the agent. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
  */
-export type RetrieveMemoryStoresTool = {
-  type:
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsToolsType;
+export type CreateAgentRequestStatus = ClosedEnum<
+  typeof CreateAgentRequestStatus
+>;
+
+export type CreateAgentRequestTeamOfAgents = {
   /**
-   * Whether this tool requires approval before execution
+   * The unique key of the agent within the workspace
    */
-  requiresApproval?: boolean | undefined;
+  key: string;
   /**
-   * Static tool configuration set at design time. Merged over LLM-provided arguments at execution time.
+   * The role of the agent in this context. This is used to give extra information to the leader to help it decide which agent to hand off to.
    */
-  configuration?: { [k: string]: any } | undefined;
+  role?: string | undefined;
 };
 
-export const CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsType =
-  {
-    WriteMemoryStore: "write_memory_store",
-  } as const;
-export type CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsType =
-  ClosedEnum<
-    typeof CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsType
-  >;
+export type Metrics = {
+  totalCost: number;
+};
 
-/**
- * Writes information to agent memory stores
- */
-export type WriteMemoryStoreTool = {
-  type:
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsType;
-  /**
-   * Whether this tool requires approval before execution
-   */
-  requiresApproval?: boolean | undefined;
+export type CreateAgentRequestKnowledgeBases = {
   /**
-   * Static tool configuration set at design time. Merged over LLM-provided arguments at execution time.
+   * Unique identifier of the knowledge base to search
    */
-  configuration?: { [k: string]: any } | undefined;
+  knowledgeId: string;
 };
 
-export const CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodyType =
-  {
-    QueryMemoryStore: "query_memory_store",
-  } as const;
-export type CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodyType =
-  ClosedEnum<
-    typeof CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodyType
-  >;
+export const CreateAgentRequestSource = {
+  Internal: "internal",
+  External: "external",
+  Experiment: "experiment",
+} as const;
+export type CreateAgentRequestSource = ClosedEnum<
+  typeof CreateAgentRequestSource
+>;
+
+export const CreateAgentRequestEngine = {
+  Text: "text",
+  Jinja: "jinja",
+  Mustache: "mustache",
+} as const;
+export type CreateAgentRequestEngine = ClosedEnum<
+  typeof CreateAgentRequestEngine
+>;
 
 /**
- * Queries agent memory stores for context
+ * Agent type: internal (Orquesta-managed) or a2a (external A2A-compliant)
  */
-export type QueryMemoryStoreTool = {
-  type: CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodyType;
-  /**
-   * Whether this tool requires approval before execution
-   */
-  requiresApproval?: boolean | undefined;
-  /**
-   * Static tool configuration set at design time. Merged over LLM-provided arguments at execution time.
-   */
-  configuration?: { [k: string]: any } | undefined;
-};
-
-export const CreateAgentRequestAgentToolInputCRUDAgentsRequestType = {
-  RetrieveAgents: "retrieve_agents",
+export const CreateAgentRequestType = {
+  Internal: "internal",
+  A2a: "a2a",
 } as const;
-export type CreateAgentRequestAgentToolInputCRUDAgentsRequestType = ClosedEnum<
-  typeof CreateAgentRequestAgentToolInputCRUDAgentsRequestType
->;
+/**
+ * Agent type: internal (Orquesta-managed) or a2a (external A2A-compliant)
+ */
+export type CreateAgentRequestType = ClosedEnum<typeof CreateAgentRequestType>;
 
 /**
- * Retrieves available agents in the system
+ * If all, the agent will require approval for all tools. If respect_tool, the agent will require approval for tools that have the requires_approval flag set to true. If none, the agent will not require approval for any tools.
+ */
+export const CreateAgentRequestToolApprovalRequired = {
+  All: "all",
+  RespectTool: "respect_tool",
+  None: "none",
+} as const;
+/**
+ * If all, the agent will require approval for all tools. If respect_tool, the agent will require approval for tools that have the requires_approval flag set to true. If none, the agent will not require approval for any tools.
  */
-export type RetrieveAgentsTool = {
-  type: CreateAgentRequestAgentToolInputCRUDAgentsRequestType;
+export type CreateAgentRequestToolApprovalRequired = ClosedEnum<
+  typeof CreateAgentRequestToolApprovalRequired
+>;
+
+export type Conditions = {
   /**
-   * Whether this tool requires approval before execution
+   * The argument of the tool call to evaluate
    */
-  requiresApproval?: boolean | undefined;
+  condition: string;
   /**
-   * Static tool configuration set at design time. Merged over LLM-provided arguments at execution time.
+   * The operator to use
    */
-  configuration?: { [k: string]: any } | undefined;
+  operator: string;
+  /**
+   * The value to compare against
+   */
+  value: string;
 };
 
-export const CreateAgentRequestAgentToolInputCRUDAgentsType = {
-  CallSubAgent: "call_sub_agent",
-} as const;
-export type CreateAgentRequestAgentToolInputCRUDAgentsType = ClosedEnum<
-  typeof CreateAgentRequestAgentToolInputCRUDAgentsType
->;
-
-/**
- * Delegates tasks to specialized sub-agents
- */
-export type CallSubAgentTool = {
-  type: CreateAgentRequestAgentToolInputCRUDAgentsType;
+export type CreateAgentRequestTools = {
   /**
-   * Whether this tool requires approval before execution
+   * The id of the resource
    */
-  requiresApproval?: boolean | undefined;
+  id: string;
   /**
-   * Static tool configuration set at design time. Merged over LLM-provided arguments at execution time.
+   * Optional tool key for custom tools
    */
-  configuration?: { [k: string]: any } | undefined;
-};
-
-export const CreateAgentRequestAgentToolInputCRUDType = {
-  WebScraper: "web_scraper",
-} as const;
-export type CreateAgentRequestAgentToolInputCRUDType = ClosedEnum<
-  typeof CreateAgentRequestAgentToolInputCRUDType
->;
-
-/**
- * Scrapes and extracts content from web pages
- */
-export type WebScraperTool = {
-  type: CreateAgentRequestAgentToolInputCRUDType;
+  key?: string | undefined;
+  actionType: string;
+  displayName?: string | undefined;
   /**
-   * Whether this tool requires approval before execution
+   * Optional tool description
    */
-  requiresApproval?: boolean | undefined;
+  description?: string | undefined;
   /**
    * Static tool configuration set at design time. Merged over LLM-provided arguments at execution time.
    */
   configuration?: { [k: string]: any } | undefined;
-};
-
-export const AgentToolInputCRUDType = {
-  GoogleSearch: "google_search",
-} as const;
-export type AgentToolInputCRUDType = ClosedEnum<typeof AgentToolInputCRUDType>;
-
-/**
- * Performs Google searches to retrieve web content
- */
-export type GoogleSearchTool = {
-  type: AgentToolInputCRUDType;
+  requiresApproval: boolean;
   /**
-   * Whether this tool requires approval before execution
+   * Nested tool ID for MCP tools (identifies specific tool within MCP server)
    */
-  requiresApproval?: boolean | undefined;
+  toolId?: string | undefined;
+  conditions?: Array<Conditions> | undefined;
   /**
-   * Static tool configuration set at design time. Merged over LLM-provided arguments at execution time.
+   * Tool execution timeout in seconds for this agent (max: 10 minutes). Overrides the timeout configured on the tool definition.
    */
-  configuration?: { [k: string]: any } | undefined;
+  timeout?: number | undefined;
 };
 
-/**
- * Tool configuration for agent create/update operations. Built-in tools only require a type, while custom tools (HTTP, Code, Function, JSON Schema, MCP) must reference pre-created tools by key or id. Provider-prefixed tools (e.g., openai:web_search) are passed through to the provider.
- */
-export type AgentToolInputCRUD =
-  | GoogleSearchTool
-  | WebScraperTool
-  | CallSubAgentTool
-  | RetrieveAgentsTool
-  | QueryMemoryStoreTool
-  | WriteMemoryStoreTool
-  | RetrieveMemoryStoresTool
-  | DeleteMemoryDocumentTool
-  | RetrieveKnowledgeBasesTool
-  | QueryKnowledgeBaseTool
-  | CurrentDateTool
-  | CodeInterpreterTool
-  | MCPTool
-  | ProviderBuiltInTool
-  | HTTPTool
-  | CodeExecutionTool
-  | FunctionTool
-  | JSONSchemaTool;
-
 /**
  * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
  */
-export const CreateAgentRequestExecuteOn = {
+export const CreateAgentRequestAgentsResponseExecuteOn = {
   Input: "input",
   Output: "output",
 } as const;
 /**
  * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
  */
-export type CreateAgentRequestExecuteOn = ClosedEnum<
-  typeof CreateAgentRequestExecuteOn
+export type CreateAgentRequestAgentsResponseExecuteOn = ClosedEnum<
+  typeof CreateAgentRequestAgentsResponseExecuteOn
 >;
 
-export type Evaluators = {
+export type CreateAgentRequestEvaluators = {
   /**
    * Unique key or identifier of the evaluator
    */
@@ -1525,28 +1325,28 @@ export type Evaluators = {
   /**
    * The percentage of executions to evaluate with this evaluator (1-100). For example, a value of 50 means the evaluator will run on approximately half of the executions.
    */
-  sampleRate?: number | undefined;
+  sampleRate: number;
   /**
    * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
    */
-  executeOn: CreateAgentRequestExecuteOn;
+  executeOn: CreateAgentRequestAgentsResponseExecuteOn;
 };
 
 /**
  * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
  */
-export const CreateAgentRequestAgentsExecuteOn = {
+export const CreateAgentRequestAgentsResponse201ExecuteOn = {
   Input: "input",
   Output: "output",
 } as const;
 /**
  * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
  */
-export type CreateAgentRequestAgentsExecuteOn = ClosedEnum<
-  typeof CreateAgentRequestAgentsExecuteOn
+export type CreateAgentRequestAgentsResponse201ExecuteOn = ClosedEnum<
+  typeof CreateAgentRequestAgentsResponse201ExecuteOn
 >;
 
-export type CreateAgentRequestGuardrails = {
+export type CreateAgentRequestAgentsGuardrails = {
   /**
    * Unique key or identifier of the evaluator
    */
@@ -1554,412 +1354,68 @@ export type CreateAgentRequestGuardrails = {
   /**
    * The percentage of executions to evaluate with this evaluator (1-100). For example, a value of 50 means the evaluator will run on approximately half of the executions.
    */
-  sampleRate?: number | undefined;
+  sampleRate: number;
   /**
    * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
    */
-  executeOn: CreateAgentRequestAgentsExecuteOn;
+  executeOn: CreateAgentRequestAgentsResponse201ExecuteOn;
 };
 
-/**
- * Configuration settings for the agent's behavior
- */
-export type Settings = {
+export type CreateAgentRequestSettings = {
   /**
    * Maximum iterations(llm calls) before the agent will stop executing.
    */
-  maxIterations?: number | undefined;
+  maxIterations: number;
   /**
    * Maximum time (in seconds) for the agent thinking process. This does not include the time for tool calls and sub agent calls. It will be loosely enforced, the in progress LLM calls will not be terminated and the last assistant message will be returned.
    */
-  maxExecutionTime?: number | undefined;
+  maxExecutionTime: number;
   /**
    * Maximum cost in USD for the agent execution. When the accumulated cost exceeds this limit, the agent will stop executing. Set to 0 for unlimited. Only supported in v3 responses
    */
-  maxCost?: number | undefined;
+  maxCost: number;
   /**
    * If all, the agent will require approval for all tools. If respect_tool, the agent will require approval for tools that have the requires_approval flag set to true. If none, the agent will not require approval for any tools.
    */
-  toolApprovalRequired?: ToolApprovalRequired | undefined;
+  toolApprovalRequired: CreateAgentRequestToolApprovalRequired;
   /**
    * When enabled, this agent is exposed as a selectable target in AI Chat for users to consume.
    */
   chatExposed?: boolean | undefined;
-  /**
-   * Tools available to the agent. Built-in tools only need a type, while custom tools (http, code, function) must reference pre-created tools by key or id.
-   */
-  tools?:
-    | Array<
-      | GoogleSearchTool
-      | WebScraperTool
-      | CallSubAgentTool
-      | RetrieveAgentsTool
-      | QueryMemoryStoreTool
-      | WriteMemoryStoreTool
-      | RetrieveMemoryStoresTool
-      | DeleteMemoryDocumentTool
-      | RetrieveKnowledgeBasesTool
-      | QueryKnowledgeBaseTool
-      | CurrentDateTool
-      | CodeInterpreterTool
-      | MCPTool
-      | ProviderBuiltInTool
-      | HTTPTool
-      | CodeExecutionTool
-      | FunctionTool
-      | JSONSchemaTool
-    >
-    | undefined;
+  tools?: Array<CreateAgentRequestTools> | undefined;
   /**
    * Configuration for an evaluator applied to the agent
    */
-  evaluators?: Array<Evaluators> | undefined;
+  evaluators?: Array<CreateAgentRequestEvaluators> | undefined;
   /**
    * Configuration for a guardrail applied to the agent
    */
-  guardrails?: Array<CreateAgentRequestGuardrails> | undefined;
-};
-
-export type KnowledgeBases = {
-  /**
-   * Unique identifier of the knowledge base to search
-   */
-  knowledgeId: string;
-};
-
-export type TeamOfAgents = {
-  /**
-   * The unique key of the agent within the workspace
-   */
-  key: string;
-  /**
-   * The role of the agent in this context. This is used to give extra information to the leader to help it decide which agent to hand off to.
-   */
-  role?: string | undefined;
+  guardrails?: Array<CreateAgentRequestAgentsGuardrails> | undefined;
 };
 
-export const Source = {
-  Internal: "internal",
-  External: "external",
-  Experiment: "experiment",
-} as const;
-export type Source = ClosedEnum<typeof Source>;
-
-export const Engine = {
-  Text: "text",
-  Jinja: "jinja",
-  Mustache: "mustache",
-} as const;
-export type Engine = ClosedEnum<typeof Engine>;
-
-export type CreateAgentRequestRequestBody = {
-  /**
-   * Unique identifier for the agent within the workspace
-   */
-  key: string;
-  /**
-   * agent display name within the workspace
-   */
-  displayName?: string | undefined;
-  /**
-   * The role or function of the agent
-   */
-  role: string;
-  /**
-   * A brief description of what the agent does
-   */
-  description: string;
-  /**
-   * Detailed instructions that guide the agent's behavior
-   */
-  instructions: string;
-  /**
-   * A custom system prompt template for the agent. If omitted, the default template is used.
-   */
-  systemPrompt?: string | null | undefined;
-  /**
-   * The path where the agent will be stored in the project structure. The first element identifies the project, followed by nested folders (auto-created as needed).
-   *
-   * @remarks
-   *
-   * With project-based API keys, the first element is treated as a folder name, as the project is predetermined by the API key.
-   */
-  path: string;
-  /**
-   * Model configuration for agent execution. Can be a simple model ID string or a configuration object with optional behavior parameters and retry settings.
-   */
-  model: ModelConfiguration2 | string;
-  /**
-   * Optional array of fallback models used when the primary model fails. Fallbacks are attempted in order. All models must support tool calling.
-   */
-  fallbackModels?: Array<FallbackModelConfiguration2 | string> | undefined;
-  /**
-   * Configuration settings for the agent's behavior
-   */
-  settings: Settings;
+export type CreateAgentRequestResponseFormatAgentsResponseJsonSchema = {
   /**
-   * Optional array of memory store identifiers for the agent to access. Accepts both memory store IDs and keys.
+   * A description of what the response format is for, used by the model to determine how to respond in the format.
    */
-  memoryStores?: Array<string> | undefined;
+  description?: string | undefined;
   /**
-   * Optional array of knowledge base configurations for the agent to access
+   * The name of the response format. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64.
    */
-  knowledgeBases?: Array<KnowledgeBases> | undefined;
+  name: string;
   /**
-   * The agents that are accessible to this orchestrator. The main agent can hand off to these agents to perform tasks.
+   * The schema for the response format, described as a JSON Schema object.
    */
-  teamOfAgents?: Array<TeamOfAgents> | undefined;
+  schema?: any | undefined;
   /**
-   * List of skills that the agent can utilize. This field allows you to specify which skills the agent has access to, enabling more complex and dynamic behavior.
+   * Whether to enable strict schema adherence when generating the output. If set to true, the model will always follow the exact schema defined in the schema field. Only a subset of JSON Schema is supported when strict is true.
    */
-  skills?: Array<string> | null | undefined;
-  variables?: { [k: string]: any } | undefined;
-  source?: Source | undefined;
-  engine?: Engine | undefined;
+  strict: boolean;
 };
 
 /**
- * The status of the agent. `Live` is the latest version of the agent. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
- */
-export const CreateAgentRequestStatus = {
-  Live: "live",
-  Draft: "draft",
-  Pending: "pending",
-  Published: "published",
-} as const;
-/**
- * The status of the agent. `Live` is the latest version of the agent. `Draft` is a version that is not yet published. `Pending` is a version that is pending approval. `Published` is a version that was live and has been replaced by a new version.
- */
-export type CreateAgentRequestStatus = ClosedEnum<
-  typeof CreateAgentRequestStatus
->;
-
-export type CreateAgentRequestTeamOfAgents = {
-  /**
-   * The unique key of the agent within the workspace
-   */
-  key: string;
-  /**
-   * The role of the agent in this context. This is used to give extra information to the leader to help it decide which agent to hand off to.
-   */
-  role?: string | undefined;
-};
-
-export type Metrics = {
-  totalCost: number;
-};
-
-export type CreateAgentRequestKnowledgeBases = {
-  /**
-   * Unique identifier of the knowledge base to search
-   */
-  knowledgeId: string;
-};
-
-export const CreateAgentRequestSource = {
-  Internal: "internal",
-  External: "external",
-  Experiment: "experiment",
-} as const;
-export type CreateAgentRequestSource = ClosedEnum<
-  typeof CreateAgentRequestSource
->;
-
-export const CreateAgentRequestEngine = {
-  Text: "text",
-  Jinja: "jinja",
-  Mustache: "mustache",
-} as const;
-export type CreateAgentRequestEngine = ClosedEnum<
-  typeof CreateAgentRequestEngine
->;
-
-/**
- * Agent type: internal (Orquesta-managed) or a2a (external A2A-compliant)
- */
-export const CreateAgentRequestType = {
-  Internal: "internal",
-  A2a: "a2a",
-} as const;
-/**
- * Agent type: internal (Orquesta-managed) or a2a (external A2A-compliant)
- */
-export type CreateAgentRequestType = ClosedEnum<typeof CreateAgentRequestType>;
-
-/**
- * If all, the agent will require approval for all tools. If respect_tool, the agent will require approval for tools that have the requires_approval flag set to true. If none, the agent will not require approval for any tools.
- */
-export const CreateAgentRequestToolApprovalRequired = {
-  All: "all",
-  RespectTool: "respect_tool",
-  None: "none",
-} as const;
-/**
- * If all, the agent will require approval for all tools. If respect_tool, the agent will require approval for tools that have the requires_approval flag set to true. If none, the agent will not require approval for any tools.
- */
-export type CreateAgentRequestToolApprovalRequired = ClosedEnum<
-  typeof CreateAgentRequestToolApprovalRequired
->;
-
-export type Conditions = {
-  /**
-   * The argument of the tool call to evaluate
-   */
-  condition: string;
-  /**
-   * The operator to use
-   */
-  operator: string;
-  /**
-   * The value to compare against
-   */
-  value: string;
-};
-
-export type CreateAgentRequestTools = {
-  /**
-   * The id of the resource
-   */
-  id: string;
-  /**
-   * Optional tool key for custom tools
-   */
-  key?: string | undefined;
-  actionType: string;
-  displayName?: string | undefined;
-  /**
-   * Optional tool description
-   */
-  description?: string | undefined;
-  /**
-   * Static tool configuration set at design time. Merged over LLM-provided arguments at execution time.
-   */
-  configuration?: { [k: string]: any } | undefined;
-  requiresApproval: boolean;
-  /**
-   * Nested tool ID for MCP tools (identifies specific tool within MCP server)
-   */
-  toolId?: string | undefined;
-  conditions?: Array<Conditions> | undefined;
-  /**
-   * Tool execution timeout in seconds (default: 2 minutes, max: 10 minutes)
-   */
-  timeout: number;
-};
-
-/**
- * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
- */
-export const CreateAgentRequestAgentsResponseExecuteOn = {
-  Input: "input",
-  Output: "output",
-} as const;
-/**
- * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
- */
-export type CreateAgentRequestAgentsResponseExecuteOn = ClosedEnum<
-  typeof CreateAgentRequestAgentsResponseExecuteOn
->;
-
-export type CreateAgentRequestEvaluators = {
-  /**
-   * Unique key or identifier of the evaluator
-   */
-  id: string;
-  /**
-   * The percentage of executions to evaluate with this evaluator (1-100). For example, a value of 50 means the evaluator will run on approximately half of the executions.
-   */
-  sampleRate: number;
-  /**
-   * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
-   */
-  executeOn: CreateAgentRequestAgentsResponseExecuteOn;
-};
-
-/**
- * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
- */
-export const CreateAgentRequestAgentsResponse201ExecuteOn = {
-  Input: "input",
-  Output: "output",
-} as const;
-/**
- * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
- */
-export type CreateAgentRequestAgentsResponse201ExecuteOn = ClosedEnum<
-  typeof CreateAgentRequestAgentsResponse201ExecuteOn
->;
-
-export type CreateAgentRequestAgentsGuardrails = {
-  /**
-   * Unique key or identifier of the evaluator
-   */
-  id: string;
-  /**
-   * The percentage of executions to evaluate with this evaluator (1-100). For example, a value of 50 means the evaluator will run on approximately half of the executions.
-   */
-  sampleRate: number;
-  /**
-   * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
-   */
-  executeOn: CreateAgentRequestAgentsResponse201ExecuteOn;
-};
-
-export type CreateAgentRequestSettings = {
-  /**
-   * Maximum iterations(llm calls) before the agent will stop executing.
-   */
-  maxIterations: number;
-  /**
-   * Maximum time (in seconds) for the agent thinking process. This does not include the time for tool calls and sub agent calls. It will be loosely enforced, the in progress LLM calls will not be terminated and the last assistant message will be returned.
-   */
-  maxExecutionTime: number;
-  /**
-   * Maximum cost in USD for the agent execution. When the accumulated cost exceeds this limit, the agent will stop executing. Set to 0 for unlimited. Only supported in v3 responses
-   */
-  maxCost: number;
-  /**
-   * If all, the agent will require approval for all tools. If respect_tool, the agent will require approval for tools that have the requires_approval flag set to true. If none, the agent will not require approval for any tools.
-   */
-  toolApprovalRequired: CreateAgentRequestToolApprovalRequired;
-  /**
-   * When enabled, this agent is exposed as a selectable target in AI Chat for users to consume.
-   */
-  chatExposed?: boolean | undefined;
-  tools?: Array<CreateAgentRequestTools> | undefined;
-  /**
-   * Configuration for an evaluator applied to the agent
-   */
-  evaluators?: Array<CreateAgentRequestEvaluators> | undefined;
-  /**
-   * Configuration for a guardrail applied to the agent
-   */
-  guardrails?: Array<CreateAgentRequestAgentsGuardrails> | undefined;
-};
-
-export type CreateAgentRequestResponseFormatAgentsResponseJsonSchema = {
-  /**
-   * A description of what the response format is for, used by the model to determine how to respond in the format.
-   */
-  description?: string | undefined;
-  /**
-   * The name of the response format. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64.
-   */
-  name: string;
-  /**
-   * The schema for the response format, described as a JSON Schema object.
-   */
-  schema?: any | undefined;
-  /**
-   * Whether to enable strict schema adherence when generating the output. If set to true, the model will always follow the exact schema defined in the schema field. Only a subset of JSON Schema is supported when strict is true.
-   */
-  strict: boolean;
-};
-
-/**
- * @remarks
- *
- * JSON Schema response format. Used to generate structured JSON responses
+ * @remarks
+ *
+ * JSON Schema response format. Used to generate structured JSON responses
  */
 export type CreateAgentRequestResponseFormatAgentsResponse201JSONSchema = {
   type: "json_schema";
@@ -2095,6 +1551,7 @@ export type CreateAgentRequestModalities = ClosedEnum<
  */
 export const CreateAgentRequestIdAgents1 = {
   OrqPiiDetection: "orq_pii_detection",
+  OrqSecretDetection: "orq_secret_detection",
   OrqSexualModeration: "orq_sexual_moderation",
   OrqHarmfulModeration: "orq_harmful_moderation",
 } as const;
@@ -2570,6 +2027,7 @@ export type CreateAgentRequestFallbackModelConfigurationModalities = ClosedEnum<
  */
 export const CreateAgentRequestIdAgentsResponse1 = {
   OrqPiiDetection: "orq_pii_detection",
+  OrqSecretDetection: "orq_secret_detection",
   OrqSexualModeration: "orq_sexual_moderation",
   OrqHarmfulModeration: "orq_harmful_moderation",
 } as const;
@@ -2993,7 +2451,7 @@ export type CreateAgentRequestResponseBody = {
   /**
    * List of skills that the agent can utilize. This field allows you to specify which skills the agent has access to, enabling more complex and dynamic behavior.
    */
-  skills: Array<string>;
+  skills?: Array<string> | undefined;
   metrics?: Metrics | undefined;
   /**
    * Extracted variables from agent instructions
@@ -3052,1115 +2510,369 @@ export type JSONSchema$Outbound = {
 };
 
 /** @internal */
-export const JSONSchema$outboundSchema: z.ZodType<
-  JSONSchema$Outbound,
-  z.ZodTypeDef,
-  JSONSchema
-> = z.object({
-  type: z.literal("json_schema"),
-  jsonSchema: z.lazy(() => ResponseFormatJsonSchema$outboundSchema),
-}).transform((v) => {
-  return remap$(v, {
-    jsonSchema: "json_schema",
-  });
-});
-
-export function jsonSchemaToJSON(jsonSchema: JSONSchema): string {
-  return JSON.stringify(JSONSchema$outboundSchema.parse(jsonSchema));
-}
-
-/** @internal */
-export type JSONObject$Outbound = {
-  type: "json_object";
-};
-
-/** @internal */
-export const JSONObject$outboundSchema: z.ZodType<
-  JSONObject$Outbound,
-  z.ZodTypeDef,
-  JSONObject
-> = z.object({
-  type: z.literal("json_object"),
-});
-
-export function jsonObjectToJSON(jsonObject: JSONObject): string {
-  return JSON.stringify(JSONObject$outboundSchema.parse(jsonObject));
-}
-
-/** @internal */
-export type Text$Outbound = {
-  type: "text";
-};
-
-/** @internal */
-export const Text$outboundSchema: z.ZodType<Text$Outbound, z.ZodTypeDef, Text> =
-  z.object({
-    type: z.literal("text"),
-  });
-
-export function textToJSON(text: Text): string {
-  return JSON.stringify(Text$outboundSchema.parse(text));
-}
-
-/** @internal */
-export type ResponseFormat$Outbound =
-  | Text$Outbound
-  | JSONObject$Outbound
-  | JSONSchema$Outbound;
-
-/** @internal */
-export const ResponseFormat$outboundSchema: z.ZodType<
-  ResponseFormat$Outbound,
-  z.ZodTypeDef,
-  ResponseFormat
-> = z.union([
-  z.lazy(() => Text$outboundSchema),
-  z.lazy(() => JSONObject$outboundSchema),
-  z.lazy(() => JSONSchema$outboundSchema),
-]);
-
-export function responseFormatToJSON(responseFormat: ResponseFormat): string {
-  return JSON.stringify(ResponseFormat$outboundSchema.parse(responseFormat));
-}
-
-/** @internal */
-export const ReasoningEffort$outboundSchema: z.ZodNativeEnum<
-  typeof ReasoningEffort
-> = z.nativeEnum(ReasoningEffort);
-
-/** @internal */
-export type Stop$Outbound = string | Array<string>;
-
-/** @internal */
-export const Stop$outboundSchema: z.ZodType<Stop$Outbound, z.ZodTypeDef, Stop> =
-  z.union([z.string(), z.array(z.string())]);
-
-export function stopToJSON(stop: Stop): string {
-  return JSON.stringify(Stop$outboundSchema.parse(stop));
-}
-
-/** @internal */
-export type Thinking$Outbound =
-  | components.ThinkingConfigDisabledSchema$Outbound
-  | components.ThinkingConfigEnabledSchema$Outbound
-  | components.ThinkingConfigAdaptiveSchema$Outbound;
-
-/** @internal */
-export const Thinking$outboundSchema: z.ZodType<
-  Thinking$Outbound,
-  z.ZodTypeDef,
-  Thinking
-> = z.union([
-  components.ThinkingConfigDisabledSchema$outboundSchema,
-  components.ThinkingConfigEnabledSchema$outboundSchema,
-  components.ThinkingConfigAdaptiveSchema$outboundSchema,
-]);
-
-export function thinkingToJSON(thinking: Thinking): string {
-  return JSON.stringify(Thinking$outboundSchema.parse(thinking));
-}
-
-/** @internal */
-export const ToolChoiceType$outboundSchema: z.ZodNativeEnum<
-  typeof ToolChoiceType
-> = z.nativeEnum(ToolChoiceType);
-
-/** @internal */
-export type ToolChoiceFunction$Outbound = {
-  name: string;
-};
-
-/** @internal */
-export const ToolChoiceFunction$outboundSchema: z.ZodType<
-  ToolChoiceFunction$Outbound,
-  z.ZodTypeDef,
-  ToolChoiceFunction
-> = z.object({
-  name: z.string(),
-});
-
-export function toolChoiceFunctionToJSON(
-  toolChoiceFunction: ToolChoiceFunction,
-): string {
-  return JSON.stringify(
-    ToolChoiceFunction$outboundSchema.parse(toolChoiceFunction),
-  );
-}
-
-/** @internal */
-export type ToolChoice2$Outbound = {
-  type?: string | undefined;
-  function: ToolChoiceFunction$Outbound;
-};
-
-/** @internal */
-export const ToolChoice2$outboundSchema: z.ZodType<
-  ToolChoice2$Outbound,
-  z.ZodTypeDef,
-  ToolChoice2
-> = z.object({
-  type: ToolChoiceType$outboundSchema.optional(),
-  function: z.lazy(() => ToolChoiceFunction$outboundSchema),
-});
-
-export function toolChoice2ToJSON(toolChoice2: ToolChoice2): string {
-  return JSON.stringify(ToolChoice2$outboundSchema.parse(toolChoice2));
-}
-
-/** @internal */
-export const ToolChoice1$outboundSchema: z.ZodNativeEnum<typeof ToolChoice1> = z
-  .nativeEnum(ToolChoice1);
-
-/** @internal */
-export type ToolChoice$Outbound = ToolChoice2$Outbound | string;
-
-/** @internal */
-export const ToolChoice$outboundSchema: z.ZodType<
-  ToolChoice$Outbound,
-  z.ZodTypeDef,
-  ToolChoice
-> = z.union([
-  z.lazy(() => ToolChoice2$outboundSchema),
-  ToolChoice1$outboundSchema,
-]);
-
-export function toolChoiceToJSON(toolChoice: ToolChoice): string {
-  return JSON.stringify(ToolChoice$outboundSchema.parse(toolChoice));
-}
-
-/** @internal */
-export const Modalities$outboundSchema: z.ZodNativeEnum<typeof Modalities> = z
-  .nativeEnum(Modalities);
-
-/** @internal */
-export const Id1$outboundSchema: z.ZodNativeEnum<typeof Id1> = z.nativeEnum(
-  Id1,
-);
-
-/** @internal */
-export type Id$Outbound = string | string;
-
-/** @internal */
-export const Id$outboundSchema: z.ZodType<Id$Outbound, z.ZodTypeDef, Id> = z
-  .union([Id1$outboundSchema, z.string()]);
-
-export function idToJSON(id: Id): string {
-  return JSON.stringify(Id$outboundSchema.parse(id));
-}
-
-/** @internal */
-export const ExecuteOn$outboundSchema: z.ZodNativeEnum<typeof ExecuteOn> = z
-  .nativeEnum(ExecuteOn);
-
-/** @internal */
-export type Guardrails$Outbound = {
-  id: string | string;
-  execute_on: string;
-};
-
-/** @internal */
-export const Guardrails$outboundSchema: z.ZodType<
-  Guardrails$Outbound,
-  z.ZodTypeDef,
-  Guardrails
-> = z.object({
-  id: z.union([Id1$outboundSchema, z.string()]),
-  executeOn: ExecuteOn$outboundSchema,
-}).transform((v) => {
-  return remap$(v, {
-    executeOn: "execute_on",
-  });
-});
-
-export function guardrailsToJSON(guardrails: Guardrails): string {
-  return JSON.stringify(Guardrails$outboundSchema.parse(guardrails));
-}
-
-/** @internal */
-export type Plugins$Outbound =
-  | components.PIIRedactionPluginEn$Outbound
-  | components.PIIRedactionPluginNl$Outbound
-  | components.PIIRedactionPluginAuto$Outbound;
-
-/** @internal */
-export const Plugins$outboundSchema: z.ZodType<
-  Plugins$Outbound,
-  z.ZodTypeDef,
-  Plugins
-> = z.union([
-  components.PIIRedactionPluginEn$outboundSchema,
-  components.PIIRedactionPluginNl$outboundSchema,
-  components.PIIRedactionPluginAuto$outboundSchema,
-]);
-
-export function pluginsToJSON(plugins: Plugins): string {
-  return JSON.stringify(Plugins$outboundSchema.parse(plugins));
-}
-
-/** @internal */
-export type ModelConfigurationFallbacks$Outbound = {
-  model: string;
-};
-
-/** @internal */
-export const ModelConfigurationFallbacks$outboundSchema: z.ZodType<
-  ModelConfigurationFallbacks$Outbound,
-  z.ZodTypeDef,
-  ModelConfigurationFallbacks
-> = z.object({
-  model: z.string(),
-});
-
-export function modelConfigurationFallbacksToJSON(
-  modelConfigurationFallbacks: ModelConfigurationFallbacks,
-): string {
-  return JSON.stringify(
-    ModelConfigurationFallbacks$outboundSchema.parse(
-      modelConfigurationFallbacks,
-    ),
-  );
-}
-
-/** @internal */
-export const ModelConfigurationType$outboundSchema: z.ZodNativeEnum<
-  typeof ModelConfigurationType
-> = z.nativeEnum(ModelConfigurationType);
-
-/** @internal */
-export type Cache$Outbound = {
-  ttl: number;
-  type: string;
-};
-
-/** @internal */
-export const Cache$outboundSchema: z.ZodType<
-  Cache$Outbound,
-  z.ZodTypeDef,
-  Cache
-> = z.object({
-  ttl: z.number().default(1800),
-  type: ModelConfigurationType$outboundSchema,
-});
-
-export function cacheToJSON(cache: Cache): string {
-  return JSON.stringify(Cache$outboundSchema.parse(cache));
-}
-
-/** @internal */
-export const LoadBalancerType$outboundSchema: z.ZodNativeEnum<
-  typeof LoadBalancerType
-> = z.nativeEnum(LoadBalancerType);
-
-/** @internal */
-export type Models$Outbound = {
-  model: string;
-  weight: number;
-};
-
-/** @internal */
-export const Models$outboundSchema: z.ZodType<
-  Models$Outbound,
-  z.ZodTypeDef,
-  Models
-> = z.object({
-  model: z.string(),
-  weight: z.number().default(0.5),
-});
-
-export function modelsToJSON(models: Models): string {
-  return JSON.stringify(Models$outboundSchema.parse(models));
-}
-
-/** @internal */
-export type LoadBalancer1$Outbound = {
-  type: string;
-  models: Array<Models$Outbound>;
-};
-
-/** @internal */
-export const LoadBalancer1$outboundSchema: z.ZodType<
-  LoadBalancer1$Outbound,
-  z.ZodTypeDef,
-  LoadBalancer1
-> = z.object({
-  type: LoadBalancerType$outboundSchema,
-  models: z.array(z.lazy(() => Models$outboundSchema)),
-});
-
-export function loadBalancer1ToJSON(loadBalancer1: LoadBalancer1): string {
-  return JSON.stringify(LoadBalancer1$outboundSchema.parse(loadBalancer1));
-}
-
-/** @internal */
-export type LoadBalancer$Outbound = LoadBalancer1$Outbound;
-
-/** @internal */
-export const LoadBalancer$outboundSchema: z.ZodType<
-  LoadBalancer$Outbound,
-  z.ZodTypeDef,
-  LoadBalancer
-> = z.lazy(() => LoadBalancer1$outboundSchema);
-
-export function loadBalancerToJSON(loadBalancer: LoadBalancer): string {
-  return JSON.stringify(LoadBalancer$outboundSchema.parse(loadBalancer));
-}
-
-/** @internal */
-export type Timeout$Outbound = {
-  call_timeout: number;
-};
-
-/** @internal */
-export const Timeout$outboundSchema: z.ZodType<
-  Timeout$Outbound,
-  z.ZodTypeDef,
-  Timeout
-> = z.object({
-  callTimeout: z.number(),
-}).transform((v) => {
-  return remap$(v, {
-    callTimeout: "call_timeout",
-  });
-});
-
-export function timeoutToJSON(timeout: Timeout): string {
-  return JSON.stringify(Timeout$outboundSchema.parse(timeout));
-}
-
-/** @internal */
-export const CreateAgentRequestModelConfigurationType$outboundSchema:
-  z.ZodNativeEnum<typeof CreateAgentRequestModelConfigurationType> = z
-    .nativeEnum(CreateAgentRequestModelConfigurationType);
-
-/** @internal */
-export const ModelConfigurationTtl$outboundSchema: z.ZodNativeEnum<
-  typeof ModelConfigurationTtl
-> = z.nativeEnum(ModelConfigurationTtl);
-
-/** @internal */
-export type ModelConfigurationCacheControl$Outbound = {
-  type: string;
-  ttl: string;
-};
-
-/** @internal */
-export const ModelConfigurationCacheControl$outboundSchema: z.ZodType<
-  ModelConfigurationCacheControl$Outbound,
-  z.ZodTypeDef,
-  ModelConfigurationCacheControl
-> = z.object({
-  type: CreateAgentRequestModelConfigurationType$outboundSchema,
-  ttl: ModelConfigurationTtl$outboundSchema.default("5m"),
-});
-
-export function modelConfigurationCacheControlToJSON(
-  modelConfigurationCacheControl: ModelConfigurationCacheControl,
-): string {
-  return JSON.stringify(
-    ModelConfigurationCacheControl$outboundSchema.parse(
-      modelConfigurationCacheControl,
-    ),
-  );
-}
-
-/** @internal */
-export type ParametersT$Outbound = {
-  name?: string | undefined;
-  frequency_penalty?: number | null | undefined;
-  max_tokens?: number | null | undefined;
-  max_completion_tokens?: number | null | undefined;
-  presence_penalty?: number | null | undefined;
-  response_format?:
-    | Text$Outbound
-    | JSONObject$Outbound
-    | JSONSchema$Outbound
-    | undefined;
-  reasoning_effort?: string | undefined;
-  verbosity?: string | undefined;
-  seed?: number | null | undefined;
-  stop?: string | Array<string> | null | undefined;
-  thinking?:
-    | components.ThinkingConfigDisabledSchema$Outbound
-    | components.ThinkingConfigEnabledSchema$Outbound
-    | components.ThinkingConfigAdaptiveSchema$Outbound
-    | undefined;
-  temperature?: number | null | undefined;
-  top_p?: number | null | undefined;
-  top_k?: number | null | undefined;
-  tool_choice?: ToolChoice2$Outbound | string | undefined;
-  parallel_tool_calls?: boolean | undefined;
-  modalities?: Array<string> | null | undefined;
-  guardrails?: Array<Guardrails$Outbound> | undefined;
-  plugins?:
-    | Array<
-      | components.PIIRedactionPluginEn$Outbound
-      | components.PIIRedactionPluginNl$Outbound
-      | components.PIIRedactionPluginAuto$Outbound
-    >
-    | undefined;
-  fallbacks?: Array<ModelConfigurationFallbacks$Outbound> | undefined;
-  cache?: Cache$Outbound | undefined;
-  load_balancer?: LoadBalancer1$Outbound | undefined;
-  timeout?: Timeout$Outbound | undefined;
-  cache_control?: ModelConfigurationCacheControl$Outbound | undefined;
-  prompt_cache_key?: string | undefined;
-};
-
-/** @internal */
-export const ParametersT$outboundSchema: z.ZodType<
-  ParametersT$Outbound,
-  z.ZodTypeDef,
-  ParametersT
-> = z.object({
-  name: z.string().optional(),
-  frequencyPenalty: z.nullable(z.number()).optional(),
-  maxTokens: z.nullable(z.number().int()).optional(),
-  maxCompletionTokens: z.nullable(z.number().int()).optional(),
-  presencePenalty: z.nullable(z.number()).optional(),
-  responseFormat: z.union([
-    z.lazy(() => Text$outboundSchema),
-    z.lazy(() => JSONObject$outboundSchema),
-    z.lazy(() => JSONSchema$outboundSchema),
-  ]).optional(),
-  reasoningEffort: ReasoningEffort$outboundSchema.optional(),
-  verbosity: z.string().optional(),
-  seed: z.nullable(z.number()).optional(),
-  stop: z.nullable(z.union([z.string(), z.array(z.string())])).optional(),
-  thinking: z.union([
-    components.ThinkingConfigDisabledSchema$outboundSchema,
-    components.ThinkingConfigEnabledSchema$outboundSchema,
-    components.ThinkingConfigAdaptiveSchema$outboundSchema,
-  ]).optional(),
-  temperature: z.nullable(z.number()).optional(),
-  topP: z.nullable(z.number()).optional(),
-  topK: z.nullable(z.number()).optional(),
-  toolChoice: z.union([
-    z.lazy(() => ToolChoice2$outboundSchema),
-    ToolChoice1$outboundSchema,
-  ]).optional(),
-  parallelToolCalls: z.boolean().optional(),
-  modalities: z.nullable(z.array(Modalities$outboundSchema)).optional(),
-  guardrails: z.array(z.lazy(() => Guardrails$outboundSchema)).optional(),
-  plugins: z.array(
-    z.union([
-      components.PIIRedactionPluginEn$outboundSchema,
-      components.PIIRedactionPluginNl$outboundSchema,
-      components.PIIRedactionPluginAuto$outboundSchema,
-    ]),
-  ).optional(),
-  fallbacks: z.array(z.lazy(() => ModelConfigurationFallbacks$outboundSchema))
-    .optional(),
-  cache: z.lazy(() => Cache$outboundSchema).optional(),
-  loadBalancer: z.lazy(() => LoadBalancer1$outboundSchema).optional(),
-  timeout: z.lazy(() => Timeout$outboundSchema).optional(),
-  cacheControl: z.lazy(() => ModelConfigurationCacheControl$outboundSchema)
-    .optional(),
-  promptCacheKey: z.string().optional(),
-}).transform((v) => {
-  return remap$(v, {
-    frequencyPenalty: "frequency_penalty",
-    maxTokens: "max_tokens",
-    maxCompletionTokens: "max_completion_tokens",
-    presencePenalty: "presence_penalty",
-    responseFormat: "response_format",
-    reasoningEffort: "reasoning_effort",
-    topP: "top_p",
-    topK: "top_k",
-    toolChoice: "tool_choice",
-    parallelToolCalls: "parallel_tool_calls",
-    loadBalancer: "load_balancer",
-    cacheControl: "cache_control",
-    promptCacheKey: "prompt_cache_key",
-  });
-});
-
-export function parametersToJSON(parametersT: ParametersT): string {
-  return JSON.stringify(ParametersT$outboundSchema.parse(parametersT));
-}
-
-/** @internal */
-export type ModelConfigurationRetry$Outbound = {
-  count: number;
-  on_codes?: Array<number> | undefined;
-};
-
-/** @internal */
-export const ModelConfigurationRetry$outboundSchema: z.ZodType<
-  ModelConfigurationRetry$Outbound,
-  z.ZodTypeDef,
-  ModelConfigurationRetry
-> = z.object({
-  count: z.number().default(3),
-  onCodes: z.array(z.number()).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    onCodes: "on_codes",
-  });
-});
-
-export function modelConfigurationRetryToJSON(
-  modelConfigurationRetry: ModelConfigurationRetry,
-): string {
-  return JSON.stringify(
-    ModelConfigurationRetry$outboundSchema.parse(modelConfigurationRetry),
-  );
-}
-
-/** @internal */
-export type ModelConfiguration2$Outbound = {
-  id: string;
-  parameters?: ParametersT$Outbound | undefined;
-  retry?: ModelConfigurationRetry$Outbound | undefined;
-};
-
-/** @internal */
-export const ModelConfiguration2$outboundSchema: z.ZodType<
-  ModelConfiguration2$Outbound,
-  z.ZodTypeDef,
-  ModelConfiguration2
-> = z.object({
-  id: z.string(),
-  parameters: z.lazy(() => ParametersT$outboundSchema).optional(),
-  retry: z.lazy(() => ModelConfigurationRetry$outboundSchema).optional(),
-});
-
-export function modelConfiguration2ToJSON(
-  modelConfiguration2: ModelConfiguration2,
-): string {
-  return JSON.stringify(
-    ModelConfiguration2$outboundSchema.parse(modelConfiguration2),
-  );
-}
-
-/** @internal */
-export type ModelConfiguration$Outbound = ModelConfiguration2$Outbound | string;
-
-/** @internal */
-export const ModelConfiguration$outboundSchema: z.ZodType<
-  ModelConfiguration$Outbound,
-  z.ZodTypeDef,
-  ModelConfiguration
-> = z.union([z.lazy(() => ModelConfiguration2$outboundSchema), z.string()]);
-
-export function modelConfigurationToJSON(
-  modelConfiguration: ModelConfiguration,
-): string {
-  return JSON.stringify(
-    ModelConfiguration$outboundSchema.parse(modelConfiguration),
-  );
-}
-
-/** @internal */
-export type CreateAgentRequestResponseFormatAgentsJsonSchema$Outbound = {
-  description?: string | undefined;
-  name: string;
-  schema?: any | undefined;
-  strict: boolean;
-};
-
-/** @internal */
-export const CreateAgentRequestResponseFormatAgentsJsonSchema$outboundSchema:
-  z.ZodType<
-    CreateAgentRequestResponseFormatAgentsJsonSchema$Outbound,
-    z.ZodTypeDef,
-    CreateAgentRequestResponseFormatAgentsJsonSchema
-  > = z.object({
-    description: z.string().optional(),
-    name: z.string(),
-    schema: z.any().optional(),
-    strict: z.boolean().default(false),
-  });
-
-export function createAgentRequestResponseFormatAgentsJsonSchemaToJSON(
-  createAgentRequestResponseFormatAgentsJsonSchema:
-    CreateAgentRequestResponseFormatAgentsJsonSchema,
-): string {
-  return JSON.stringify(
-    CreateAgentRequestResponseFormatAgentsJsonSchema$outboundSchema.parse(
-      createAgentRequestResponseFormatAgentsJsonSchema,
-    ),
-  );
-}
-
-/** @internal */
-export type CreateAgentRequestResponseFormatJSONSchema$Outbound = {
-  type: "json_schema";
-  json_schema: CreateAgentRequestResponseFormatAgentsJsonSchema$Outbound;
-};
-
-/** @internal */
-export const CreateAgentRequestResponseFormatJSONSchema$outboundSchema:
-  z.ZodType<
-    CreateAgentRequestResponseFormatJSONSchema$Outbound,
-    z.ZodTypeDef,
-    CreateAgentRequestResponseFormatJSONSchema
-  > = z.object({
-    type: z.literal("json_schema"),
-    jsonSchema: z.lazy(() =>
-      CreateAgentRequestResponseFormatAgentsJsonSchema$outboundSchema
-    ),
-  }).transform((v) => {
-    return remap$(v, {
-      jsonSchema: "json_schema",
-    });
+export const JSONSchema$outboundSchema: z.ZodType<
+  JSONSchema$Outbound,
+  z.ZodTypeDef,
+  JSONSchema
+> = z.object({
+  type: z.literal("json_schema"),
+  jsonSchema: z.lazy(() => ResponseFormatJsonSchema$outboundSchema),
+}).transform((v) => {
+  return remap$(v, {
+    jsonSchema: "json_schema",
   });
+});
 
-export function createAgentRequestResponseFormatJSONSchemaToJSON(
-  createAgentRequestResponseFormatJSONSchema:
-    CreateAgentRequestResponseFormatJSONSchema,
-): string {
-  return JSON.stringify(
-    CreateAgentRequestResponseFormatJSONSchema$outboundSchema.parse(
-      createAgentRequestResponseFormatJSONSchema,
-    ),
-  );
+export function jsonSchemaToJSON(jsonSchema: JSONSchema): string {
+  return JSON.stringify(JSONSchema$outboundSchema.parse(jsonSchema));
 }
 
 /** @internal */
-export type ResponseFormatJSONObject$Outbound = {
+export type JSONObject$Outbound = {
   type: "json_object";
 };
 
 /** @internal */
-export const ResponseFormatJSONObject$outboundSchema: z.ZodType<
-  ResponseFormatJSONObject$Outbound,
+export const JSONObject$outboundSchema: z.ZodType<
+  JSONObject$Outbound,
   z.ZodTypeDef,
-  ResponseFormatJSONObject
+  JSONObject
 > = z.object({
   type: z.literal("json_object"),
 });
 
-export function responseFormatJSONObjectToJSON(
-  responseFormatJSONObject: ResponseFormatJSONObject,
-): string {
-  return JSON.stringify(
-    ResponseFormatJSONObject$outboundSchema.parse(responseFormatJSONObject),
-  );
+export function jsonObjectToJSON(jsonObject: JSONObject): string {
+  return JSON.stringify(JSONObject$outboundSchema.parse(jsonObject));
 }
 
 /** @internal */
-export type ResponseFormatText$Outbound = {
+export type Text$Outbound = {
   type: "text";
 };
 
 /** @internal */
-export const ResponseFormatText$outboundSchema: z.ZodType<
-  ResponseFormatText$Outbound,
-  z.ZodTypeDef,
-  ResponseFormatText
-> = z.object({
-  type: z.literal("text"),
-});
+export const Text$outboundSchema: z.ZodType<Text$Outbound, z.ZodTypeDef, Text> =
+  z.object({
+    type: z.literal("text"),
+  });
 
-export function responseFormatTextToJSON(
-  responseFormatText: ResponseFormatText,
-): string {
-  return JSON.stringify(
-    ResponseFormatText$outboundSchema.parse(responseFormatText),
-  );
+export function textToJSON(text: Text): string {
+  return JSON.stringify(Text$outboundSchema.parse(text));
 }
 
 /** @internal */
-export type FallbackModelConfigurationResponseFormat$Outbound =
-  | ResponseFormatText$Outbound
-  | ResponseFormatJSONObject$Outbound
-  | CreateAgentRequestResponseFormatJSONSchema$Outbound;
+export type ResponseFormat$Outbound =
+  | Text$Outbound
+  | JSONObject$Outbound
+  | JSONSchema$Outbound;
 
 /** @internal */
-export const FallbackModelConfigurationResponseFormat$outboundSchema: z.ZodType<
-  FallbackModelConfigurationResponseFormat$Outbound,
+export const ResponseFormat$outboundSchema: z.ZodType<
+  ResponseFormat$Outbound,
   z.ZodTypeDef,
-  FallbackModelConfigurationResponseFormat
+  ResponseFormat
 > = z.union([
-  z.lazy(() => ResponseFormatText$outboundSchema),
-  z.lazy(() => ResponseFormatJSONObject$outboundSchema),
-  z.lazy(() => CreateAgentRequestResponseFormatJSONSchema$outboundSchema),
+  z.lazy(() => Text$outboundSchema),
+  z.lazy(() => JSONObject$outboundSchema),
+  z.lazy(() => JSONSchema$outboundSchema),
 ]);
 
-export function fallbackModelConfigurationResponseFormatToJSON(
-  fallbackModelConfigurationResponseFormat:
-    FallbackModelConfigurationResponseFormat,
-): string {
-  return JSON.stringify(
-    FallbackModelConfigurationResponseFormat$outboundSchema.parse(
-      fallbackModelConfigurationResponseFormat,
-    ),
-  );
+export function responseFormatToJSON(responseFormat: ResponseFormat): string {
+  return JSON.stringify(ResponseFormat$outboundSchema.parse(responseFormat));
 }
 
 /** @internal */
-export const FallbackModelConfigurationReasoningEffort$outboundSchema:
-  z.ZodNativeEnum<typeof FallbackModelConfigurationReasoningEffort> = z
-    .nativeEnum(FallbackModelConfigurationReasoningEffort);
+export const ReasoningEffort$outboundSchema: z.ZodNativeEnum<
+  typeof ReasoningEffort
+> = z.nativeEnum(ReasoningEffort);
 
 /** @internal */
-export type FallbackModelConfigurationStop$Outbound = string | Array<string>;
+export type Stop$Outbound = string | Array<string>;
 
 /** @internal */
-export const FallbackModelConfigurationStop$outboundSchema: z.ZodType<
-  FallbackModelConfigurationStop$Outbound,
-  z.ZodTypeDef,
-  FallbackModelConfigurationStop
-> = z.union([z.string(), z.array(z.string())]);
+export const Stop$outboundSchema: z.ZodType<Stop$Outbound, z.ZodTypeDef, Stop> =
+  z.union([z.string(), z.array(z.string())]);
 
-export function fallbackModelConfigurationStopToJSON(
-  fallbackModelConfigurationStop: FallbackModelConfigurationStop,
-): string {
-  return JSON.stringify(
-    FallbackModelConfigurationStop$outboundSchema.parse(
-      fallbackModelConfigurationStop,
-    ),
-  );
+export function stopToJSON(stop: Stop): string {
+  return JSON.stringify(Stop$outboundSchema.parse(stop));
 }
 
 /** @internal */
-export type FallbackModelConfigurationThinking$Outbound =
+export type Thinking$Outbound =
   | components.ThinkingConfigDisabledSchema$Outbound
   | components.ThinkingConfigEnabledSchema$Outbound
   | components.ThinkingConfigAdaptiveSchema$Outbound;
 
 /** @internal */
-export const FallbackModelConfigurationThinking$outboundSchema: z.ZodType<
-  FallbackModelConfigurationThinking$Outbound,
+export const Thinking$outboundSchema: z.ZodType<
+  Thinking$Outbound,
   z.ZodTypeDef,
-  FallbackModelConfigurationThinking
+  Thinking
 > = z.union([
   components.ThinkingConfigDisabledSchema$outboundSchema,
   components.ThinkingConfigEnabledSchema$outboundSchema,
   components.ThinkingConfigAdaptiveSchema$outboundSchema,
 ]);
 
-export function fallbackModelConfigurationThinkingToJSON(
-  fallbackModelConfigurationThinking: FallbackModelConfigurationThinking,
-): string {
-  return JSON.stringify(
-    FallbackModelConfigurationThinking$outboundSchema.parse(
-      fallbackModelConfigurationThinking,
-    ),
-  );
+export function thinkingToJSON(thinking: Thinking): string {
+  return JSON.stringify(Thinking$outboundSchema.parse(thinking));
 }
 
 /** @internal */
-export const CreateAgentRequestToolChoiceType$outboundSchema: z.ZodNativeEnum<
-  typeof CreateAgentRequestToolChoiceType
-> = z.nativeEnum(CreateAgentRequestToolChoiceType);
+export const ToolChoiceType$outboundSchema: z.ZodNativeEnum<
+  typeof ToolChoiceType
+> = z.nativeEnum(ToolChoiceType);
 
 /** @internal */
-export type CreateAgentRequestToolChoiceFunction$Outbound = {
+export type ToolChoiceFunction$Outbound = {
   name: string;
 };
 
 /** @internal */
-export const CreateAgentRequestToolChoiceFunction$outboundSchema: z.ZodType<
-  CreateAgentRequestToolChoiceFunction$Outbound,
+export const ToolChoiceFunction$outboundSchema: z.ZodType<
+  ToolChoiceFunction$Outbound,
   z.ZodTypeDef,
-  CreateAgentRequestToolChoiceFunction
+  ToolChoiceFunction
 > = z.object({
   name: z.string(),
 });
 
-export function createAgentRequestToolChoiceFunctionToJSON(
-  createAgentRequestToolChoiceFunction: CreateAgentRequestToolChoiceFunction,
+export function toolChoiceFunctionToJSON(
+  toolChoiceFunction: ToolChoiceFunction,
 ): string {
   return JSON.stringify(
-    CreateAgentRequestToolChoiceFunction$outboundSchema.parse(
-      createAgentRequestToolChoiceFunction,
-    ),
+    ToolChoiceFunction$outboundSchema.parse(toolChoiceFunction),
   );
 }
 
 /** @internal */
-export type CreateAgentRequestToolChoice2$Outbound = {
+export type ToolChoice2$Outbound = {
   type?: string | undefined;
-  function: CreateAgentRequestToolChoiceFunction$Outbound;
+  function: ToolChoiceFunction$Outbound;
 };
 
 /** @internal */
-export const CreateAgentRequestToolChoice2$outboundSchema: z.ZodType<
-  CreateAgentRequestToolChoice2$Outbound,
+export const ToolChoice2$outboundSchema: z.ZodType<
+  ToolChoice2$Outbound,
   z.ZodTypeDef,
-  CreateAgentRequestToolChoice2
+  ToolChoice2
 > = z.object({
-  type: CreateAgentRequestToolChoiceType$outboundSchema.optional(),
-  function: z.lazy(() => CreateAgentRequestToolChoiceFunction$outboundSchema),
+  type: ToolChoiceType$outboundSchema.optional(),
+  function: z.lazy(() => ToolChoiceFunction$outboundSchema),
 });
 
-export function createAgentRequestToolChoice2ToJSON(
-  createAgentRequestToolChoice2: CreateAgentRequestToolChoice2,
-): string {
-  return JSON.stringify(
-    CreateAgentRequestToolChoice2$outboundSchema.parse(
-      createAgentRequestToolChoice2,
-    ),
-  );
+export function toolChoice2ToJSON(toolChoice2: ToolChoice2): string {
+  return JSON.stringify(ToolChoice2$outboundSchema.parse(toolChoice2));
 }
 
 /** @internal */
-export const CreateAgentRequestToolChoice1$outboundSchema: z.ZodNativeEnum<
-  typeof CreateAgentRequestToolChoice1
-> = z.nativeEnum(CreateAgentRequestToolChoice1);
+export const ToolChoice1$outboundSchema: z.ZodNativeEnum<typeof ToolChoice1> = z
+  .nativeEnum(ToolChoice1);
 
 /** @internal */
-export type FallbackModelConfigurationToolChoice$Outbound =
-  | CreateAgentRequestToolChoice2$Outbound
-  | string;
+export type ToolChoice$Outbound = ToolChoice2$Outbound | string;
 
 /** @internal */
-export const FallbackModelConfigurationToolChoice$outboundSchema: z.ZodType<
-  FallbackModelConfigurationToolChoice$Outbound,
+export const ToolChoice$outboundSchema: z.ZodType<
+  ToolChoice$Outbound,
   z.ZodTypeDef,
-  FallbackModelConfigurationToolChoice
+  ToolChoice
 > = z.union([
-  z.lazy(() => CreateAgentRequestToolChoice2$outboundSchema),
-  CreateAgentRequestToolChoice1$outboundSchema,
+  z.lazy(() => ToolChoice2$outboundSchema),
+  ToolChoice1$outboundSchema,
 ]);
 
-export function fallbackModelConfigurationToolChoiceToJSON(
-  fallbackModelConfigurationToolChoice: FallbackModelConfigurationToolChoice,
-): string {
-  return JSON.stringify(
-    FallbackModelConfigurationToolChoice$outboundSchema.parse(
-      fallbackModelConfigurationToolChoice,
-    ),
-  );
+export function toolChoiceToJSON(toolChoice: ToolChoice): string {
+  return JSON.stringify(ToolChoice$outboundSchema.parse(toolChoice));
 }
 
 /** @internal */
-export const FallbackModelConfigurationModalities$outboundSchema:
-  z.ZodNativeEnum<typeof FallbackModelConfigurationModalities> = z.nativeEnum(
-    FallbackModelConfigurationModalities,
-  );
+export const Modalities$outboundSchema: z.ZodNativeEnum<typeof Modalities> = z
+  .nativeEnum(Modalities);
 
 /** @internal */
-export const CreateAgentRequestId1$outboundSchema: z.ZodNativeEnum<
-  typeof CreateAgentRequestId1
-> = z.nativeEnum(CreateAgentRequestId1);
+export const Id1$outboundSchema: z.ZodNativeEnum<typeof Id1> = z.nativeEnum(
+  Id1,
+);
 
 /** @internal */
-export type FallbackModelConfigurationId$Outbound = string | string;
+export type Id$Outbound = string | string;
 
 /** @internal */
-export const FallbackModelConfigurationId$outboundSchema: z.ZodType<
-  FallbackModelConfigurationId$Outbound,
-  z.ZodTypeDef,
-  FallbackModelConfigurationId
-> = z.union([CreateAgentRequestId1$outboundSchema, z.string()]);
+export const Id$outboundSchema: z.ZodType<Id$Outbound, z.ZodTypeDef, Id> = z
+  .union([Id1$outboundSchema, z.string()]);
 
-export function fallbackModelConfigurationIdToJSON(
-  fallbackModelConfigurationId: FallbackModelConfigurationId,
-): string {
-  return JSON.stringify(
-    FallbackModelConfigurationId$outboundSchema.parse(
-      fallbackModelConfigurationId,
-    ),
-  );
+export function idToJSON(id: Id): string {
+  return JSON.stringify(Id$outboundSchema.parse(id));
 }
 
 /** @internal */
-export const FallbackModelConfigurationExecuteOn$outboundSchema:
-  z.ZodNativeEnum<typeof FallbackModelConfigurationExecuteOn> = z.nativeEnum(
-    FallbackModelConfigurationExecuteOn,
-  );
+export const ExecuteOn$outboundSchema: z.ZodNativeEnum<typeof ExecuteOn> = z
+  .nativeEnum(ExecuteOn);
 
 /** @internal */
-export type FallbackModelConfigurationGuardrails$Outbound = {
+export type Guardrails$Outbound = {
   id: string | string;
   execute_on: string;
 };
 
 /** @internal */
-export const FallbackModelConfigurationGuardrails$outboundSchema: z.ZodType<
-  FallbackModelConfigurationGuardrails$Outbound,
+export const Guardrails$outboundSchema: z.ZodType<
+  Guardrails$Outbound,
   z.ZodTypeDef,
-  FallbackModelConfigurationGuardrails
-> = z.object({
-  id: z.union([CreateAgentRequestId1$outboundSchema, z.string()]),
-  executeOn: FallbackModelConfigurationExecuteOn$outboundSchema,
+  Guardrails
+> = z.object({
+  id: z.union([Id1$outboundSchema, z.string()]),
+  executeOn: ExecuteOn$outboundSchema,
 }).transform((v) => {
   return remap$(v, {
     executeOn: "execute_on",
   });
 });
 
-export function fallbackModelConfigurationGuardrailsToJSON(
-  fallbackModelConfigurationGuardrails: FallbackModelConfigurationGuardrails,
-): string {
-  return JSON.stringify(
-    FallbackModelConfigurationGuardrails$outboundSchema.parse(
-      fallbackModelConfigurationGuardrails,
-    ),
-  );
+export function guardrailsToJSON(guardrails: Guardrails): string {
+  return JSON.stringify(Guardrails$outboundSchema.parse(guardrails));
 }
 
 /** @internal */
-export type FallbackModelConfigurationPlugins$Outbound =
+export type Plugins$Outbound =
   | components.PIIRedactionPluginEn$Outbound
   | components.PIIRedactionPluginNl$Outbound
   | components.PIIRedactionPluginAuto$Outbound;
 
 /** @internal */
-export const FallbackModelConfigurationPlugins$outboundSchema: z.ZodType<
-  FallbackModelConfigurationPlugins$Outbound,
+export const Plugins$outboundSchema: z.ZodType<
+  Plugins$Outbound,
   z.ZodTypeDef,
-  FallbackModelConfigurationPlugins
+  Plugins
 > = z.union([
   components.PIIRedactionPluginEn$outboundSchema,
   components.PIIRedactionPluginNl$outboundSchema,
   components.PIIRedactionPluginAuto$outboundSchema,
 ]);
 
-export function fallbackModelConfigurationPluginsToJSON(
-  fallbackModelConfigurationPlugins: FallbackModelConfigurationPlugins,
-): string {
-  return JSON.stringify(
-    FallbackModelConfigurationPlugins$outboundSchema.parse(
-      fallbackModelConfigurationPlugins,
-    ),
-  );
+export function pluginsToJSON(plugins: Plugins): string {
+  return JSON.stringify(Plugins$outboundSchema.parse(plugins));
 }
 
 /** @internal */
-export type FallbackModelConfigurationFallbacks$Outbound = {
+export type ModelConfigurationFallbacks$Outbound = {
   model: string;
 };
 
 /** @internal */
-export const FallbackModelConfigurationFallbacks$outboundSchema: z.ZodType<
-  FallbackModelConfigurationFallbacks$Outbound,
+export const ModelConfigurationFallbacks$outboundSchema: z.ZodType<
+  ModelConfigurationFallbacks$Outbound,
   z.ZodTypeDef,
-  FallbackModelConfigurationFallbacks
+  ModelConfigurationFallbacks
 > = z.object({
   model: z.string(),
 });
 
-export function fallbackModelConfigurationFallbacksToJSON(
-  fallbackModelConfigurationFallbacks: FallbackModelConfigurationFallbacks,
+export function modelConfigurationFallbacksToJSON(
+  modelConfigurationFallbacks: ModelConfigurationFallbacks,
 ): string {
   return JSON.stringify(
-    FallbackModelConfigurationFallbacks$outboundSchema.parse(
-      fallbackModelConfigurationFallbacks,
+    ModelConfigurationFallbacks$outboundSchema.parse(
+      modelConfigurationFallbacks,
     ),
   );
 }
 
 /** @internal */
-export const FallbackModelConfigurationType$outboundSchema: z.ZodNativeEnum<
-  typeof FallbackModelConfigurationType
-> = z.nativeEnum(FallbackModelConfigurationType);
+export const ModelConfigurationType$outboundSchema: z.ZodNativeEnum<
+  typeof ModelConfigurationType
+> = z.nativeEnum(ModelConfigurationType);
 
 /** @internal */
-export type FallbackModelConfigurationCache$Outbound = {
+export type Cache$Outbound = {
   ttl: number;
   type: string;
 };
 
 /** @internal */
-export const FallbackModelConfigurationCache$outboundSchema: z.ZodType<
-  FallbackModelConfigurationCache$Outbound,
+export const Cache$outboundSchema: z.ZodType<
+  Cache$Outbound,
   z.ZodTypeDef,
-  FallbackModelConfigurationCache
+  Cache
 > = z.object({
   ttl: z.number().default(1800),
-  type: FallbackModelConfigurationType$outboundSchema,
+  type: ModelConfigurationType$outboundSchema,
 });
 
-export function fallbackModelConfigurationCacheToJSON(
-  fallbackModelConfigurationCache: FallbackModelConfigurationCache,
-): string {
-  return JSON.stringify(
-    FallbackModelConfigurationCache$outboundSchema.parse(
-      fallbackModelConfigurationCache,
-    ),
-  );
+export function cacheToJSON(cache: Cache): string {
+  return JSON.stringify(Cache$outboundSchema.parse(cache));
 }
 
 /** @internal */
-export const CreateAgentRequestLoadBalancerType$outboundSchema: z.ZodNativeEnum<
-  typeof CreateAgentRequestLoadBalancerType
-> = z.nativeEnum(CreateAgentRequestLoadBalancerType);
+export const LoadBalancerType$outboundSchema: z.ZodNativeEnum<
+  typeof LoadBalancerType
+> = z.nativeEnum(LoadBalancerType);
 
 /** @internal */
-export type LoadBalancerModels$Outbound = {
+export type Models$Outbound = {
   model: string;
   weight: number;
 };
 
 /** @internal */
-export const LoadBalancerModels$outboundSchema: z.ZodType<
-  LoadBalancerModels$Outbound,
+export const Models$outboundSchema: z.ZodType<
+  Models$Outbound,
   z.ZodTypeDef,
-  LoadBalancerModels
+  Models
 > = z.object({
   model: z.string(),
   weight: z.number().default(0.5),
 });
 
-export function loadBalancerModelsToJSON(
-  loadBalancerModels: LoadBalancerModels,
-): string {
-  return JSON.stringify(
-    LoadBalancerModels$outboundSchema.parse(loadBalancerModels),
-  );
+export function modelsToJSON(models: Models): string {
+  return JSON.stringify(Models$outboundSchema.parse(models));
 }
 
 /** @internal */
-export type CreateAgentRequestLoadBalancer1$Outbound = {
+export type LoadBalancer1$Outbound = {
   type: string;
-  models: Array<LoadBalancerModels$Outbound>;
+  models: Array<Models$Outbound>;
 };
 
 /** @internal */
-export const CreateAgentRequestLoadBalancer1$outboundSchema: z.ZodType<
-  CreateAgentRequestLoadBalancer1$Outbound,
+export const LoadBalancer1$outboundSchema: z.ZodType<
+  LoadBalancer1$Outbound,
   z.ZodTypeDef,
-  CreateAgentRequestLoadBalancer1
+  LoadBalancer1
 > = z.object({
-  type: CreateAgentRequestLoadBalancerType$outboundSchema,
-  models: z.array(z.lazy(() => LoadBalancerModels$outboundSchema)),
+  type: LoadBalancerType$outboundSchema,
+  models: z.array(z.lazy(() => Models$outboundSchema)),
 });
 
-export function createAgentRequestLoadBalancer1ToJSON(
-  createAgentRequestLoadBalancer1: CreateAgentRequestLoadBalancer1,
-): string {
-  return JSON.stringify(
-    CreateAgentRequestLoadBalancer1$outboundSchema.parse(
-      createAgentRequestLoadBalancer1,
-    ),
-  );
+export function loadBalancer1ToJSON(loadBalancer1: LoadBalancer1): string {
+  return JSON.stringify(LoadBalancer1$outboundSchema.parse(loadBalancer1));
 }
 
 /** @internal */
-export type FallbackModelConfigurationLoadBalancer$Outbound =
-  CreateAgentRequestLoadBalancer1$Outbound;
+export type LoadBalancer$Outbound = LoadBalancer1$Outbound;
 
 /** @internal */
-export const FallbackModelConfigurationLoadBalancer$outboundSchema: z.ZodType<
-  FallbackModelConfigurationLoadBalancer$Outbound,
+export const LoadBalancer$outboundSchema: z.ZodType<
+  LoadBalancer$Outbound,
   z.ZodTypeDef,
-  FallbackModelConfigurationLoadBalancer
-> = z.lazy(() => CreateAgentRequestLoadBalancer1$outboundSchema);
+  LoadBalancer
+> = z.lazy(() => LoadBalancer1$outboundSchema);
 
-export function fallbackModelConfigurationLoadBalancerToJSON(
-  fallbackModelConfigurationLoadBalancer:
-    FallbackModelConfigurationLoadBalancer,
-): string {
-  return JSON.stringify(
-    FallbackModelConfigurationLoadBalancer$outboundSchema.parse(
-      fallbackModelConfigurationLoadBalancer,
-    ),
-  );
+export function loadBalancerToJSON(loadBalancer: LoadBalancer): string {
+  return JSON.stringify(LoadBalancer$outboundSchema.parse(loadBalancer));
 }
 
 /** @internal */
-export type FallbackModelConfigurationTimeout$Outbound = {
+export type Timeout$Outbound = {
   call_timeout: number;
 };
 
 /** @internal */
-export const FallbackModelConfigurationTimeout$outboundSchema: z.ZodType<
-  FallbackModelConfigurationTimeout$Outbound,
+export const Timeout$outboundSchema: z.ZodType<
+  Timeout$Outbound,
   z.ZodTypeDef,
-  FallbackModelConfigurationTimeout
+  Timeout
 > = z.object({
   callTimeout: z.number(),
 }).transform((v) => {
@@ -4169,64 +2881,57 @@ export const FallbackModelConfigurationTimeout$outboundSchema: z.ZodType<
   });
 });
 
-export function fallbackModelConfigurationTimeoutToJSON(
-  fallbackModelConfigurationTimeout: FallbackModelConfigurationTimeout,
-): string {
-  return JSON.stringify(
-    FallbackModelConfigurationTimeout$outboundSchema.parse(
-      fallbackModelConfigurationTimeout,
-    ),
-  );
+export function timeoutToJSON(timeout: Timeout): string {
+  return JSON.stringify(Timeout$outboundSchema.parse(timeout));
 }
 
 /** @internal */
-export const CreateAgentRequestFallbackModelConfigurationType$outboundSchema:
-  z.ZodNativeEnum<typeof CreateAgentRequestFallbackModelConfigurationType> = z
-    .nativeEnum(CreateAgentRequestFallbackModelConfigurationType);
+export const CreateAgentRequestModelConfigurationType$outboundSchema:
+  z.ZodNativeEnum<typeof CreateAgentRequestModelConfigurationType> = z
+    .nativeEnum(CreateAgentRequestModelConfigurationType);
 
 /** @internal */
-export const FallbackModelConfigurationTtl$outboundSchema: z.ZodNativeEnum<
-  typeof FallbackModelConfigurationTtl
-> = z.nativeEnum(FallbackModelConfigurationTtl);
+export const ModelConfigurationTtl$outboundSchema: z.ZodNativeEnum<
+  typeof ModelConfigurationTtl
+> = z.nativeEnum(ModelConfigurationTtl);
 
 /** @internal */
-export type FallbackModelConfigurationCacheControl$Outbound = {
+export type ModelConfigurationCacheControl$Outbound = {
   type: string;
   ttl: string;
 };
 
 /** @internal */
-export const FallbackModelConfigurationCacheControl$outboundSchema: z.ZodType<
-  FallbackModelConfigurationCacheControl$Outbound,
+export const ModelConfigurationCacheControl$outboundSchema: z.ZodType<
+  ModelConfigurationCacheControl$Outbound,
   z.ZodTypeDef,
-  FallbackModelConfigurationCacheControl
+  ModelConfigurationCacheControl
 > = z.object({
-  type: CreateAgentRequestFallbackModelConfigurationType$outboundSchema,
-  ttl: FallbackModelConfigurationTtl$outboundSchema.default("5m"),
+  type: CreateAgentRequestModelConfigurationType$outboundSchema,
+  ttl: ModelConfigurationTtl$outboundSchema.default("5m"),
 });
 
-export function fallbackModelConfigurationCacheControlToJSON(
-  fallbackModelConfigurationCacheControl:
-    FallbackModelConfigurationCacheControl,
+export function modelConfigurationCacheControlToJSON(
+  modelConfigurationCacheControl: ModelConfigurationCacheControl,
 ): string {
   return JSON.stringify(
-    FallbackModelConfigurationCacheControl$outboundSchema.parse(
-      fallbackModelConfigurationCacheControl,
+    ModelConfigurationCacheControl$outboundSchema.parse(
+      modelConfigurationCacheControl,
     ),
   );
 }
 
 /** @internal */
-export type FallbackModelConfigurationParameters$Outbound = {
+export type ParametersT$Outbound = {
   name?: string | undefined;
   frequency_penalty?: number | null | undefined;
   max_tokens?: number | null | undefined;
   max_completion_tokens?: number | null | undefined;
   presence_penalty?: number | null | undefined;
   response_format?:
-    | ResponseFormatText$Outbound
-    | ResponseFormatJSONObject$Outbound
-    | CreateAgentRequestResponseFormatJSONSchema$Outbound
+    | Text$Outbound
+    | JSONObject$Outbound
+    | JSONSchema$Outbound
     | undefined;
   reasoning_effort?: string | undefined;
   verbosity?: string | undefined;
@@ -4240,10 +2945,10 @@ export type FallbackModelConfigurationParameters$Outbound = {
   temperature?: number | null | undefined;
   top_p?: number | null | undefined;
   top_k?: number | null | undefined;
-  tool_choice?: CreateAgentRequestToolChoice2$Outbound | string | undefined;
+  tool_choice?: ToolChoice2$Outbound | string | undefined;
   parallel_tool_calls?: boolean | undefined;
   modalities?: Array<string> | null | undefined;
-  guardrails?: Array<FallbackModelConfigurationGuardrails$Outbound> | undefined;
+  guardrails?: Array<Guardrails$Outbound> | undefined;
   plugins?:
     | Array<
       | components.PIIRedactionPluginEn$Outbound
@@ -4251,19 +2956,19 @@ export type FallbackModelConfigurationParameters$Outbound = {
       | components.PIIRedactionPluginAuto$Outbound
     >
     | undefined;
-  fallbacks?: Array<FallbackModelConfigurationFallbacks$Outbound> | undefined;
-  cache?: FallbackModelConfigurationCache$Outbound | undefined;
-  load_balancer?: CreateAgentRequestLoadBalancer1$Outbound | undefined;
-  timeout?: FallbackModelConfigurationTimeout$Outbound | undefined;
-  cache_control?: FallbackModelConfigurationCacheControl$Outbound | undefined;
+  fallbacks?: Array<ModelConfigurationFallbacks$Outbound> | undefined;
+  cache?: Cache$Outbound | undefined;
+  load_balancer?: LoadBalancer1$Outbound | undefined;
+  timeout?: Timeout$Outbound | undefined;
+  cache_control?: ModelConfigurationCacheControl$Outbound | undefined;
   prompt_cache_key?: string | undefined;
 };
 
 /** @internal */
-export const FallbackModelConfigurationParameters$outboundSchema: z.ZodType<
-  FallbackModelConfigurationParameters$Outbound,
+export const ParametersT$outboundSchema: z.ZodType<
+  ParametersT$Outbound,
   z.ZodTypeDef,
-  FallbackModelConfigurationParameters
+  ParametersT
 > = z.object({
   name: z.string().optional(),
   frequencyPenalty: z.nullable(z.number()).optional(),
@@ -4271,12 +2976,11 @@ export const FallbackModelConfigurationParameters$outboundSchema: z.ZodType<
   maxCompletionTokens: z.nullable(z.number().int()).optional(),
   presencePenalty: z.nullable(z.number()).optional(),
   responseFormat: z.union([
-    z.lazy(() => ResponseFormatText$outboundSchema),
-    z.lazy(() => ResponseFormatJSONObject$outboundSchema),
-    z.lazy(() => CreateAgentRequestResponseFormatJSONSchema$outboundSchema),
+    z.lazy(() => Text$outboundSchema),
+    z.lazy(() => JSONObject$outboundSchema),
+    z.lazy(() => JSONSchema$outboundSchema),
   ]).optional(),
-  reasoningEffort: FallbackModelConfigurationReasoningEffort$outboundSchema
-    .optional(),
+  reasoningEffort: ReasoningEffort$outboundSchema.optional(),
   verbosity: z.string().optional(),
   seed: z.nullable(z.number()).optional(),
   stop: z.nullable(z.union([z.string(), z.array(z.string())])).optional(),
@@ -4289,16 +2993,12 @@ export const FallbackModelConfigurationParameters$outboundSchema: z.ZodType<
   topP: z.nullable(z.number()).optional(),
   topK: z.nullable(z.number()).optional(),
   toolChoice: z.union([
-    z.lazy(() => CreateAgentRequestToolChoice2$outboundSchema),
-    CreateAgentRequestToolChoice1$outboundSchema,
+    z.lazy(() => ToolChoice2$outboundSchema),
+    ToolChoice1$outboundSchema,
   ]).optional(),
   parallelToolCalls: z.boolean().optional(),
-  modalities: z.nullable(
-    z.array(FallbackModelConfigurationModalities$outboundSchema),
-  ).optional(),
-  guardrails: z.array(
-    z.lazy(() => FallbackModelConfigurationGuardrails$outboundSchema),
-  ).optional(),
+  modalities: z.nullable(z.array(Modalities$outboundSchema)).optional(),
+  guardrails: z.array(z.lazy(() => Guardrails$outboundSchema)).optional(),
   plugins: z.array(
     z.union([
       components.PIIRedactionPluginEn$outboundSchema,
@@ -4306,18 +3006,13 @@ export const FallbackModelConfigurationParameters$outboundSchema: z.ZodType<
       components.PIIRedactionPluginAuto$outboundSchema,
     ]),
   ).optional(),
-  fallbacks: z.array(
-    z.lazy(() => FallbackModelConfigurationFallbacks$outboundSchema),
-  ).optional(),
-  cache: z.lazy(() => FallbackModelConfigurationCache$outboundSchema)
-    .optional(),
-  loadBalancer: z.lazy(() => CreateAgentRequestLoadBalancer1$outboundSchema)
+  fallbacks: z.array(z.lazy(() => ModelConfigurationFallbacks$outboundSchema))
     .optional(),
-  timeout: z.lazy(() => FallbackModelConfigurationTimeout$outboundSchema)
+  cache: z.lazy(() => Cache$outboundSchema).optional(),
+  loadBalancer: z.lazy(() => LoadBalancer1$outboundSchema).optional(),
+  timeout: z.lazy(() => Timeout$outboundSchema).optional(),
+  cacheControl: z.lazy(() => ModelConfigurationCacheControl$outboundSchema)
     .optional(),
-  cacheControl: z.lazy(() =>
-    FallbackModelConfigurationCacheControl$outboundSchema
-  ).optional(),
   promptCacheKey: z.string().optional(),
 }).transform((v) => {
   return remap$(v, {
@@ -4337,27 +3032,21 @@ export const FallbackModelConfigurationParameters$outboundSchema: z.ZodType<
   });
 });
 
-export function fallbackModelConfigurationParametersToJSON(
-  fallbackModelConfigurationParameters: FallbackModelConfigurationParameters,
-): string {
-  return JSON.stringify(
-    FallbackModelConfigurationParameters$outboundSchema.parse(
-      fallbackModelConfigurationParameters,
-    ),
-  );
+export function parametersToJSON(parametersT: ParametersT): string {
+  return JSON.stringify(ParametersT$outboundSchema.parse(parametersT));
 }
 
 /** @internal */
-export type FallbackModelConfigurationRetry$Outbound = {
+export type ModelConfigurationRetry$Outbound = {
   count: number;
   on_codes?: Array<number> | undefined;
 };
 
 /** @internal */
-export const FallbackModelConfigurationRetry$outboundSchema: z.ZodType<
-  FallbackModelConfigurationRetry$Outbound,
+export const ModelConfigurationRetry$outboundSchema: z.ZodType<
+  ModelConfigurationRetry$Outbound,
   z.ZodTypeDef,
-  FallbackModelConfigurationRetry
+  ModelConfigurationRetry
 > = z.object({
   count: z.number().default(3),
   onCodes: z.array(z.number()).optional(),
@@ -4367,803 +3056,843 @@ export const FallbackModelConfigurationRetry$outboundSchema: z.ZodType<
   });
 });
 
-export function fallbackModelConfigurationRetryToJSON(
-  fallbackModelConfigurationRetry: FallbackModelConfigurationRetry,
+export function modelConfigurationRetryToJSON(
+  modelConfigurationRetry: ModelConfigurationRetry,
 ): string {
   return JSON.stringify(
-    FallbackModelConfigurationRetry$outboundSchema.parse(
-      fallbackModelConfigurationRetry,
-    ),
+    ModelConfigurationRetry$outboundSchema.parse(modelConfigurationRetry),
   );
 }
 
 /** @internal */
-export type FallbackModelConfiguration2$Outbound = {
+export type ModelConfiguration2$Outbound = {
   id: string;
-  parameters?: FallbackModelConfigurationParameters$Outbound | undefined;
-  retry?: FallbackModelConfigurationRetry$Outbound | undefined;
+  parameters?: ParametersT$Outbound | undefined;
+  retry?: ModelConfigurationRetry$Outbound | undefined;
 };
 
 /** @internal */
-export const FallbackModelConfiguration2$outboundSchema: z.ZodType<
-  FallbackModelConfiguration2$Outbound,
+export const ModelConfiguration2$outboundSchema: z.ZodType<
+  ModelConfiguration2$Outbound,
   z.ZodTypeDef,
-  FallbackModelConfiguration2
+  ModelConfiguration2
 > = z.object({
   id: z.string(),
-  parameters: z.lazy(() => FallbackModelConfigurationParameters$outboundSchema)
-    .optional(),
-  retry: z.lazy(() => FallbackModelConfigurationRetry$outboundSchema)
-    .optional(),
+  parameters: z.lazy(() => ParametersT$outboundSchema).optional(),
+  retry: z.lazy(() => ModelConfigurationRetry$outboundSchema).optional(),
 });
 
-export function fallbackModelConfiguration2ToJSON(
-  fallbackModelConfiguration2: FallbackModelConfiguration2,
+export function modelConfiguration2ToJSON(
+  modelConfiguration2: ModelConfiguration2,
 ): string {
   return JSON.stringify(
-    FallbackModelConfiguration2$outboundSchema.parse(
-      fallbackModelConfiguration2,
-    ),
+    ModelConfiguration2$outboundSchema.parse(modelConfiguration2),
   );
 }
 
 /** @internal */
-export type FallbackModelConfiguration$Outbound =
-  | FallbackModelConfiguration2$Outbound
-  | string;
+export type ModelConfiguration$Outbound = ModelConfiguration2$Outbound | string;
 
 /** @internal */
-export const FallbackModelConfiguration$outboundSchema: z.ZodType<
-  FallbackModelConfiguration$Outbound,
+export const ModelConfiguration$outboundSchema: z.ZodType<
+  ModelConfiguration$Outbound,
   z.ZodTypeDef,
-  FallbackModelConfiguration
-> = z.union([
-  z.lazy(() => FallbackModelConfiguration2$outboundSchema),
-  z.string(),
-]);
+  ModelConfiguration
+> = z.union([z.lazy(() => ModelConfiguration2$outboundSchema), z.string()]);
 
-export function fallbackModelConfigurationToJSON(
-  fallbackModelConfiguration: FallbackModelConfiguration,
+export function modelConfigurationToJSON(
+  modelConfiguration: ModelConfiguration,
 ): string {
   return JSON.stringify(
-    FallbackModelConfiguration$outboundSchema.parse(fallbackModelConfiguration),
+    ModelConfiguration$outboundSchema.parse(modelConfiguration),
   );
 }
 
 /** @internal */
-export const ToolApprovalRequired$outboundSchema: z.ZodNativeEnum<
-  typeof ToolApprovalRequired
-> = z.nativeEnum(ToolApprovalRequired);
+export type CreateAgentRequestResponseFormatAgentsJsonSchema$Outbound = {
+  description?: string | undefined;
+  name: string;
+  schema?: any | undefined;
+  strict: boolean;
+};
 
 /** @internal */
-export type ProviderBuiltInTool$Outbound = {
-  type: string;
-  requires_approval?: boolean | undefined;
-  configuration?: { [k: string]: any } | undefined;
+export const CreateAgentRequestResponseFormatAgentsJsonSchema$outboundSchema:
+  z.ZodType<
+    CreateAgentRequestResponseFormatAgentsJsonSchema$Outbound,
+    z.ZodTypeDef,
+    CreateAgentRequestResponseFormatAgentsJsonSchema
+  > = z.object({
+    description: z.string().optional(),
+    name: z.string(),
+    schema: z.any().optional(),
+    strict: z.boolean().default(false),
+  });
+
+export function createAgentRequestResponseFormatAgentsJsonSchemaToJSON(
+  createAgentRequestResponseFormatAgentsJsonSchema:
+    CreateAgentRequestResponseFormatAgentsJsonSchema,
+): string {
+  return JSON.stringify(
+    CreateAgentRequestResponseFormatAgentsJsonSchema$outboundSchema.parse(
+      createAgentRequestResponseFormatAgentsJsonSchema,
+    ),
+  );
+}
+
+/** @internal */
+export type CreateAgentRequestResponseFormatJSONSchema$Outbound = {
+  type: "json_schema";
+  json_schema: CreateAgentRequestResponseFormatAgentsJsonSchema$Outbound;
 };
 
 /** @internal */
-export const ProviderBuiltInTool$outboundSchema: z.ZodType<
-  ProviderBuiltInTool$Outbound,
-  z.ZodTypeDef,
-  ProviderBuiltInTool
-> = z.object({
-  type: z.string(),
-  requiresApproval: z.boolean().optional(),
-  configuration: z.record(z.any()).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    requiresApproval: "requires_approval",
+export const CreateAgentRequestResponseFormatJSONSchema$outboundSchema:
+  z.ZodType<
+    CreateAgentRequestResponseFormatJSONSchema$Outbound,
+    z.ZodTypeDef,
+    CreateAgentRequestResponseFormatJSONSchema
+  > = z.object({
+    type: z.literal("json_schema"),
+    jsonSchema: z.lazy(() =>
+      CreateAgentRequestResponseFormatAgentsJsonSchema$outboundSchema
+    ),
+  }).transform((v) => {
+    return remap$(v, {
+      jsonSchema: "json_schema",
+    });
   });
-});
 
-export function providerBuiltInToolToJSON(
-  providerBuiltInTool: ProviderBuiltInTool,
+export function createAgentRequestResponseFormatJSONSchemaToJSON(
+  createAgentRequestResponseFormatJSONSchema:
+    CreateAgentRequestResponseFormatJSONSchema,
 ): string {
   return JSON.stringify(
-    ProviderBuiltInTool$outboundSchema.parse(providerBuiltInTool),
+    CreateAgentRequestResponseFormatJSONSchema$outboundSchema.parse(
+      createAgentRequestResponseFormatJSONSchema,
+    ),
   );
 }
 
 /** @internal */
-export const CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools17Type$outboundSchema:
-  z.ZodNativeEnum<
-    typeof CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools17Type
-  > = z.nativeEnum(
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools17Type,
+export type ResponseFormatJSONObject$Outbound = {
+  type: "json_object";
+};
+
+/** @internal */
+export const ResponseFormatJSONObject$outboundSchema: z.ZodType<
+  ResponseFormatJSONObject$Outbound,
+  z.ZodTypeDef,
+  ResponseFormatJSONObject
+> = z.object({
+  type: z.literal("json_object"),
+});
+
+export function responseFormatJSONObjectToJSON(
+  responseFormatJSONObject: ResponseFormatJSONObject,
+): string {
+  return JSON.stringify(
+    ResponseFormatJSONObject$outboundSchema.parse(responseFormatJSONObject),
   );
+}
 
 /** @internal */
-export type MCPTool$Outbound = {
-  type: string;
-  key?: string | undefined;
-  id?: string | undefined;
-  tool_id: string;
-  requires_approval: boolean;
+export type ResponseFormatText$Outbound = {
+  type: "text";
 };
 
 /** @internal */
-export const MCPTool$outboundSchema: z.ZodType<
-  MCPTool$Outbound,
+export const ResponseFormatText$outboundSchema: z.ZodType<
+  ResponseFormatText$Outbound,
   z.ZodTypeDef,
-  MCPTool
+  ResponseFormatText
 > = z.object({
-  type:
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools17Type$outboundSchema
-      .default("mcp"),
-  key: z.string().optional(),
-  id: z.string().optional(),
-  toolId: z.string(),
-  requiresApproval: z.boolean().default(false),
-}).transform((v) => {
-  return remap$(v, {
-    toolId: "tool_id",
-    requiresApproval: "requires_approval",
-  });
+  type: z.literal("text"),
 });
 
-export function mcpToolToJSON(mcpTool: MCPTool): string {
-  return JSON.stringify(MCPTool$outboundSchema.parse(mcpTool));
+export function responseFormatTextToJSON(
+  responseFormatText: ResponseFormatText,
+): string {
+  return JSON.stringify(
+    ResponseFormatText$outboundSchema.parse(responseFormatText),
+  );
 }
 
 /** @internal */
-export const CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools16Type$outboundSchema:
-  z.ZodNativeEnum<
-    typeof CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools16Type
-  > = z.nativeEnum(
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools16Type,
+export type FallbackModelConfigurationResponseFormat$Outbound =
+  | ResponseFormatText$Outbound
+  | ResponseFormatJSONObject$Outbound
+  | CreateAgentRequestResponseFormatJSONSchema$Outbound;
+
+/** @internal */
+export const FallbackModelConfigurationResponseFormat$outboundSchema: z.ZodType<
+  FallbackModelConfigurationResponseFormat$Outbound,
+  z.ZodTypeDef,
+  FallbackModelConfigurationResponseFormat
+> = z.union([
+  z.lazy(() => ResponseFormatText$outboundSchema),
+  z.lazy(() => ResponseFormatJSONObject$outboundSchema),
+  z.lazy(() => CreateAgentRequestResponseFormatJSONSchema$outboundSchema),
+]);
+
+export function fallbackModelConfigurationResponseFormatToJSON(
+  fallbackModelConfigurationResponseFormat:
+    FallbackModelConfigurationResponseFormat,
+): string {
+  return JSON.stringify(
+    FallbackModelConfigurationResponseFormat$outboundSchema.parse(
+      fallbackModelConfigurationResponseFormat,
+    ),
   );
+}
 
 /** @internal */
-export type JSONSchemaTool$Outbound = {
-  type: string;
-  key?: string | undefined;
-  id?: string | undefined;
-  requires_approval: boolean;
-};
+export const FallbackModelConfigurationReasoningEffort$outboundSchema:
+  z.ZodNativeEnum<typeof FallbackModelConfigurationReasoningEffort> = z
+    .nativeEnum(FallbackModelConfigurationReasoningEffort);
+
+/** @internal */
+export type FallbackModelConfigurationStop$Outbound = string | Array<string>;
 
 /** @internal */
-export const JSONSchemaTool$outboundSchema: z.ZodType<
-  JSONSchemaTool$Outbound,
+export const FallbackModelConfigurationStop$outboundSchema: z.ZodType<
+  FallbackModelConfigurationStop$Outbound,
   z.ZodTypeDef,
-  JSONSchemaTool
-> = z.object({
-  type:
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools16Type$outboundSchema
-      .default("json_schema"),
-  key: z.string().optional(),
-  id: z.string().optional(),
-  requiresApproval: z.boolean().default(false),
-}).transform((v) => {
-  return remap$(v, {
-    requiresApproval: "requires_approval",
-  });
-});
+  FallbackModelConfigurationStop
+> = z.union([z.string(), z.array(z.string())]);
+
+export function fallbackModelConfigurationStopToJSON(
+  fallbackModelConfigurationStop: FallbackModelConfigurationStop,
+): string {
+  return JSON.stringify(
+    FallbackModelConfigurationStop$outboundSchema.parse(
+      fallbackModelConfigurationStop,
+    ),
+  );
+}
+
+/** @internal */
+export type FallbackModelConfigurationThinking$Outbound =
+  | components.ThinkingConfigDisabledSchema$Outbound
+  | components.ThinkingConfigEnabledSchema$Outbound
+  | components.ThinkingConfigAdaptiveSchema$Outbound;
+
+/** @internal */
+export const FallbackModelConfigurationThinking$outboundSchema: z.ZodType<
+  FallbackModelConfigurationThinking$Outbound,
+  z.ZodTypeDef,
+  FallbackModelConfigurationThinking
+> = z.union([
+  components.ThinkingConfigDisabledSchema$outboundSchema,
+  components.ThinkingConfigEnabledSchema$outboundSchema,
+  components.ThinkingConfigAdaptiveSchema$outboundSchema,
+]);
 
-export function jsonSchemaToolToJSON(jsonSchemaTool: JSONSchemaTool): string {
-  return JSON.stringify(JSONSchemaTool$outboundSchema.parse(jsonSchemaTool));
+export function fallbackModelConfigurationThinkingToJSON(
+  fallbackModelConfigurationThinking: FallbackModelConfigurationThinking,
+): string {
+  return JSON.stringify(
+    FallbackModelConfigurationThinking$outboundSchema.parse(
+      fallbackModelConfigurationThinking,
+    ),
+  );
 }
 
 /** @internal */
-export const CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools15Type$outboundSchema:
-  z.ZodNativeEnum<
-    typeof CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools15Type
-  > = z.nativeEnum(
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools15Type,
-  );
+export const CreateAgentRequestToolChoiceType$outboundSchema: z.ZodNativeEnum<
+  typeof CreateAgentRequestToolChoiceType
+> = z.nativeEnum(CreateAgentRequestToolChoiceType);
 
 /** @internal */
-export type FunctionTool$Outbound = {
-  type: string;
-  key?: string | undefined;
-  id?: string | undefined;
-  requires_approval: boolean;
+export type CreateAgentRequestToolChoiceFunction$Outbound = {
+  name: string;
 };
 
 /** @internal */
-export const FunctionTool$outboundSchema: z.ZodType<
-  FunctionTool$Outbound,
+export const CreateAgentRequestToolChoiceFunction$outboundSchema: z.ZodType<
+  CreateAgentRequestToolChoiceFunction$Outbound,
   z.ZodTypeDef,
-  FunctionTool
+  CreateAgentRequestToolChoiceFunction
 > = z.object({
-  type:
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools15Type$outboundSchema
-      .default("function"),
-  key: z.string().optional(),
-  id: z.string().optional(),
-  requiresApproval: z.boolean().default(false),
-}).transform((v) => {
-  return remap$(v, {
-    requiresApproval: "requires_approval",
-  });
+  name: z.string(),
 });
 
-export function functionToolToJSON(functionTool: FunctionTool): string {
-  return JSON.stringify(FunctionTool$outboundSchema.parse(functionTool));
-}
-
-/** @internal */
-export const CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools14Type$outboundSchema:
-  z.ZodNativeEnum<
-    typeof CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools14Type
-  > = z.nativeEnum(
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools14Type,
+export function createAgentRequestToolChoiceFunctionToJSON(
+  createAgentRequestToolChoiceFunction: CreateAgentRequestToolChoiceFunction,
+): string {
+  return JSON.stringify(
+    CreateAgentRequestToolChoiceFunction$outboundSchema.parse(
+      createAgentRequestToolChoiceFunction,
+    ),
   );
+}
 
 /** @internal */
-export type CodeExecutionTool$Outbound = {
-  type: string;
-  key?: string | undefined;
-  id?: string | undefined;
-  requires_approval: boolean;
+export type CreateAgentRequestToolChoice2$Outbound = {
+  type?: string | undefined;
+  function: CreateAgentRequestToolChoiceFunction$Outbound;
 };
 
 /** @internal */
-export const CodeExecutionTool$outboundSchema: z.ZodType<
-  CodeExecutionTool$Outbound,
+export const CreateAgentRequestToolChoice2$outboundSchema: z.ZodType<
+  CreateAgentRequestToolChoice2$Outbound,
   z.ZodTypeDef,
-  CodeExecutionTool
+  CreateAgentRequestToolChoice2
 > = z.object({
-  type:
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools14Type$outboundSchema
-      .default("code"),
-  key: z.string().optional(),
-  id: z.string().optional(),
-  requiresApproval: z.boolean().default(false),
-}).transform((v) => {
-  return remap$(v, {
-    requiresApproval: "requires_approval",
-  });
+  type: CreateAgentRequestToolChoiceType$outboundSchema.optional(),
+  function: z.lazy(() => CreateAgentRequestToolChoiceFunction$outboundSchema),
 });
 
-export function codeExecutionToolToJSON(
-  codeExecutionTool: CodeExecutionTool,
+export function createAgentRequestToolChoice2ToJSON(
+  createAgentRequestToolChoice2: CreateAgentRequestToolChoice2,
 ): string {
   return JSON.stringify(
-    CodeExecutionTool$outboundSchema.parse(codeExecutionTool),
+    CreateAgentRequestToolChoice2$outboundSchema.parse(
+      createAgentRequestToolChoice2,
+    ),
   );
 }
 
 /** @internal */
-export const CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools13Type$outboundSchema:
-  z.ZodNativeEnum<
-    typeof CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools13Type
-  > = z.nativeEnum(
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools13Type,
-  );
+export const CreateAgentRequestToolChoice1$outboundSchema: z.ZodNativeEnum<
+  typeof CreateAgentRequestToolChoice1
+> = z.nativeEnum(CreateAgentRequestToolChoice1);
 
 /** @internal */
-export type HTTPTool$Outbound = {
-  type: string;
-  key?: string | undefined;
-  id?: string | undefined;
-  requires_approval: boolean;
-};
+export type FallbackModelConfigurationToolChoice$Outbound =
+  | CreateAgentRequestToolChoice2$Outbound
+  | string;
 
 /** @internal */
-export const HTTPTool$outboundSchema: z.ZodType<
-  HTTPTool$Outbound,
+export const FallbackModelConfigurationToolChoice$outboundSchema: z.ZodType<
+  FallbackModelConfigurationToolChoice$Outbound,
   z.ZodTypeDef,
-  HTTPTool
-> = z.object({
-  type:
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools13Type$outboundSchema
-      .default("http"),
-  key: z.string().optional(),
-  id: z.string().optional(),
-  requiresApproval: z.boolean().default(false),
-}).transform((v) => {
-  return remap$(v, {
-    requiresApproval: "requires_approval",
-  });
-});
+  FallbackModelConfigurationToolChoice
+> = z.union([
+  z.lazy(() => CreateAgentRequestToolChoice2$outboundSchema),
+  CreateAgentRequestToolChoice1$outboundSchema,
+]);
 
-export function httpToolToJSON(httpTool: HTTPTool): string {
-  return JSON.stringify(HTTPTool$outboundSchema.parse(httpTool));
+export function fallbackModelConfigurationToolChoiceToJSON(
+  fallbackModelConfigurationToolChoice: FallbackModelConfigurationToolChoice,
+): string {
+  return JSON.stringify(
+    FallbackModelConfigurationToolChoice$outboundSchema.parse(
+      fallbackModelConfigurationToolChoice,
+    ),
+  );
 }
 
 /** @internal */
-export const CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools12Type$outboundSchema:
-  z.ZodNativeEnum<
-    typeof CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools12Type
-  > = z.nativeEnum(
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools12Type,
+export const FallbackModelConfigurationModalities$outboundSchema:
+  z.ZodNativeEnum<typeof FallbackModelConfigurationModalities> = z.nativeEnum(
+    FallbackModelConfigurationModalities,
   );
 
 /** @internal */
-export type CodeInterpreterTool$Outbound = {
-  type: string;
-  requires_approval?: boolean | undefined;
-  configuration?: { [k: string]: any } | undefined;
-};
+export const CreateAgentRequestId1$outboundSchema: z.ZodNativeEnum<
+  typeof CreateAgentRequestId1
+> = z.nativeEnum(CreateAgentRequestId1);
+
+/** @internal */
+export type FallbackModelConfigurationId$Outbound = string | string;
 
 /** @internal */
-export const CodeInterpreterTool$outboundSchema: z.ZodType<
-  CodeInterpreterTool$Outbound,
+export const FallbackModelConfigurationId$outboundSchema: z.ZodType<
+  FallbackModelConfigurationId$Outbound,
   z.ZodTypeDef,
-  CodeInterpreterTool
-> = z.object({
-  type:
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools12Type$outboundSchema,
-  requiresApproval: z.boolean().optional(),
-  configuration: z.record(z.any()).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    requiresApproval: "requires_approval",
-  });
-});
+  FallbackModelConfigurationId
+> = z.union([CreateAgentRequestId1$outboundSchema, z.string()]);
 
-export function codeInterpreterToolToJSON(
-  codeInterpreterTool: CodeInterpreterTool,
+export function fallbackModelConfigurationIdToJSON(
+  fallbackModelConfigurationId: FallbackModelConfigurationId,
 ): string {
   return JSON.stringify(
-    CodeInterpreterTool$outboundSchema.parse(codeInterpreterTool),
+    FallbackModelConfigurationId$outboundSchema.parse(
+      fallbackModelConfigurationId,
+    ),
   );
 }
 
 /** @internal */
-export const CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools11Type$outboundSchema:
-  z.ZodNativeEnum<
-    typeof CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools11Type
-  > = z.nativeEnum(
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools11Type,
+export const FallbackModelConfigurationExecuteOn$outboundSchema:
+  z.ZodNativeEnum<typeof FallbackModelConfigurationExecuteOn> = z.nativeEnum(
+    FallbackModelConfigurationExecuteOn,
   );
 
 /** @internal */
-export type CurrentDateTool$Outbound = {
-  type: string;
-  requires_approval?: boolean | undefined;
-  configuration?: { [k: string]: any } | undefined;
+export type FallbackModelConfigurationGuardrails$Outbound = {
+  id: string | string;
+  execute_on: string;
 };
 
 /** @internal */
-export const CurrentDateTool$outboundSchema: z.ZodType<
-  CurrentDateTool$Outbound,
+export const FallbackModelConfigurationGuardrails$outboundSchema: z.ZodType<
+  FallbackModelConfigurationGuardrails$Outbound,
   z.ZodTypeDef,
-  CurrentDateTool
+  FallbackModelConfigurationGuardrails
 > = z.object({
-  type:
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools11Type$outboundSchema,
-  requiresApproval: z.boolean().optional(),
-  configuration: z.record(z.any()).optional(),
+  id: z.union([CreateAgentRequestId1$outboundSchema, z.string()]),
+  executeOn: FallbackModelConfigurationExecuteOn$outboundSchema,
 }).transform((v) => {
   return remap$(v, {
-    requiresApproval: "requires_approval",
+    executeOn: "execute_on",
   });
 });
 
-export function currentDateToolToJSON(
-  currentDateTool: CurrentDateTool,
+export function fallbackModelConfigurationGuardrailsToJSON(
+  fallbackModelConfigurationGuardrails: FallbackModelConfigurationGuardrails,
 ): string {
-  return JSON.stringify(CurrentDateTool$outboundSchema.parse(currentDateTool));
+  return JSON.stringify(
+    FallbackModelConfigurationGuardrails$outboundSchema.parse(
+      fallbackModelConfigurationGuardrails,
+    ),
+  );
 }
 
 /** @internal */
-export const CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools10Type$outboundSchema:
-  z.ZodNativeEnum<
-    typeof CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools10Type
-  > = z.nativeEnum(
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools10Type,
+export type FallbackModelConfigurationPlugins$Outbound =
+  | components.PIIRedactionPluginEn$Outbound
+  | components.PIIRedactionPluginNl$Outbound
+  | components.PIIRedactionPluginAuto$Outbound;
+
+/** @internal */
+export const FallbackModelConfigurationPlugins$outboundSchema: z.ZodType<
+  FallbackModelConfigurationPlugins$Outbound,
+  z.ZodTypeDef,
+  FallbackModelConfigurationPlugins
+> = z.union([
+  components.PIIRedactionPluginEn$outboundSchema,
+  components.PIIRedactionPluginNl$outboundSchema,
+  components.PIIRedactionPluginAuto$outboundSchema,
+]);
+
+export function fallbackModelConfigurationPluginsToJSON(
+  fallbackModelConfigurationPlugins: FallbackModelConfigurationPlugins,
+): string {
+  return JSON.stringify(
+    FallbackModelConfigurationPlugins$outboundSchema.parse(
+      fallbackModelConfigurationPlugins,
+    ),
   );
+}
 
 /** @internal */
-export type QueryKnowledgeBaseTool$Outbound = {
-  type: string;
-  requires_approval?: boolean | undefined;
-  configuration?: { [k: string]: any } | undefined;
+export type FallbackModelConfigurationFallbacks$Outbound = {
+  model: string;
 };
 
 /** @internal */
-export const QueryKnowledgeBaseTool$outboundSchema: z.ZodType<
-  QueryKnowledgeBaseTool$Outbound,
+export const FallbackModelConfigurationFallbacks$outboundSchema: z.ZodType<
+  FallbackModelConfigurationFallbacks$Outbound,
   z.ZodTypeDef,
-  QueryKnowledgeBaseTool
+  FallbackModelConfigurationFallbacks
 > = z.object({
-  type:
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools10Type$outboundSchema,
-  requiresApproval: z.boolean().optional(),
-  configuration: z.record(z.any()).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    requiresApproval: "requires_approval",
-  });
+  model: z.string(),
 });
 
-export function queryKnowledgeBaseToolToJSON(
-  queryKnowledgeBaseTool: QueryKnowledgeBaseTool,
+export function fallbackModelConfigurationFallbacksToJSON(
+  fallbackModelConfigurationFallbacks: FallbackModelConfigurationFallbacks,
 ): string {
   return JSON.stringify(
-    QueryKnowledgeBaseTool$outboundSchema.parse(queryKnowledgeBaseTool),
+    FallbackModelConfigurationFallbacks$outboundSchema.parse(
+      fallbackModelConfigurationFallbacks,
+    ),
   );
 }
 
 /** @internal */
-export const CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools9Type$outboundSchema:
-  z.ZodNativeEnum<
-    typeof CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools9Type
-  > = z.nativeEnum(
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools9Type,
-  );
+export const FallbackModelConfigurationType$outboundSchema: z.ZodNativeEnum<
+  typeof FallbackModelConfigurationType
+> = z.nativeEnum(FallbackModelConfigurationType);
 
 /** @internal */
-export type RetrieveKnowledgeBasesTool$Outbound = {
+export type FallbackModelConfigurationCache$Outbound = {
+  ttl: number;
   type: string;
-  requires_approval?: boolean | undefined;
-  configuration?: { [k: string]: any } | undefined;
 };
 
 /** @internal */
-export const RetrieveKnowledgeBasesTool$outboundSchema: z.ZodType<
-  RetrieveKnowledgeBasesTool$Outbound,
+export const FallbackModelConfigurationCache$outboundSchema: z.ZodType<
+  FallbackModelConfigurationCache$Outbound,
   z.ZodTypeDef,
-  RetrieveKnowledgeBasesTool
+  FallbackModelConfigurationCache
 > = z.object({
-  type:
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools9Type$outboundSchema,
-  requiresApproval: z.boolean().optional(),
-  configuration: z.record(z.any()).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    requiresApproval: "requires_approval",
-  });
+  ttl: z.number().default(1800),
+  type: FallbackModelConfigurationType$outboundSchema,
 });
 
-export function retrieveKnowledgeBasesToolToJSON(
-  retrieveKnowledgeBasesTool: RetrieveKnowledgeBasesTool,
+export function fallbackModelConfigurationCacheToJSON(
+  fallbackModelConfigurationCache: FallbackModelConfigurationCache,
 ): string {
   return JSON.stringify(
-    RetrieveKnowledgeBasesTool$outboundSchema.parse(retrieveKnowledgeBasesTool),
+    FallbackModelConfigurationCache$outboundSchema.parse(
+      fallbackModelConfigurationCache,
+    ),
   );
 }
 
 /** @internal */
-export const CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools8Type$outboundSchema:
-  z.ZodNativeEnum<
-    typeof CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools8Type
-  > = z.nativeEnum(
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools8Type,
-  );
+export const CreateAgentRequestLoadBalancerType$outboundSchema: z.ZodNativeEnum<
+  typeof CreateAgentRequestLoadBalancerType
+> = z.nativeEnum(CreateAgentRequestLoadBalancerType);
 
 /** @internal */
-export type DeleteMemoryDocumentTool$Outbound = {
-  type: string;
-  requires_approval?: boolean | undefined;
-  configuration?: { [k: string]: any } | undefined;
+export type LoadBalancerModels$Outbound = {
+  model: string;
+  weight: number;
 };
 
 /** @internal */
-export const DeleteMemoryDocumentTool$outboundSchema: z.ZodType<
-  DeleteMemoryDocumentTool$Outbound,
+export const LoadBalancerModels$outboundSchema: z.ZodType<
+  LoadBalancerModels$Outbound,
   z.ZodTypeDef,
-  DeleteMemoryDocumentTool
+  LoadBalancerModels
 > = z.object({
-  type:
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsTools8Type$outboundSchema,
-  requiresApproval: z.boolean().optional(),
-  configuration: z.record(z.any()).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    requiresApproval: "requires_approval",
-  });
+  model: z.string(),
+  weight: z.number().default(0.5),
 });
 
-export function deleteMemoryDocumentToolToJSON(
-  deleteMemoryDocumentTool: DeleteMemoryDocumentTool,
+export function loadBalancerModelsToJSON(
+  loadBalancerModels: LoadBalancerModels,
 ): string {
   return JSON.stringify(
-    DeleteMemoryDocumentTool$outboundSchema.parse(deleteMemoryDocumentTool),
+    LoadBalancerModels$outboundSchema.parse(loadBalancerModels),
   );
 }
 
 /** @internal */
-export const CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsToolsType$outboundSchema:
-  z.ZodNativeEnum<
-    typeof CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsToolsType
-  > = z.nativeEnum(
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsToolsType,
-  );
-
-/** @internal */
-export type RetrieveMemoryStoresTool$Outbound = {
+export type CreateAgentRequestLoadBalancer1$Outbound = {
   type: string;
-  requires_approval?: boolean | undefined;
-  configuration?: { [k: string]: any } | undefined;
+  models: Array<LoadBalancerModels$Outbound>;
 };
 
 /** @internal */
-export const RetrieveMemoryStoresTool$outboundSchema: z.ZodType<
-  RetrieveMemoryStoresTool$Outbound,
+export const CreateAgentRequestLoadBalancer1$outboundSchema: z.ZodType<
+  CreateAgentRequestLoadBalancer1$Outbound,
   z.ZodTypeDef,
-  RetrieveMemoryStoresTool
+  CreateAgentRequestLoadBalancer1
 > = z.object({
-  type:
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsToolsType$outboundSchema,
-  requiresApproval: z.boolean().optional(),
-  configuration: z.record(z.any()).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    requiresApproval: "requires_approval",
-  });
+  type: CreateAgentRequestLoadBalancerType$outboundSchema,
+  models: z.array(z.lazy(() => LoadBalancerModels$outboundSchema)),
 });
 
-export function retrieveMemoryStoresToolToJSON(
-  retrieveMemoryStoresTool: RetrieveMemoryStoresTool,
+export function createAgentRequestLoadBalancer1ToJSON(
+  createAgentRequestLoadBalancer1: CreateAgentRequestLoadBalancer1,
 ): string {
   return JSON.stringify(
-    RetrieveMemoryStoresTool$outboundSchema.parse(retrieveMemoryStoresTool),
+    CreateAgentRequestLoadBalancer1$outboundSchema.parse(
+      createAgentRequestLoadBalancer1,
+    ),
   );
 }
 
 /** @internal */
-export const CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsType$outboundSchema:
-  z.ZodNativeEnum<
-    typeof CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsType
-  > = z.nativeEnum(
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsType,
-  );
-
-/** @internal */
-export type WriteMemoryStoreTool$Outbound = {
-  type: string;
-  requires_approval?: boolean | undefined;
-  configuration?: { [k: string]: any } | undefined;
-};
+export type FallbackModelConfigurationLoadBalancer$Outbound =
+  CreateAgentRequestLoadBalancer1$Outbound;
 
 /** @internal */
-export const WriteMemoryStoreTool$outboundSchema: z.ZodType<
-  WriteMemoryStoreTool$Outbound,
+export const FallbackModelConfigurationLoadBalancer$outboundSchema: z.ZodType<
+  FallbackModelConfigurationLoadBalancer$Outbound,
   z.ZodTypeDef,
-  WriteMemoryStoreTool
-> = z.object({
-  type:
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodySettingsType$outboundSchema,
-  requiresApproval: z.boolean().optional(),
-  configuration: z.record(z.any()).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    requiresApproval: "requires_approval",
-  });
-});
+  FallbackModelConfigurationLoadBalancer
+> = z.lazy(() => CreateAgentRequestLoadBalancer1$outboundSchema);
 
-export function writeMemoryStoreToolToJSON(
-  writeMemoryStoreTool: WriteMemoryStoreTool,
+export function fallbackModelConfigurationLoadBalancerToJSON(
+  fallbackModelConfigurationLoadBalancer:
+    FallbackModelConfigurationLoadBalancer,
 ): string {
   return JSON.stringify(
-    WriteMemoryStoreTool$outboundSchema.parse(writeMemoryStoreTool),
+    FallbackModelConfigurationLoadBalancer$outboundSchema.parse(
+      fallbackModelConfigurationLoadBalancer,
+    ),
   );
 }
 
 /** @internal */
-export const CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodyType$outboundSchema:
-  z.ZodNativeEnum<
-    typeof CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodyType
-  > = z.nativeEnum(
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodyType,
-  );
-
-/** @internal */
-export type QueryMemoryStoreTool$Outbound = {
-  type: string;
-  requires_approval?: boolean | undefined;
-  configuration?: { [k: string]: any } | undefined;
+export type FallbackModelConfigurationTimeout$Outbound = {
+  call_timeout: number;
 };
 
 /** @internal */
-export const QueryMemoryStoreTool$outboundSchema: z.ZodType<
-  QueryMemoryStoreTool$Outbound,
+export const FallbackModelConfigurationTimeout$outboundSchema: z.ZodType<
+  FallbackModelConfigurationTimeout$Outbound,
   z.ZodTypeDef,
-  QueryMemoryStoreTool
+  FallbackModelConfigurationTimeout
 > = z.object({
-  type:
-    CreateAgentRequestAgentToolInputCRUDAgentsRequestRequestBodyType$outboundSchema,
-  requiresApproval: z.boolean().optional(),
-  configuration: z.record(z.any()).optional(),
+  callTimeout: z.number(),
 }).transform((v) => {
   return remap$(v, {
-    requiresApproval: "requires_approval",
+    callTimeout: "call_timeout",
   });
 });
 
-export function queryMemoryStoreToolToJSON(
-  queryMemoryStoreTool: QueryMemoryStoreTool,
+export function fallbackModelConfigurationTimeoutToJSON(
+  fallbackModelConfigurationTimeout: FallbackModelConfigurationTimeout,
 ): string {
   return JSON.stringify(
-    QueryMemoryStoreTool$outboundSchema.parse(queryMemoryStoreTool),
+    FallbackModelConfigurationTimeout$outboundSchema.parse(
+      fallbackModelConfigurationTimeout,
+    ),
   );
 }
 
 /** @internal */
-export const CreateAgentRequestAgentToolInputCRUDAgentsRequestType$outboundSchema:
-  z.ZodNativeEnum<
-    typeof CreateAgentRequestAgentToolInputCRUDAgentsRequestType
-  > = z.nativeEnum(CreateAgentRequestAgentToolInputCRUDAgentsRequestType);
+export const CreateAgentRequestFallbackModelConfigurationType$outboundSchema:
+  z.ZodNativeEnum<typeof CreateAgentRequestFallbackModelConfigurationType> = z
+    .nativeEnum(CreateAgentRequestFallbackModelConfigurationType);
+
+/** @internal */
+export const FallbackModelConfigurationTtl$outboundSchema: z.ZodNativeEnum<
+  typeof FallbackModelConfigurationTtl
+> = z.nativeEnum(FallbackModelConfigurationTtl);
 
 /** @internal */
-export type RetrieveAgentsTool$Outbound = {
+export type FallbackModelConfigurationCacheControl$Outbound = {
   type: string;
-  requires_approval?: boolean | undefined;
-  configuration?: { [k: string]: any } | undefined;
+  ttl: string;
 };
 
 /** @internal */
-export const RetrieveAgentsTool$outboundSchema: z.ZodType<
-  RetrieveAgentsTool$Outbound,
+export const FallbackModelConfigurationCacheControl$outboundSchema: z.ZodType<
+  FallbackModelConfigurationCacheControl$Outbound,
   z.ZodTypeDef,
-  RetrieveAgentsTool
+  FallbackModelConfigurationCacheControl
 > = z.object({
-  type: CreateAgentRequestAgentToolInputCRUDAgentsRequestType$outboundSchema,
-  requiresApproval: z.boolean().optional(),
-  configuration: z.record(z.any()).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    requiresApproval: "requires_approval",
-  });
+  type: CreateAgentRequestFallbackModelConfigurationType$outboundSchema,
+  ttl: FallbackModelConfigurationTtl$outboundSchema.default("5m"),
 });
 
-export function retrieveAgentsToolToJSON(
-  retrieveAgentsTool: RetrieveAgentsTool,
+export function fallbackModelConfigurationCacheControlToJSON(
+  fallbackModelConfigurationCacheControl:
+    FallbackModelConfigurationCacheControl,
 ): string {
   return JSON.stringify(
-    RetrieveAgentsTool$outboundSchema.parse(retrieveAgentsTool),
+    FallbackModelConfigurationCacheControl$outboundSchema.parse(
+      fallbackModelConfigurationCacheControl,
+    ),
   );
 }
 
 /** @internal */
-export const CreateAgentRequestAgentToolInputCRUDAgentsType$outboundSchema:
-  z.ZodNativeEnum<typeof CreateAgentRequestAgentToolInputCRUDAgentsType> = z
-    .nativeEnum(CreateAgentRequestAgentToolInputCRUDAgentsType);
-
-/** @internal */
-export type CallSubAgentTool$Outbound = {
-  type: string;
-  requires_approval?: boolean | undefined;
-  configuration?: { [k: string]: any } | undefined;
+export type FallbackModelConfigurationParameters$Outbound = {
+  name?: string | undefined;
+  frequency_penalty?: number | null | undefined;
+  max_tokens?: number | null | undefined;
+  max_completion_tokens?: number | null | undefined;
+  presence_penalty?: number | null | undefined;
+  response_format?:
+    | ResponseFormatText$Outbound
+    | ResponseFormatJSONObject$Outbound
+    | CreateAgentRequestResponseFormatJSONSchema$Outbound
+    | undefined;
+  reasoning_effort?: string | undefined;
+  verbosity?: string | undefined;
+  seed?: number | null | undefined;
+  stop?: string | Array<string> | null | undefined;
+  thinking?:
+    | components.ThinkingConfigDisabledSchema$Outbound
+    | components.ThinkingConfigEnabledSchema$Outbound
+    | components.ThinkingConfigAdaptiveSchema$Outbound
+    | undefined;
+  temperature?: number | null | undefined;
+  top_p?: number | null | undefined;
+  top_k?: number | null | undefined;
+  tool_choice?: CreateAgentRequestToolChoice2$Outbound | string | undefined;
+  parallel_tool_calls?: boolean | undefined;
+  modalities?: Array<string> | null | undefined;
+  guardrails?: Array<FallbackModelConfigurationGuardrails$Outbound> | undefined;
+  plugins?:
+    | Array<
+      | components.PIIRedactionPluginEn$Outbound
+      | components.PIIRedactionPluginNl$Outbound
+      | components.PIIRedactionPluginAuto$Outbound
+    >
+    | undefined;
+  fallbacks?: Array<FallbackModelConfigurationFallbacks$Outbound> | undefined;
+  cache?: FallbackModelConfigurationCache$Outbound | undefined;
+  load_balancer?: CreateAgentRequestLoadBalancer1$Outbound | undefined;
+  timeout?: FallbackModelConfigurationTimeout$Outbound | undefined;
+  cache_control?: FallbackModelConfigurationCacheControl$Outbound | undefined;
+  prompt_cache_key?: string | undefined;
 };
 
 /** @internal */
-export const CallSubAgentTool$outboundSchema: z.ZodType<
-  CallSubAgentTool$Outbound,
+export const FallbackModelConfigurationParameters$outboundSchema: z.ZodType<
+  FallbackModelConfigurationParameters$Outbound,
   z.ZodTypeDef,
-  CallSubAgentTool
+  FallbackModelConfigurationParameters
 > = z.object({
-  type: CreateAgentRequestAgentToolInputCRUDAgentsType$outboundSchema,
-  requiresApproval: z.boolean().optional(),
-  configuration: z.record(z.any()).optional(),
+  name: z.string().optional(),
+  frequencyPenalty: z.nullable(z.number()).optional(),
+  maxTokens: z.nullable(z.number().int()).optional(),
+  maxCompletionTokens: z.nullable(z.number().int()).optional(),
+  presencePenalty: z.nullable(z.number()).optional(),
+  responseFormat: z.union([
+    z.lazy(() => ResponseFormatText$outboundSchema),
+    z.lazy(() => ResponseFormatJSONObject$outboundSchema),
+    z.lazy(() => CreateAgentRequestResponseFormatJSONSchema$outboundSchema),
+  ]).optional(),
+  reasoningEffort: FallbackModelConfigurationReasoningEffort$outboundSchema
+    .optional(),
+  verbosity: z.string().optional(),
+  seed: z.nullable(z.number()).optional(),
+  stop: z.nullable(z.union([z.string(), z.array(z.string())])).optional(),
+  thinking: z.union([
+    components.ThinkingConfigDisabledSchema$outboundSchema,
+    components.ThinkingConfigEnabledSchema$outboundSchema,
+    components.ThinkingConfigAdaptiveSchema$outboundSchema,
+  ]).optional(),
+  temperature: z.nullable(z.number()).optional(),
+  topP: z.nullable(z.number()).optional(),
+  topK: z.nullable(z.number()).optional(),
+  toolChoice: z.union([
+    z.lazy(() => CreateAgentRequestToolChoice2$outboundSchema),
+    CreateAgentRequestToolChoice1$outboundSchema,
+  ]).optional(),
+  parallelToolCalls: z.boolean().optional(),
+  modalities: z.nullable(
+    z.array(FallbackModelConfigurationModalities$outboundSchema),
+  ).optional(),
+  guardrails: z.array(
+    z.lazy(() => FallbackModelConfigurationGuardrails$outboundSchema),
+  ).optional(),
+  plugins: z.array(
+    z.union([
+      components.PIIRedactionPluginEn$outboundSchema,
+      components.PIIRedactionPluginNl$outboundSchema,
+      components.PIIRedactionPluginAuto$outboundSchema,
+    ]),
+  ).optional(),
+  fallbacks: z.array(
+    z.lazy(() => FallbackModelConfigurationFallbacks$outboundSchema),
+  ).optional(),
+  cache: z.lazy(() => FallbackModelConfigurationCache$outboundSchema)
+    .optional(),
+  loadBalancer: z.lazy(() => CreateAgentRequestLoadBalancer1$outboundSchema)
+    .optional(),
+  timeout: z.lazy(() => FallbackModelConfigurationTimeout$outboundSchema)
+    .optional(),
+  cacheControl: z.lazy(() =>
+    FallbackModelConfigurationCacheControl$outboundSchema
+  ).optional(),
+  promptCacheKey: z.string().optional(),
 }).transform((v) => {
   return remap$(v, {
-    requiresApproval: "requires_approval",
+    frequencyPenalty: "frequency_penalty",
+    maxTokens: "max_tokens",
+    maxCompletionTokens: "max_completion_tokens",
+    presencePenalty: "presence_penalty",
+    responseFormat: "response_format",
+    reasoningEffort: "reasoning_effort",
+    topP: "top_p",
+    topK: "top_k",
+    toolChoice: "tool_choice",
+    parallelToolCalls: "parallel_tool_calls",
+    loadBalancer: "load_balancer",
+    cacheControl: "cache_control",
+    promptCacheKey: "prompt_cache_key",
   });
 });
 
-export function callSubAgentToolToJSON(
-  callSubAgentTool: CallSubAgentTool,
+export function fallbackModelConfigurationParametersToJSON(
+  fallbackModelConfigurationParameters: FallbackModelConfigurationParameters,
 ): string {
   return JSON.stringify(
-    CallSubAgentTool$outboundSchema.parse(callSubAgentTool),
+    FallbackModelConfigurationParameters$outboundSchema.parse(
+      fallbackModelConfigurationParameters,
+    ),
   );
 }
 
 /** @internal */
-export const CreateAgentRequestAgentToolInputCRUDType$outboundSchema:
-  z.ZodNativeEnum<typeof CreateAgentRequestAgentToolInputCRUDType> = z
-    .nativeEnum(CreateAgentRequestAgentToolInputCRUDType);
-
-/** @internal */
-export type WebScraperTool$Outbound = {
-  type: string;
-  requires_approval?: boolean | undefined;
-  configuration?: { [k: string]: any } | undefined;
+export type FallbackModelConfigurationRetry$Outbound = {
+  count: number;
+  on_codes?: Array<number> | undefined;
 };
 
 /** @internal */
-export const WebScraperTool$outboundSchema: z.ZodType<
-  WebScraperTool$Outbound,
+export const FallbackModelConfigurationRetry$outboundSchema: z.ZodType<
+  FallbackModelConfigurationRetry$Outbound,
   z.ZodTypeDef,
-  WebScraperTool
+  FallbackModelConfigurationRetry
 > = z.object({
-  type: CreateAgentRequestAgentToolInputCRUDType$outboundSchema,
-  requiresApproval: z.boolean().optional(),
-  configuration: z.record(z.any()).optional(),
+  count: z.number().default(3),
+  onCodes: z.array(z.number()).optional(),
 }).transform((v) => {
   return remap$(v, {
-    requiresApproval: "requires_approval",
+    onCodes: "on_codes",
   });
 });
 
-export function webScraperToolToJSON(webScraperTool: WebScraperTool): string {
-  return JSON.stringify(WebScraperTool$outboundSchema.parse(webScraperTool));
+export function fallbackModelConfigurationRetryToJSON(
+  fallbackModelConfigurationRetry: FallbackModelConfigurationRetry,
+): string {
+  return JSON.stringify(
+    FallbackModelConfigurationRetry$outboundSchema.parse(
+      fallbackModelConfigurationRetry,
+    ),
+  );
 }
 
 /** @internal */
-export const AgentToolInputCRUDType$outboundSchema: z.ZodNativeEnum<
-  typeof AgentToolInputCRUDType
-> = z.nativeEnum(AgentToolInputCRUDType);
-
-/** @internal */
-export type GoogleSearchTool$Outbound = {
-  type: string;
-  requires_approval?: boolean | undefined;
-  configuration?: { [k: string]: any } | undefined;
+export type FallbackModelConfiguration2$Outbound = {
+  id: string;
+  parameters?: FallbackModelConfigurationParameters$Outbound | undefined;
+  retry?: FallbackModelConfigurationRetry$Outbound | undefined;
 };
 
 /** @internal */
-export const GoogleSearchTool$outboundSchema: z.ZodType<
-  GoogleSearchTool$Outbound,
+export const FallbackModelConfiguration2$outboundSchema: z.ZodType<
+  FallbackModelConfiguration2$Outbound,
   z.ZodTypeDef,
-  GoogleSearchTool
+  FallbackModelConfiguration2
 > = z.object({
-  type: AgentToolInputCRUDType$outboundSchema,
-  requiresApproval: z.boolean().optional(),
-  configuration: z.record(z.any()).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    requiresApproval: "requires_approval",
-  });
+  id: z.string(),
+  parameters: z.lazy(() => FallbackModelConfigurationParameters$outboundSchema)
+    .optional(),
+  retry: z.lazy(() => FallbackModelConfigurationRetry$outboundSchema)
+    .optional(),
 });
 
-export function googleSearchToolToJSON(
-  googleSearchTool: GoogleSearchTool,
+export function fallbackModelConfiguration2ToJSON(
+  fallbackModelConfiguration2: FallbackModelConfiguration2,
 ): string {
   return JSON.stringify(
-    GoogleSearchTool$outboundSchema.parse(googleSearchTool),
+    FallbackModelConfiguration2$outboundSchema.parse(
+      fallbackModelConfiguration2,
+    ),
   );
 }
 
 /** @internal */
-export type AgentToolInputCRUD$Outbound =
-  | GoogleSearchTool$Outbound
-  | WebScraperTool$Outbound
-  | CallSubAgentTool$Outbound
-  | RetrieveAgentsTool$Outbound
-  | QueryMemoryStoreTool$Outbound
-  | WriteMemoryStoreTool$Outbound
-  | RetrieveMemoryStoresTool$Outbound
-  | DeleteMemoryDocumentTool$Outbound
-  | RetrieveKnowledgeBasesTool$Outbound
-  | QueryKnowledgeBaseTool$Outbound
-  | CurrentDateTool$Outbound
-  | CodeInterpreterTool$Outbound
-  | MCPTool$Outbound
-  | ProviderBuiltInTool$Outbound
-  | HTTPTool$Outbound
-  | CodeExecutionTool$Outbound
-  | FunctionTool$Outbound
-  | JSONSchemaTool$Outbound;
-
-/** @internal */
-export const AgentToolInputCRUD$outboundSchema: z.ZodType<
-  AgentToolInputCRUD$Outbound,
+export type FallbackModelConfiguration$Outbound =
+  | FallbackModelConfiguration2$Outbound
+  | string;
+
+/** @internal */
+export const FallbackModelConfiguration$outboundSchema: z.ZodType<
+  FallbackModelConfiguration$Outbound,
   z.ZodTypeDef,
-  AgentToolInputCRUD
+  FallbackModelConfiguration
 > = z.union([
-  z.lazy(() => GoogleSearchTool$outboundSchema),
-  z.lazy(() => WebScraperTool$outboundSchema),
-  z.lazy(() => CallSubAgentTool$outboundSchema),
-  z.lazy(() => RetrieveAgentsTool$outboundSchema),
-  z.lazy(() => QueryMemoryStoreTool$outboundSchema),
-  z.lazy(() => WriteMemoryStoreTool$outboundSchema),
-  z.lazy(() => RetrieveMemoryStoresTool$outboundSchema),
-  z.lazy(() => DeleteMemoryDocumentTool$outboundSchema),
-  z.lazy(() => RetrieveKnowledgeBasesTool$outboundSchema),
-  z.lazy(() => QueryKnowledgeBaseTool$outboundSchema),
-  z.lazy(() => CurrentDateTool$outboundSchema),
-  z.lazy(() => CodeInterpreterTool$outboundSchema),
-  z.lazy(() => MCPTool$outboundSchema),
-  z.lazy(() => ProviderBuiltInTool$outboundSchema),
-  z.lazy(() => HTTPTool$outboundSchema),
-  z.lazy(() => CodeExecutionTool$outboundSchema),
-  z.lazy(() => FunctionTool$outboundSchema),
-  z.lazy(() => JSONSchemaTool$outboundSchema),
+  z.lazy(() => FallbackModelConfiguration2$outboundSchema),
+  z.string(),
 ]);
 
-export function agentToolInputCRUDToJSON(
-  agentToolInputCRUD: AgentToolInputCRUD,
+export function fallbackModelConfigurationToJSON(
+  fallbackModelConfiguration: FallbackModelConfiguration,
 ): string {
   return JSON.stringify(
-    AgentToolInputCRUD$outboundSchema.parse(agentToolInputCRUD),
+    FallbackModelConfiguration$outboundSchema.parse(fallbackModelConfiguration),
   );
 }
 
+/** @internal */
+export const ToolApprovalRequired$outboundSchema: z.ZodNativeEnum<
+  typeof ToolApprovalRequired
+> = z.nativeEnum(ToolApprovalRequired);
+
 /** @internal */
 export const CreateAgentRequestExecuteOn$outboundSchema: z.ZodNativeEnum<
   typeof CreateAgentRequestExecuteOn
@@ -5241,28 +3970,7 @@ export type Settings$Outbound = {
   max_cost: number;
   tool_approval_required: string;
   chat_exposed?: boolean | undefined;
-  tools?:
-    | Array<
-      | GoogleSearchTool$Outbound
-      | WebScraperTool$Outbound
-      | CallSubAgentTool$Outbound
-      | RetrieveAgentsTool$Outbound
-      | QueryMemoryStoreTool$Outbound
-      | WriteMemoryStoreTool$Outbound
-      | RetrieveMemoryStoresTool$Outbound
-      | DeleteMemoryDocumentTool$Outbound
-      | RetrieveKnowledgeBasesTool$Outbound
-      | QueryKnowledgeBaseTool$Outbound
-      | CurrentDateTool$Outbound
-      | CodeInterpreterTool$Outbound
-      | MCPTool$Outbound
-      | ProviderBuiltInTool$Outbound
-      | HTTPTool$Outbound
-      | CodeExecutionTool$Outbound
-      | FunctionTool$Outbound
-      | JSONSchemaTool$Outbound
-    >
-    | undefined;
+  tools?: Array<components.AgentToolInputCRUD$Outbound> | undefined;
   evaluators?: Array<Evaluators$Outbound> | undefined;
   guardrails?: Array<CreateAgentRequestGuardrails$Outbound> | undefined;
 };
@@ -5280,28 +3988,7 @@ export const Settings$outboundSchema: z.ZodType<
     "respect_tool",
   ),
   chatExposed: z.boolean().optional(),
-  tools: z.array(
-    z.union([
-      z.lazy(() => GoogleSearchTool$outboundSchema),
-      z.lazy(() => WebScraperTool$outboundSchema),
-      z.lazy(() => CallSubAgentTool$outboundSchema),
-      z.lazy(() => RetrieveAgentsTool$outboundSchema),
-      z.lazy(() => QueryMemoryStoreTool$outboundSchema),
-      z.lazy(() => WriteMemoryStoreTool$outboundSchema),
-      z.lazy(() => RetrieveMemoryStoresTool$outboundSchema),
-      z.lazy(() => DeleteMemoryDocumentTool$outboundSchema),
-      z.lazy(() => RetrieveKnowledgeBasesTool$outboundSchema),
-      z.lazy(() => QueryKnowledgeBaseTool$outboundSchema),
-      z.lazy(() => CurrentDateTool$outboundSchema),
-      z.lazy(() => CodeInterpreterTool$outboundSchema),
-      z.lazy(() => MCPTool$outboundSchema),
-      z.lazy(() => ProviderBuiltInTool$outboundSchema),
-      z.lazy(() => HTTPTool$outboundSchema),
-      z.lazy(() => CodeExecutionTool$outboundSchema),
-      z.lazy(() => FunctionTool$outboundSchema),
-      z.lazy(() => JSONSchemaTool$outboundSchema),
-    ]),
-  ).optional(),
+  tools: z.array(components.AgentToolInputCRUD$outboundSchema).optional(),
   evaluators: z.array(z.lazy(() => Evaluators$outboundSchema)).optional(),
   guardrails: z.array(z.lazy(() => CreateAgentRequestGuardrails$outboundSchema))
     .optional(),
@@ -5570,7 +4257,7 @@ export const CreateAgentRequestTools$inboundSchema: z.ZodType<
   requires_approval: z.boolean().default(false),
   tool_id: z.string().optional(),
   conditions: z.array(z.lazy(() => Conditions$inboundSchema)).optional(),
-  timeout: z.number().default(120),
+  timeout: z.number().optional(),
 }).transform((v) => {
   return remap$(v, {
     "action_type": "actionType",
@@ -7151,7 +5838,7 @@ export const CreateAgentRequestResponseBody$inboundSchema: z.ZodType<
   team_of_agents: z.array(
     z.lazy(() => CreateAgentRequestTeamOfAgents$inboundSchema),
   ).optional(),
-  skills: z.array(z.string()),
+  skills: z.array(z.string()).optional(),
   metrics: z.lazy(() => Metrics$inboundSchema).optional(),
   variables: z.record(z.any()).optional(),
   knowledge_bases: z.array(