@orq-ai/node 4.1.0 → 4.1.3

package/src/models/operations/listagents.ts

@@ -7,6 +7,7 @@ import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
 import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
+import * as components from "../components/index.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type ListAgentsRequest = {
@@ -280,6 +281,42 @@ export type ListAgentsResponseFormat =
   | ListAgentsResponseFormatJSONObject
   | ListAgentsResponseFormatAgentsJSONSchema;
 
+/**
+ * Constrains effort on reasoning for [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
+ *
+ * @remarks
+ *
+ * - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool calls are supported for all reasoning values in gpt-5.1.
+ * - All models before `gpt-5.1` default to `medium` reasoning effort, and do not support `none`.
+ * - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+ * - `xhigh` is currently only supported for `gpt-5.1-codex-max`.
+ *
+ * Any of "none", "minimal", "low", "medium", "high", "xhigh".
+ */
+export const ListAgentsReasoningEffort = {
+  None: "none",
+  Minimal: "minimal",
+  Low: "low",
+  Medium: "medium",
+  High: "high",
+  Xhigh: "xhigh",
+} as const;
+/**
+ * Constrains effort on reasoning for [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
+ *
+ * @remarks
+ *
+ * - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool calls are supported for all reasoning values in gpt-5.1.
+ * - All models before `gpt-5.1` default to `medium` reasoning effort, and do not support `none`.
+ * - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+ * - `xhigh` is currently only supported for `gpt-5.1-codex-max`.
+ *
+ * Any of "none", "minimal", "low", "medium", "high", "xhigh".
+ */
+export type ListAgentsReasoningEffort = ClosedEnum<
+  typeof ListAgentsReasoningEffort
+>;
+
 /**
  * Up to 4 sequences where the API will stop generating further tokens.
  */
@@ -295,46 +332,9 @@ export type ListAgentsStreamOptions = {
   includeUsage?: boolean | undefined;
 };
 
-/**
- * Enables or disables the thinking mode capability
- */
-export const ListAgentsType = {
-  Enabled: "enabled",
-  Disabled: "disabled",
-} as const;
-/**
- * Enables or disables the thinking mode capability
- */
-export type ListAgentsType = ClosedEnum<typeof ListAgentsType>;
-
-/**
- * The level of reasoning the model should use. This setting is supported only by `gemini-3` models. If budget_tokens is specified and `thinking_level` is available, `budget_tokens` will be ignored.
- */
-export const ListAgentsThinkingLevel = {
-  Low: "low",
-  High: "high",
-} as const;
-/**
- * The level of reasoning the model should use. This setting is supported only by `gemini-3` models. If budget_tokens is specified and `thinking_level` is available, `budget_tokens` will be ignored.
- */
-export type ListAgentsThinkingLevel = ClosedEnum<
-  typeof ListAgentsThinkingLevel
->;
-
-export type ListAgentsThinking = {
-  /**
-   * Enables or disables the thinking mode capability
-   */
-  type: ListAgentsType;
-  /**
-   * Determines how many tokens the model can use for its internal reasoning process. Larger budgets can enable more thorough analysis for complex problems, improving response quality. Must be ≥1024 and less than `max_tokens`.
-   */
-  budgetTokens: number;
-  /**
-   * The level of reasoning the model should use. This setting is supported only by `gemini-3` models. If budget_tokens is specified and `thinking_level` is available, `budget_tokens` will be ignored.
-   */
-  thinkingLevel?: ListAgentsThinkingLevel | undefined;
-};
+export type ListAgentsThinking =
+  | components.ThinkingConfigDisabledSchema
+  | components.ThinkingConfigEnabledSchema;
 
 /**
  * The type of the tool. Currently, only function is supported.
@@ -384,6 +384,43 @@ export const ListAgentsModalities = {
 } as const;
 export type ListAgentsModalities = ClosedEnum<typeof ListAgentsModalities>;
 
+/**
+ * The key of the guardrail.
+ */
+export const ListAgentsId1 = {
+  OrqPiiDetection: "orq_pii_detection",
+  OrqSexualModeration: "orq_sexual_moderation",
+  OrqHarmfulModeration: "orq_harmful_moderation",
+} as const;
+/**
+ * The key of the guardrail.
+ */
+export type ListAgentsId1 = ClosedEnum<typeof ListAgentsId1>;
+
+export type ListAgentsId = ListAgentsId1 | string;
+
+/**
+ * Determines whether the guardrail runs on the input (user message) or output (model response).
+ */
+export const ListAgentsAgentsResponseExecuteOn = {
+  Input: "input",
+  Output: "output",
+} as const;
+/**
+ * Determines whether the guardrail runs on the input (user message) or output (model response).
+ */
+export type ListAgentsAgentsResponseExecuteOn = ClosedEnum<
+  typeof ListAgentsAgentsResponseExecuteOn
+>;
+
+export type ListAgentsAgentsGuardrails = {
+  id: ListAgentsId1 | string;
+  /**
+   * Determines whether the guardrail runs on the input (user message) or output (model response).
+   */
+  executeOn: ListAgentsAgentsResponseExecuteOn;
+};
+
 /**
  * Model behavior parameters (snake_case) stored as part of the agent configuration. These become the default parameters used when the agent is executed. Commonly used: temperature (0-1, controls randomness), max_completion_tokens (response length), top_p (nucleus sampling). Advanced: frequency_penalty, presence_penalty, response_format (JSON/structured output), reasoning_effort (for o1/thinking models), seed (reproducibility), stop sequences. Model-specific support varies. Runtime parameters in agent execution requests can override these defaults.
  */
@@ -433,9 +470,18 @@ export type ListAgentsParameters = {
     | ListAgentsResponseFormatAgentsJSONSchema
     | undefined;
   /**
-   * Constrains effort on reasoning for reasoning models. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
+   * Constrains effort on reasoning for [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
+   *
+   * @remarks
+   *
+   * - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool calls are supported for all reasoning values in gpt-5.1.
+   * - All models before `gpt-5.1` default to `medium` reasoning effort, and do not support `none`.
+   * - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+   * - `xhigh` is currently only supported for `gpt-5.1-codex-max`.
+   *
+   * Any of "none", "minimal", "low", "medium", "high", "xhigh".
    */
-  reasoningEffort?: string | undefined;
+  reasoningEffort?: ListAgentsReasoningEffort | undefined;
   /**
    * Adjusts response verbosity. Lower levels yield shorter answers.
    */
@@ -452,7 +498,10 @@ export type ListAgentsParameters = {
    * Options for streaming response. Only set this when you set stream: true.
    */
   streamOptions?: ListAgentsStreamOptions | null | undefined;
-  thinking?: ListAgentsThinking | undefined;
+  thinking?:
+    | components.ThinkingConfigDisabledSchema
+    | components.ThinkingConfigEnabledSchema
+    | undefined;
   /**
    * What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic.
    */
@@ -477,6 +526,10 @@ export type ListAgentsParameters = {
    * Output types that you would like the model to generate. Most models are capable of generating text, which is the default: ["text"]. The gpt-4o-audio-preview model can also be used to generate audio. To request that this model generate both text and audio responses, you can use: ["text", "audio"].
    */
   modalities?: Array<ListAgentsModalities> | null | undefined;
+  /**
+   * A list of guardrails to apply to the request.
+   */
+  guardrails?: Array<ListAgentsAgentsGuardrails> | undefined;
 };
 
 /**
@@ -597,6 +650,42 @@ export type ListAgentsFallbackModelConfigurationResponseFormat =
   | ListAgentsResponseFormatAgentsJSONObject
   | ListAgentsResponseFormatAgentsResponse200JSONSchema;
 
+/**
+ * Constrains effort on reasoning for [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
+ *
+ * @remarks
+ *
+ * - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool calls are supported for all reasoning values in gpt-5.1.
+ * - All models before `gpt-5.1` default to `medium` reasoning effort, and do not support `none`.
+ * - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+ * - `xhigh` is currently only supported for `gpt-5.1-codex-max`.
+ *
+ * Any of "none", "minimal", "low", "medium", "high", "xhigh".
+ */
+export const ListAgentsFallbackModelConfigurationReasoningEffort = {
+  None: "none",
+  Minimal: "minimal",
+  Low: "low",
+  Medium: "medium",
+  High: "high",
+  Xhigh: "xhigh",
+} as const;
+/**
+ * Constrains effort on reasoning for [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
+ *
+ * @remarks
+ *
+ * - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool calls are supported for all reasoning values in gpt-5.1.
+ * - All models before `gpt-5.1` default to `medium` reasoning effort, and do not support `none`.
+ * - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+ * - `xhigh` is currently only supported for `gpt-5.1-codex-max`.
+ *
+ * Any of "none", "minimal", "low", "medium", "high", "xhigh".
+ */
+export type ListAgentsFallbackModelConfigurationReasoningEffort = ClosedEnum<
+  typeof ListAgentsFallbackModelConfigurationReasoningEffort
+>;
+
 /**
  * Up to 4 sequences where the API will stop generating further tokens.
  */
@@ -612,48 +701,9 @@ export type ListAgentsFallbackModelConfigurationStreamOptions = {
   includeUsage?: boolean | undefined;
 };
 
-/**
- * Enables or disables the thinking mode capability
- */
-export const ListAgentsFallbackModelConfigurationType = {
-  Enabled: "enabled",
-  Disabled: "disabled",
-} as const;
-/**
- * Enables or disables the thinking mode capability
- */
-export type ListAgentsFallbackModelConfigurationType = ClosedEnum<
-  typeof ListAgentsFallbackModelConfigurationType
->;
-
-/**
- * The level of reasoning the model should use. This setting is supported only by `gemini-3` models. If budget_tokens is specified and `thinking_level` is available, `budget_tokens` will be ignored.
- */
-export const ListAgentsFallbackModelConfigurationThinkingLevel = {
-  Low: "low",
-  High: "high",
-} as const;
-/**
- * The level of reasoning the model should use. This setting is supported only by `gemini-3` models. If budget_tokens is specified and `thinking_level` is available, `budget_tokens` will be ignored.
- */
-export type ListAgentsFallbackModelConfigurationThinkingLevel = ClosedEnum<
-  typeof ListAgentsFallbackModelConfigurationThinkingLevel
->;
-
-export type ListAgentsFallbackModelConfigurationThinking = {
-  /**
-   * Enables or disables the thinking mode capability
-   */
-  type: ListAgentsFallbackModelConfigurationType;
-  /**
-   * Determines how many tokens the model can use for its internal reasoning process. Larger budgets can enable more thorough analysis for complex problems, improving response quality. Must be ≥1024 and less than `max_tokens`.
-   */
-  budgetTokens: number;
-  /**
-   * The level of reasoning the model should use. This setting is supported only by `gemini-3` models. If budget_tokens is specified and `thinking_level` is available, `budget_tokens` will be ignored.
-   */
-  thinkingLevel?: ListAgentsFallbackModelConfigurationThinkingLevel | undefined;
-};
+export type ListAgentsFallbackModelConfigurationThinking =
+  | components.ThinkingConfigDisabledSchema
+  | components.ThinkingConfigEnabledSchema;
 
 /**
  * The type of the tool. Currently, only function is supported.
@@ -707,6 +757,45 @@ export type ListAgentsFallbackModelConfigurationModalities = ClosedEnum<
   typeof ListAgentsFallbackModelConfigurationModalities
 >;
 
+/**
+ * The key of the guardrail.
+ */
+export const ListAgentsIdAgents1 = {
+  OrqPiiDetection: "orq_pii_detection",
+  OrqSexualModeration: "orq_sexual_moderation",
+  OrqHarmfulModeration: "orq_harmful_moderation",
+} as const;
+/**
+ * The key of the guardrail.
+ */
+export type ListAgentsIdAgents1 = ClosedEnum<typeof ListAgentsIdAgents1>;
+
+export type ListAgentsFallbackModelConfigurationId =
+  | ListAgentsIdAgents1
+  | string;
+
+/**
+ * Determines whether the guardrail runs on the input (user message) or output (model response).
+ */
+export const ListAgentsFallbackModelConfigurationExecuteOn = {
+  Input: "input",
+  Output: "output",
+} as const;
+/**
+ * Determines whether the guardrail runs on the input (user message) or output (model response).
+ */
+export type ListAgentsFallbackModelConfigurationExecuteOn = ClosedEnum<
+  typeof ListAgentsFallbackModelConfigurationExecuteOn
+>;
+
+export type ListAgentsFallbackModelConfigurationGuardrails = {
+  id: ListAgentsIdAgents1 | string;
+  /**
+   * Determines whether the guardrail runs on the input (user message) or output (model response).
+   */
+  executeOn: ListAgentsFallbackModelConfigurationExecuteOn;
+};
+
 /**
  * Optional model parameters specific to this fallback model. Overrides primary model parameters if this fallback is used.
  */
@@ -756,9 +845,20 @@ export type ListAgentsFallbackModelConfigurationParameters = {
     | ListAgentsResponseFormatAgentsResponse200JSONSchema
     | undefined;
   /**
-   * Constrains effort on reasoning for reasoning models. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
+   * Constrains effort on reasoning for [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
+   *
+   * @remarks
+   *
+   * - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool calls are supported for all reasoning values in gpt-5.1.
+   * - All models before `gpt-5.1` default to `medium` reasoning effort, and do not support `none`.
+   * - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+   * - `xhigh` is currently only supported for `gpt-5.1-codex-max`.
+   *
+   * Any of "none", "minimal", "low", "medium", "high", "xhigh".
    */
-  reasoningEffort?: string | undefined;
+  reasoningEffort?:
+    | ListAgentsFallbackModelConfigurationReasoningEffort
+    | undefined;
   /**
    * Adjusts response verbosity. Lower levels yield shorter answers.
    */
@@ -778,7 +878,10 @@ export type ListAgentsFallbackModelConfigurationParameters = {
     | ListAgentsFallbackModelConfigurationStreamOptions
     | null
     | undefined;
-  thinking?: ListAgentsFallbackModelConfigurationThinking | undefined;
+  thinking?:
+    | components.ThinkingConfigDisabledSchema
+    | components.ThinkingConfigEnabledSchema
+    | undefined;
   /**
    * What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic.
    */
@@ -809,6 +912,12 @@ export type ListAgentsFallbackModelConfigurationParameters = {
     | Array<ListAgentsFallbackModelConfigurationModalities>
     | null
     | undefined;
+  /**
+   * A list of guardrails to apply to the request.
+   */
+  guardrails?:
+    | Array<ListAgentsFallbackModelConfigurationGuardrails>
+    | undefined;
 };
 
 /**
@@ -1279,7 +1388,7 @@ export const ListAgentsSettings$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   max_iterations: z.number().int().default(100),
-  max_execution_time: z.number().int().default(300),
+  max_execution_time: z.number().int().default(600),
   tool_approval_required: ListAgentsToolApprovalRequired$inboundSchema.default(
     "respect_tool",
   ),
@@ -1312,7 +1421,7 @@ export const ListAgentsSettings$outboundSchema: z.ZodType<
   ListAgentsSettings
 > = z.object({
   maxIterations: z.number().int().default(100),
-  maxExecutionTime: z.number().int().default(300),
+  maxExecutionTime: z.number().int().default(600),
   toolApprovalRequired: ListAgentsToolApprovalRequired$outboundSchema.default(
     "respect_tool",
   ),
@@ -1641,6 +1750,15 @@ export function listAgentsResponseFormatFromJSON(
   );
 }
 
+/** @internal */
+export const ListAgentsReasoningEffort$inboundSchema: z.ZodNativeEnum<
+  typeof ListAgentsReasoningEffort
+> = z.nativeEnum(ListAgentsReasoningEffort);
+/** @internal */
+export const ListAgentsReasoningEffort$outboundSchema: z.ZodNativeEnum<
+  typeof ListAgentsReasoningEffort
+> = ListAgentsReasoningEffort$inboundSchema;
+
 /** @internal */
 export const ListAgentsStop$inboundSchema: z.ZodType<
   ListAgentsStop,
@@ -1717,61 +1835,29 @@ export function listAgentsStreamOptionsFromJSON(
   );
 }
 
-/** @internal */
-export const ListAgentsType$inboundSchema: z.ZodNativeEnum<
-  typeof ListAgentsType
-> = z.nativeEnum(ListAgentsType);
-/** @internal */
-export const ListAgentsType$outboundSchema: z.ZodNativeEnum<
-  typeof ListAgentsType
-> = ListAgentsType$inboundSchema;
-
-/** @internal */
-export const ListAgentsThinkingLevel$inboundSchema: z.ZodNativeEnum<
-  typeof ListAgentsThinkingLevel
-> = z.nativeEnum(ListAgentsThinkingLevel);
-/** @internal */
-export const ListAgentsThinkingLevel$outboundSchema: z.ZodNativeEnum<
-  typeof ListAgentsThinkingLevel
-> = ListAgentsThinkingLevel$inboundSchema;
-
 /** @internal */
 export const ListAgentsThinking$inboundSchema: z.ZodType<
   ListAgentsThinking,
   z.ZodTypeDef,
   unknown
-> = z.object({
-  type: ListAgentsType$inboundSchema,
-  budget_tokens: z.number(),
-  thinking_level: ListAgentsThinkingLevel$inboundSchema.optional(),
-}).transform((v) => {
-  return remap$(v, {
-    "budget_tokens": "budgetTokens",
-    "thinking_level": "thinkingLevel",
-  });
-});
+> = z.union([
+  components.ThinkingConfigDisabledSchema$inboundSchema,
+  components.ThinkingConfigEnabledSchema$inboundSchema,
+]);
 /** @internal */
-export type ListAgentsThinking$Outbound = {
-  type: string;
-  budget_tokens: number;
-  thinking_level?: string | undefined;
-};
+export type ListAgentsThinking$Outbound =
+  | components.ThinkingConfigDisabledSchema$Outbound
+  | components.ThinkingConfigEnabledSchema$Outbound;
 
 /** @internal */
 export const ListAgentsThinking$outboundSchema: z.ZodType<
   ListAgentsThinking$Outbound,
   z.ZodTypeDef,
   ListAgentsThinking
-> = z.object({
-  type: ListAgentsType$outboundSchema,
-  budgetTokens: z.number(),
-  thinkingLevel: ListAgentsThinkingLevel$outboundSchema.optional(),
-}).transform((v) => {
-  return remap$(v, {
-    budgetTokens: "budget_tokens",
-    thinkingLevel: "thinking_level",
-  });
-});
+> = z.union([
+  components.ThinkingConfigDisabledSchema$outboundSchema,
+  components.ThinkingConfigEnabledSchema$outboundSchema,
+]);
 
 export function listAgentsThinkingToJSON(
   listAgentsThinking: ListAgentsThinking,
@@ -1941,6 +2027,103 @@ export const ListAgentsModalities$outboundSchema: z.ZodNativeEnum<
   typeof ListAgentsModalities
 > = ListAgentsModalities$inboundSchema;
 
+/** @internal */
+export const ListAgentsId1$inboundSchema: z.ZodNativeEnum<
+  typeof ListAgentsId1
+> = z.nativeEnum(ListAgentsId1);
+/** @internal */
+export const ListAgentsId1$outboundSchema: z.ZodNativeEnum<
+  typeof ListAgentsId1
+> = ListAgentsId1$inboundSchema;
+
+/** @internal */
+export const ListAgentsId$inboundSchema: z.ZodType<
+  ListAgentsId,
+  z.ZodTypeDef,
+  unknown
+> = z.union([ListAgentsId1$inboundSchema, z.string()]);
+/** @internal */
+export type ListAgentsId$Outbound = string | string;
+
+/** @internal */
+export const ListAgentsId$outboundSchema: z.ZodType<
+  ListAgentsId$Outbound,
+  z.ZodTypeDef,
+  ListAgentsId
+> = z.union([ListAgentsId1$outboundSchema, z.string()]);
+
+export function listAgentsIdToJSON(listAgentsId: ListAgentsId): string {
+  return JSON.stringify(ListAgentsId$outboundSchema.parse(listAgentsId));
+}
+export function listAgentsIdFromJSON(
+  jsonString: string,
+): SafeParseResult<ListAgentsId, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListAgentsId$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListAgentsId' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListAgentsAgentsResponseExecuteOn$inboundSchema: z.ZodNativeEnum<
+  typeof ListAgentsAgentsResponseExecuteOn
+> = z.nativeEnum(ListAgentsAgentsResponseExecuteOn);
+/** @internal */
+export const ListAgentsAgentsResponseExecuteOn$outboundSchema: z.ZodNativeEnum<
+  typeof ListAgentsAgentsResponseExecuteOn
+> = ListAgentsAgentsResponseExecuteOn$inboundSchema;
+
+/** @internal */
+export const ListAgentsAgentsGuardrails$inboundSchema: z.ZodType<
+  ListAgentsAgentsGuardrails,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.union([ListAgentsId1$inboundSchema, z.string()]),
+  execute_on: ListAgentsAgentsResponseExecuteOn$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "execute_on": "executeOn",
+  });
+});
+/** @internal */
+export type ListAgentsAgentsGuardrails$Outbound = {
+  id: string | string;
+  execute_on: string;
+};
+
+/** @internal */
+export const ListAgentsAgentsGuardrails$outboundSchema: z.ZodType<
+  ListAgentsAgentsGuardrails$Outbound,
+  z.ZodTypeDef,
+  ListAgentsAgentsGuardrails
+> = z.object({
+  id: z.union([ListAgentsId1$outboundSchema, z.string()]),
+  executeOn: ListAgentsAgentsResponseExecuteOn$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    executeOn: "execute_on",
+  });
+});
+
+export function listAgentsAgentsGuardrailsToJSON(
+  listAgentsAgentsGuardrails: ListAgentsAgentsGuardrails,
+): string {
+  return JSON.stringify(
+    ListAgentsAgentsGuardrails$outboundSchema.parse(listAgentsAgentsGuardrails),
+  );
+}
+export function listAgentsAgentsGuardrailsFromJSON(
+  jsonString: string,
+): SafeParseResult<ListAgentsAgentsGuardrails, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListAgentsAgentsGuardrails$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListAgentsAgentsGuardrails' from JSON`,
+  );
+}
+
 /** @internal */
 export const ListAgentsParameters$inboundSchema: z.ZodType<
   ListAgentsParameters,
@@ -1960,14 +2143,17 @@ export const ListAgentsParameters$inboundSchema: z.ZodType<
     z.lazy(() => ListAgentsResponseFormatJSONObject$inboundSchema),
     z.lazy(() => ListAgentsResponseFormatAgentsJSONSchema$inboundSchema),
   ]).optional(),
-  reasoning_effort: z.string().optional(),
+  reasoning_effort: ListAgentsReasoningEffort$inboundSchema.optional(),
   verbosity: z.string().optional(),
   seed: z.nullable(z.number()).optional(),
   stop: z.nullable(z.union([z.string(), z.array(z.string())])).optional(),
   stream_options: z.nullable(
     z.lazy(() => ListAgentsStreamOptions$inboundSchema),
   ).optional(),
-  thinking: z.lazy(() => ListAgentsThinking$inboundSchema).optional(),
+  thinking: z.union([
+    components.ThinkingConfigDisabledSchema$inboundSchema,
+    components.ThinkingConfigEnabledSchema$inboundSchema,
+  ]).optional(),
   temperature: z.nullable(z.number()).optional(),
   top_p: z.nullable(z.number()).optional(),
   top_k: z.nullable(z.number()).optional(),
@@ -1978,6 +2164,8 @@ export const ListAgentsParameters$inboundSchema: z.ZodType<
   parallel_tool_calls: z.boolean().optional(),
   modalities: z.nullable(z.array(ListAgentsModalities$inboundSchema))
     .optional(),
+  guardrails: z.array(z.lazy(() => ListAgentsAgentsGuardrails$inboundSchema))
+    .optional(),
 }).transform((v) => {
   return remap$(v, {
     "frequency_penalty": "frequencyPenalty",
@@ -2014,13 +2202,17 @@ export type ListAgentsParameters$Outbound = {
   seed?: number | null | undefined;
   stop?: string | Array<string> | null | undefined;
   stream_options?: ListAgentsStreamOptions$Outbound | null | undefined;
-  thinking?: ListAgentsThinking$Outbound | undefined;
+  thinking?:
+    | components.ThinkingConfigDisabledSchema$Outbound
+    | components.ThinkingConfigEnabledSchema$Outbound
+    | undefined;
   temperature?: number | null | undefined;
   top_p?: number | null | undefined;
   top_k?: number | null | undefined;
   tool_choice?: ListAgentsToolChoice2$Outbound | string | undefined;
   parallel_tool_calls?: boolean | undefined;
   modalities?: Array<string> | null | undefined;
+  guardrails?: Array<ListAgentsAgentsGuardrails$Outbound> | undefined;
 };
 
 /** @internal */
@@ -2042,14 +2234,17 @@ export const ListAgentsParameters$outboundSchema: z.ZodType<
     z.lazy(() => ListAgentsResponseFormatJSONObject$outboundSchema),
     z.lazy(() => ListAgentsResponseFormatAgentsJSONSchema$outboundSchema),
   ]).optional(),
-  reasoningEffort: z.string().optional(),
+  reasoningEffort: ListAgentsReasoningEffort$outboundSchema.optional(),
   verbosity: z.string().optional(),
   seed: z.nullable(z.number()).optional(),
   stop: z.nullable(z.union([z.string(), z.array(z.string())])).optional(),
   streamOptions: z.nullable(
     z.lazy(() => ListAgentsStreamOptions$outboundSchema),
   ).optional(),
-  thinking: z.lazy(() => ListAgentsThinking$outboundSchema).optional(),
+  thinking: z.union([
+    components.ThinkingConfigDisabledSchema$outboundSchema,
+    components.ThinkingConfigEnabledSchema$outboundSchema,
+  ]).optional(),
   temperature: z.nullable(z.number()).optional(),
   topP: z.nullable(z.number()).optional(),
   topK: z.nullable(z.number()).optional(),
@@ -2060,6 +2255,8 @@ export const ListAgentsParameters$outboundSchema: z.ZodType<
   parallelToolCalls: z.boolean().optional(),
   modalities: z.nullable(z.array(ListAgentsModalities$outboundSchema))
     .optional(),
+  guardrails: z.array(z.lazy(() => ListAgentsAgentsGuardrails$outboundSchema))
+    .optional(),
 }).transform((v) => {
   return remap$(v, {
     frequencyPenalty: "frequency_penalty",
@@ -2485,6 +2682,15 @@ export function listAgentsFallbackModelConfigurationResponseFormatFromJSON(
   );
 }
 
+/** @internal */
+export const ListAgentsFallbackModelConfigurationReasoningEffort$inboundSchema:
+  z.ZodNativeEnum<typeof ListAgentsFallbackModelConfigurationReasoningEffort> =
+    z.nativeEnum(ListAgentsFallbackModelConfigurationReasoningEffort);
+/** @internal */
+export const ListAgentsFallbackModelConfigurationReasoningEffort$outboundSchema:
+  z.ZodNativeEnum<typeof ListAgentsFallbackModelConfigurationReasoningEffort> =
+    ListAgentsFallbackModelConfigurationReasoningEffort$inboundSchema;
+
 /** @internal */
 export const ListAgentsFallbackModelConfigurationStop$inboundSchema: z.ZodType<
   ListAgentsFallbackModelConfigurationStop,
@@ -2587,48 +2793,20 @@ export function listAgentsFallbackModelConfigurationStreamOptionsFromJSON(
   );
 }
 
-/** @internal */
-export const ListAgentsFallbackModelConfigurationType$inboundSchema:
-  z.ZodNativeEnum<typeof ListAgentsFallbackModelConfigurationType> = z
-    .nativeEnum(ListAgentsFallbackModelConfigurationType);
-/** @internal */
-export const ListAgentsFallbackModelConfigurationType$outboundSchema:
-  z.ZodNativeEnum<typeof ListAgentsFallbackModelConfigurationType> =
-    ListAgentsFallbackModelConfigurationType$inboundSchema;
-
-/** @internal */
-export const ListAgentsFallbackModelConfigurationThinkingLevel$inboundSchema:
-  z.ZodNativeEnum<typeof ListAgentsFallbackModelConfigurationThinkingLevel> = z
-    .nativeEnum(ListAgentsFallbackModelConfigurationThinkingLevel);
-/** @internal */
-export const ListAgentsFallbackModelConfigurationThinkingLevel$outboundSchema:
-  z.ZodNativeEnum<typeof ListAgentsFallbackModelConfigurationThinkingLevel> =
-    ListAgentsFallbackModelConfigurationThinkingLevel$inboundSchema;
-
 /** @internal */
 export const ListAgentsFallbackModelConfigurationThinking$inboundSchema:
   z.ZodType<
     ListAgentsFallbackModelConfigurationThinking,
     z.ZodTypeDef,
     unknown
-  > = z.object({
-    type: ListAgentsFallbackModelConfigurationType$inboundSchema,
-    budget_tokens: z.number(),
-    thinking_level:
-      ListAgentsFallbackModelConfigurationThinkingLevel$inboundSchema
-        .optional(),
-  }).transform((v) => {
-    return remap$(v, {
-      "budget_tokens": "budgetTokens",
-      "thinking_level": "thinkingLevel",
-    });
-  });
+  > = z.union([
+    components.ThinkingConfigDisabledSchema$inboundSchema,
+    components.ThinkingConfigEnabledSchema$inboundSchema,
+  ]);
 /** @internal */
-export type ListAgentsFallbackModelConfigurationThinking$Outbound = {
-  type: string;
-  budget_tokens: number;
-  thinking_level?: string | undefined;
-};
+export type ListAgentsFallbackModelConfigurationThinking$Outbound =
+  | components.ThinkingConfigDisabledSchema$Outbound
+  | components.ThinkingConfigEnabledSchema$Outbound;
 
 /** @internal */
 export const ListAgentsFallbackModelConfigurationThinking$outboundSchema:
@@ -2636,18 +2814,10 @@ export const ListAgentsFallbackModelConfigurationThinking$outboundSchema:
     ListAgentsFallbackModelConfigurationThinking$Outbound,
     z.ZodTypeDef,
     ListAgentsFallbackModelConfigurationThinking
-  > = z.object({
-    type: ListAgentsFallbackModelConfigurationType$outboundSchema,
-    budgetTokens: z.number(),
-    thinkingLevel:
-      ListAgentsFallbackModelConfigurationThinkingLevel$outboundSchema
-        .optional(),
-  }).transform((v) => {
-    return remap$(v, {
-      budgetTokens: "budget_tokens",
-      thinkingLevel: "thinking_level",
-    });
-  });
+  > = z.union([
+    components.ThinkingConfigDisabledSchema$outboundSchema,
+    components.ThinkingConfigEnabledSchema$outboundSchema,
+  ]);
 
 export function listAgentsFallbackModelConfigurationThinkingToJSON(
   listAgentsFallbackModelConfigurationThinking:
@@ -2840,6 +3010,122 @@ export const ListAgentsFallbackModelConfigurationModalities$outboundSchema:
   z.ZodNativeEnum<typeof ListAgentsFallbackModelConfigurationModalities> =
     ListAgentsFallbackModelConfigurationModalities$inboundSchema;
 
+/** @internal */
+export const ListAgentsIdAgents1$inboundSchema: z.ZodNativeEnum<
+  typeof ListAgentsIdAgents1
+> = z.nativeEnum(ListAgentsIdAgents1);
+/** @internal */
+export const ListAgentsIdAgents1$outboundSchema: z.ZodNativeEnum<
+  typeof ListAgentsIdAgents1
+> = ListAgentsIdAgents1$inboundSchema;
+
+/** @internal */
+export const ListAgentsFallbackModelConfigurationId$inboundSchema: z.ZodType<
+  ListAgentsFallbackModelConfigurationId,
+  z.ZodTypeDef,
+  unknown
+> = z.union([ListAgentsIdAgents1$inboundSchema, z.string()]);
+/** @internal */
+export type ListAgentsFallbackModelConfigurationId$Outbound = string | string;
+
+/** @internal */
+export const ListAgentsFallbackModelConfigurationId$outboundSchema: z.ZodType<
+  ListAgentsFallbackModelConfigurationId$Outbound,
+  z.ZodTypeDef,
+  ListAgentsFallbackModelConfigurationId
+> = z.union([ListAgentsIdAgents1$outboundSchema, z.string()]);
+
+export function listAgentsFallbackModelConfigurationIdToJSON(
+  listAgentsFallbackModelConfigurationId:
+    ListAgentsFallbackModelConfigurationId,
+): string {
+  return JSON.stringify(
+    ListAgentsFallbackModelConfigurationId$outboundSchema.parse(
+      listAgentsFallbackModelConfigurationId,
+    ),
+  );
+}
+export function listAgentsFallbackModelConfigurationIdFromJSON(
+  jsonString: string,
+): SafeParseResult<ListAgentsFallbackModelConfigurationId, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ListAgentsFallbackModelConfigurationId$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListAgentsFallbackModelConfigurationId' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListAgentsFallbackModelConfigurationExecuteOn$inboundSchema:
+  z.ZodNativeEnum<typeof ListAgentsFallbackModelConfigurationExecuteOn> = z
+    .nativeEnum(ListAgentsFallbackModelConfigurationExecuteOn);
+/** @internal */
+export const ListAgentsFallbackModelConfigurationExecuteOn$outboundSchema:
+  z.ZodNativeEnum<typeof ListAgentsFallbackModelConfigurationExecuteOn> =
+    ListAgentsFallbackModelConfigurationExecuteOn$inboundSchema;
+
+/** @internal */
+export const ListAgentsFallbackModelConfigurationGuardrails$inboundSchema:
+  z.ZodType<
+    ListAgentsFallbackModelConfigurationGuardrails,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    id: z.union([ListAgentsIdAgents1$inboundSchema, z.string()]),
+    execute_on: ListAgentsFallbackModelConfigurationExecuteOn$inboundSchema,
+  }).transform((v) => {
+    return remap$(v, {
+      "execute_on": "executeOn",
+    });
+  });
+/** @internal */
+export type ListAgentsFallbackModelConfigurationGuardrails$Outbound = {
+  id: string | string;
+  execute_on: string;
+};
+
+/** @internal */
+export const ListAgentsFallbackModelConfigurationGuardrails$outboundSchema:
+  z.ZodType<
+    ListAgentsFallbackModelConfigurationGuardrails$Outbound,
+    z.ZodTypeDef,
+    ListAgentsFallbackModelConfigurationGuardrails
+  > = z.object({
+    id: z.union([ListAgentsIdAgents1$outboundSchema, z.string()]),
+    executeOn: ListAgentsFallbackModelConfigurationExecuteOn$outboundSchema,
+  }).transform((v) => {
+    return remap$(v, {
+      executeOn: "execute_on",
+    });
+  });
+
+export function listAgentsFallbackModelConfigurationGuardrailsToJSON(
+  listAgentsFallbackModelConfigurationGuardrails:
+    ListAgentsFallbackModelConfigurationGuardrails,
+): string {
+  return JSON.stringify(
+    ListAgentsFallbackModelConfigurationGuardrails$outboundSchema.parse(
+      listAgentsFallbackModelConfigurationGuardrails,
+    ),
+  );
+}
+export function listAgentsFallbackModelConfigurationGuardrailsFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  ListAgentsFallbackModelConfigurationGuardrails,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      ListAgentsFallbackModelConfigurationGuardrails$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'ListAgentsFallbackModelConfigurationGuardrails' from JSON`,
+  );
+}
+
 /** @internal */
 export const ListAgentsFallbackModelConfigurationParameters$inboundSchema:
   z.ZodType<
@@ -2864,7 +3150,9 @@ export const ListAgentsFallbackModelConfigurationParameters$inboundSchema:
         ListAgentsResponseFormatAgentsResponse200JSONSchema$inboundSchema
       ),
     ]).optional(),
-    reasoning_effort: z.string().optional(),
+    reasoning_effort:
+      ListAgentsFallbackModelConfigurationReasoningEffort$inboundSchema
+        .optional(),
     verbosity: z.string().optional(),
     seed: z.nullable(z.number()).optional(),
     stop: z.nullable(z.union([z.string(), z.array(z.string())])).optional(),
@@ -2873,9 +3161,10 @@ export const ListAgentsFallbackModelConfigurationParameters$inboundSchema:
         ListAgentsFallbackModelConfigurationStreamOptions$inboundSchema
       ),
     ).optional(),
-    thinking: z.lazy(() =>
-      ListAgentsFallbackModelConfigurationThinking$inboundSchema
-    ).optional(),
+    thinking: z.union([
+      components.ThinkingConfigDisabledSchema$inboundSchema,
+      components.ThinkingConfigEnabledSchema$inboundSchema,
+    ]).optional(),
     temperature: z.nullable(z.number()).optional(),
     top_p: z.nullable(z.number()).optional(),
     top_k: z.nullable(z.number()).optional(),
@@ -2887,6 +3176,11 @@ export const ListAgentsFallbackModelConfigurationParameters$inboundSchema:
     modalities: z.nullable(
       z.array(ListAgentsFallbackModelConfigurationModalities$inboundSchema),
     ).optional(),
+    guardrails: z.array(
+      z.lazy(() =>
+        ListAgentsFallbackModelConfigurationGuardrails$inboundSchema
+      ),
+    ).optional(),
   }).transform((v) => {
     return remap$(v, {
       "frequency_penalty": "frequencyPenalty",
@@ -2926,13 +3220,19 @@ export type ListAgentsFallbackModelConfigurationParameters$Outbound = {
     | ListAgentsFallbackModelConfigurationStreamOptions$Outbound
     | null
     | undefined;
-  thinking?: ListAgentsFallbackModelConfigurationThinking$Outbound | undefined;
+  thinking?:
+    | components.ThinkingConfigDisabledSchema$Outbound
+    | components.ThinkingConfigEnabledSchema$Outbound
+    | undefined;
   temperature?: number | null | undefined;
   top_p?: number | null | undefined;
   top_k?: number | null | undefined;
   tool_choice?: ListAgentsToolChoiceAgents2$Outbound | string | undefined;
   parallel_tool_calls?: boolean | undefined;
   modalities?: Array<string> | null | undefined;
+  guardrails?:
+    | Array<ListAgentsFallbackModelConfigurationGuardrails$Outbound>
+    | undefined;
 };
 
 /** @internal */
@@ -2959,7 +3259,9 @@ export const ListAgentsFallbackModelConfigurationParameters$outboundSchema:
         ListAgentsResponseFormatAgentsResponse200JSONSchema$outboundSchema
       ),
     ]).optional(),
-    reasoningEffort: z.string().optional(),
+    reasoningEffort:
+      ListAgentsFallbackModelConfigurationReasoningEffort$outboundSchema
+        .optional(),
     verbosity: z.string().optional(),
     seed: z.nullable(z.number()).optional(),
     stop: z.nullable(z.union([z.string(), z.array(z.string())])).optional(),
@@ -2968,9 +3270,10 @@ export const ListAgentsFallbackModelConfigurationParameters$outboundSchema:
         ListAgentsFallbackModelConfigurationStreamOptions$outboundSchema
       ),
     ).optional(),
-    thinking: z.lazy(() =>
-      ListAgentsFallbackModelConfigurationThinking$outboundSchema
-    ).optional(),
+    thinking: z.union([
+      components.ThinkingConfigDisabledSchema$outboundSchema,
+      components.ThinkingConfigEnabledSchema$outboundSchema,
+    ]).optional(),
     temperature: z.nullable(z.number()).optional(),
     topP: z.nullable(z.number()).optional(),
     topK: z.nullable(z.number()).optional(),
@@ -2982,6 +3285,11 @@ export const ListAgentsFallbackModelConfigurationParameters$outboundSchema:
     modalities: z.nullable(
       z.array(ListAgentsFallbackModelConfigurationModalities$outboundSchema),
     ).optional(),
+    guardrails: z.array(
+      z.lazy(() =>
+        ListAgentsFallbackModelConfigurationGuardrails$outboundSchema
+      ),
+    ).optional(),
   }).transform((v) => {
     return remap$(v, {
       frequencyPenalty: "frequency_penalty",