@orq-ai/node 4.1.0 → 4.1.3

package/src/models/operations/streamrunagent.ts

@@ -117,6 +117,42 @@ export type StreamRunAgentModelConfigurationResponseFormat =
   | StreamRunAgentResponseFormatJSONObject
   | StreamRunAgentResponseFormatJSONSchema;
 
+/**
+ * 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 StreamRunAgentModelConfigurationReasoningEffort = {
+  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 StreamRunAgentModelConfigurationReasoningEffort = ClosedEnum<
+  typeof StreamRunAgentModelConfigurationReasoningEffort
+>;
+
 /**
  * Up to 4 sequences where the API will stop generating further tokens.
  */
@@ -132,48 +168,9 @@ export type StreamRunAgentModelConfigurationStreamOptions = {
   includeUsage?: boolean | undefined;
 };
 
-/**
- * Enables or disables the thinking mode capability
- */
-export const StreamRunAgentModelConfigurationType = {
-  Enabled: "enabled",
-  Disabled: "disabled",
-} as const;
-/**
- * Enables or disables the thinking mode capability
- */
-export type StreamRunAgentModelConfigurationType = ClosedEnum<
-  typeof StreamRunAgentModelConfigurationType
->;
-
-/**
- * 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 StreamRunAgentModelConfigurationThinkingLevel = {
-  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 StreamRunAgentModelConfigurationThinkingLevel = ClosedEnum<
-  typeof StreamRunAgentModelConfigurationThinkingLevel
->;
-
-export type StreamRunAgentModelConfigurationThinking = {
-  /**
-   * Enables or disables the thinking mode capability
-   */
-  type: StreamRunAgentModelConfigurationType;
-  /**
-   * 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?: StreamRunAgentModelConfigurationThinkingLevel | undefined;
-};
+export type StreamRunAgentModelConfigurationThinking =
+  | components.ThinkingConfigDisabledSchema
+  | components.ThinkingConfigEnabledSchema;
 
 /**
  * The type of the tool. Currently, only function is supported.
@@ -227,6 +224,43 @@ export type StreamRunAgentModelConfigurationModalities = ClosedEnum<
   typeof StreamRunAgentModelConfigurationModalities
 >;
 
+/**
+ * The key of the guardrail.
+ */
+export const StreamRunAgentId1 = {
+  OrqPiiDetection: "orq_pii_detection",
+  OrqSexualModeration: "orq_sexual_moderation",
+  OrqHarmfulModeration: "orq_harmful_moderation",
+} as const;
+/**
+ * The key of the guardrail.
+ */
+export type StreamRunAgentId1 = ClosedEnum<typeof StreamRunAgentId1>;
+
+export type StreamRunAgentModelConfigurationId = StreamRunAgentId1 | string;
+
+/**
+ * Determines whether the guardrail runs on the input (user message) or output (model response).
+ */
+export const StreamRunAgentModelConfigurationExecuteOn = {
+  Input: "input",
+  Output: "output",
+} as const;
+/**
+ * Determines whether the guardrail runs on the input (user message) or output (model response).
+ */
+export type StreamRunAgentModelConfigurationExecuteOn = ClosedEnum<
+  typeof StreamRunAgentModelConfigurationExecuteOn
+>;
+
+export type StreamRunAgentModelConfigurationGuardrails = {
+  id: StreamRunAgentId1 | string;
+  /**
+   * Determines whether the guardrail runs on the input (user message) or output (model response).
+   */
+  executeOn: StreamRunAgentModelConfigurationExecuteOn;
+};
+
 /**
  * Model behavior parameters that control how the model generates responses. Common parameters: `temperature` (0-1, randomness), `max_completion_tokens` (max output length), `top_p` (sampling diversity). Advanced: `frequency_penalty`, `presence_penalty`, `response_format` (JSON/structured), `reasoning_effort`, `seed` (reproducibility). Support varies by model - consult AI Gateway documentation.
  */
@@ -276,9 +310,18 @@ export type StreamRunAgentModelConfigurationParameters = {
     | StreamRunAgentResponseFormatJSONSchema
     | 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?: StreamRunAgentModelConfigurationReasoningEffort | undefined;
   /**
    * Adjusts response verbosity. Lower levels yield shorter answers.
    */
@@ -298,7 +341,10 @@ export type StreamRunAgentModelConfigurationParameters = {
     | StreamRunAgentModelConfigurationStreamOptions
     | null
     | undefined;
-  thinking?: StreamRunAgentModelConfigurationThinking | 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.
    */
@@ -329,6 +375,10 @@ export type StreamRunAgentModelConfigurationParameters = {
     | Array<StreamRunAgentModelConfigurationModalities>
     | null
     | undefined;
+  /**
+   * A list of guardrails to apply to the request.
+   */
+  guardrails?: Array<StreamRunAgentModelConfigurationGuardrails> | undefined;
 };
 
 /**
@@ -476,6 +526,41 @@ export type StreamRunAgentFallbackModelConfigurationResponseFormat =
   | StreamRunAgentResponseFormatAgentsJSONObject
   | StreamRunAgentResponseFormatAgentsRequestJSONSchema;
 
+/**
+ * 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 StreamRunAgentFallbackModelConfigurationReasoningEffort = {
+  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 StreamRunAgentFallbackModelConfigurationReasoningEffort =
+  ClosedEnum<typeof StreamRunAgentFallbackModelConfigurationReasoningEffort>;
+
 /**
  * Up to 4 sequences where the API will stop generating further tokens.
  */
@@ -493,50 +578,9 @@ export type StreamRunAgentFallbackModelConfigurationStreamOptions = {
   includeUsage?: boolean | undefined;
 };
 
-/**
- * Enables or disables the thinking mode capability
- */
-export const StreamRunAgentFallbackModelConfigurationType = {
-  Enabled: "enabled",
-  Disabled: "disabled",
-} as const;
-/**
- * Enables or disables the thinking mode capability
- */
-export type StreamRunAgentFallbackModelConfigurationType = ClosedEnum<
-  typeof StreamRunAgentFallbackModelConfigurationType
->;
-
-/**
- * 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 StreamRunAgentFallbackModelConfigurationThinkingLevel = {
-  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 StreamRunAgentFallbackModelConfigurationThinkingLevel = ClosedEnum<
-  typeof StreamRunAgentFallbackModelConfigurationThinkingLevel
->;
-
-export type StreamRunAgentFallbackModelConfigurationThinking = {
-  /**
-   * Enables or disables the thinking mode capability
-   */
-  type: StreamRunAgentFallbackModelConfigurationType;
-  /**
-   * 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?:
-    | StreamRunAgentFallbackModelConfigurationThinkingLevel
-    | undefined;
-};
+export type StreamRunAgentFallbackModelConfigurationThinking =
+  | components.ThinkingConfigDisabledSchema
+  | components.ThinkingConfigEnabledSchema;
 
 /**
  * The type of the tool. Currently, only function is supported.
@@ -590,6 +634,47 @@ export type StreamRunAgentFallbackModelConfigurationModalities = ClosedEnum<
   typeof StreamRunAgentFallbackModelConfigurationModalities
 >;
 
+/**
+ * The key of the guardrail.
+ */
+export const StreamRunAgentIdAgents1 = {
+  OrqPiiDetection: "orq_pii_detection",
+  OrqSexualModeration: "orq_sexual_moderation",
+  OrqHarmfulModeration: "orq_harmful_moderation",
+} as const;
+/**
+ * The key of the guardrail.
+ */
+export type StreamRunAgentIdAgents1 = ClosedEnum<
+  typeof StreamRunAgentIdAgents1
+>;
+
+export type StreamRunAgentFallbackModelConfigurationId =
+  | StreamRunAgentIdAgents1
+  | string;
+
+/**
+ * Determines whether the guardrail runs on the input (user message) or output (model response).
+ */
+export const StreamRunAgentFallbackModelConfigurationExecuteOn = {
+  Input: "input",
+  Output: "output",
+} as const;
+/**
+ * Determines whether the guardrail runs on the input (user message) or output (model response).
+ */
+export type StreamRunAgentFallbackModelConfigurationExecuteOn = ClosedEnum<
+  typeof StreamRunAgentFallbackModelConfigurationExecuteOn
+>;
+
+export type StreamRunAgentFallbackModelConfigurationGuardrails = {
+  id: StreamRunAgentIdAgents1 | string;
+  /**
+   * Determines whether the guardrail runs on the input (user message) or output (model response).
+   */
+  executeOn: StreamRunAgentFallbackModelConfigurationExecuteOn;
+};
+
 /**
  * Optional model parameters specific to this fallback model. Overrides primary model parameters if this fallback is used.
  */
@@ -639,9 +724,20 @@ export type StreamRunAgentFallbackModelConfigurationParameters = {
     | StreamRunAgentResponseFormatAgentsRequestJSONSchema
     | 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?:
+    | StreamRunAgentFallbackModelConfigurationReasoningEffort
+    | undefined;
   /**
    * Adjusts response verbosity. Lower levels yield shorter answers.
    */
@@ -661,7 +757,10 @@ export type StreamRunAgentFallbackModelConfigurationParameters = {
     | StreamRunAgentFallbackModelConfigurationStreamOptions
     | null
     | undefined;
-  thinking?: StreamRunAgentFallbackModelConfigurationThinking | 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.
    */
@@ -692,6 +791,12 @@ export type StreamRunAgentFallbackModelConfigurationParameters = {
     | Array<StreamRunAgentFallbackModelConfigurationModalities>
     | null
     | undefined;
+  /**
+   * A list of guardrails to apply to the request.
+   */
+  guardrails?:
+    | Array<StreamRunAgentFallbackModelConfigurationGuardrails>
+    | undefined;
 };
 
 /**
@@ -1903,6 +2008,15 @@ export function streamRunAgentModelConfigurationResponseFormatFromJSON(
   );
 }
 
+/** @internal */
+export const StreamRunAgentModelConfigurationReasoningEffort$inboundSchema:
+  z.ZodNativeEnum<typeof StreamRunAgentModelConfigurationReasoningEffort> = z
+    .nativeEnum(StreamRunAgentModelConfigurationReasoningEffort);
+/** @internal */
+export const StreamRunAgentModelConfigurationReasoningEffort$outboundSchema:
+  z.ZodNativeEnum<typeof StreamRunAgentModelConfigurationReasoningEffort> =
+    StreamRunAgentModelConfigurationReasoningEffort$inboundSchema;
+
 /** @internal */
 export const StreamRunAgentModelConfigurationStop$inboundSchema: z.ZodType<
   StreamRunAgentModelConfigurationStop,
@@ -1999,64 +2113,29 @@ export function streamRunAgentModelConfigurationStreamOptionsFromJSON(
   );
 }
 
-/** @internal */
-export const StreamRunAgentModelConfigurationType$inboundSchema:
-  z.ZodNativeEnum<typeof StreamRunAgentModelConfigurationType> = z.nativeEnum(
-    StreamRunAgentModelConfigurationType,
-  );
-/** @internal */
-export const StreamRunAgentModelConfigurationType$outboundSchema:
-  z.ZodNativeEnum<typeof StreamRunAgentModelConfigurationType> =
-    StreamRunAgentModelConfigurationType$inboundSchema;
-
-/** @internal */
-export const StreamRunAgentModelConfigurationThinkingLevel$inboundSchema:
-  z.ZodNativeEnum<typeof StreamRunAgentModelConfigurationThinkingLevel> = z
-    .nativeEnum(StreamRunAgentModelConfigurationThinkingLevel);
-/** @internal */
-export const StreamRunAgentModelConfigurationThinkingLevel$outboundSchema:
-  z.ZodNativeEnum<typeof StreamRunAgentModelConfigurationThinkingLevel> =
-    StreamRunAgentModelConfigurationThinkingLevel$inboundSchema;
-
 /** @internal */
 export const StreamRunAgentModelConfigurationThinking$inboundSchema: z.ZodType<
   StreamRunAgentModelConfigurationThinking,
   z.ZodTypeDef,
   unknown
-> = z.object({
-  type: StreamRunAgentModelConfigurationType$inboundSchema,
-  budget_tokens: z.number(),
-  thinking_level: StreamRunAgentModelConfigurationThinkingLevel$inboundSchema
-    .optional(),
-}).transform((v) => {
-  return remap$(v, {
-    "budget_tokens": "budgetTokens",
-    "thinking_level": "thinkingLevel",
-  });
-});
+> = z.union([
+  components.ThinkingConfigDisabledSchema$inboundSchema,
+  components.ThinkingConfigEnabledSchema$inboundSchema,
+]);
 /** @internal */
-export type StreamRunAgentModelConfigurationThinking$Outbound = {
-  type: string;
-  budget_tokens: number;
-  thinking_level?: string | undefined;
-};
+export type StreamRunAgentModelConfigurationThinking$Outbound =
+  | components.ThinkingConfigDisabledSchema$Outbound
+  | components.ThinkingConfigEnabledSchema$Outbound;
 
 /** @internal */
 export const StreamRunAgentModelConfigurationThinking$outboundSchema: z.ZodType<
   StreamRunAgentModelConfigurationThinking$Outbound,
   z.ZodTypeDef,
   StreamRunAgentModelConfigurationThinking
-> = z.object({
-  type: StreamRunAgentModelConfigurationType$outboundSchema,
-  budgetTokens: z.number(),
-  thinkingLevel: StreamRunAgentModelConfigurationThinkingLevel$outboundSchema
-    .optional(),
-}).transform((v) => {
-  return remap$(v, {
-    budgetTokens: "budget_tokens",
-    thinkingLevel: "thinking_level",
-  });
-});
+> = z.union([
+  components.ThinkingConfigDisabledSchema$outboundSchema,
+  components.ThinkingConfigEnabledSchema$outboundSchema,
+]);
 
 export function streamRunAgentModelConfigurationThinkingToJSON(
   streamRunAgentModelConfigurationThinking:
@@ -2243,6 +2322,118 @@ export const StreamRunAgentModelConfigurationModalities$outboundSchema:
   z.ZodNativeEnum<typeof StreamRunAgentModelConfigurationModalities> =
     StreamRunAgentModelConfigurationModalities$inboundSchema;
 
+/** @internal */
+export const StreamRunAgentId1$inboundSchema: z.ZodNativeEnum<
+  typeof StreamRunAgentId1
+> = z.nativeEnum(StreamRunAgentId1);
+/** @internal */
+export const StreamRunAgentId1$outboundSchema: z.ZodNativeEnum<
+  typeof StreamRunAgentId1
+> = StreamRunAgentId1$inboundSchema;
+
+/** @internal */
+export const StreamRunAgentModelConfigurationId$inboundSchema: z.ZodType<
+  StreamRunAgentModelConfigurationId,
+  z.ZodTypeDef,
+  unknown
+> = z.union([StreamRunAgentId1$inboundSchema, z.string()]);
+/** @internal */
+export type StreamRunAgentModelConfigurationId$Outbound = string | string;
+
+/** @internal */
+export const StreamRunAgentModelConfigurationId$outboundSchema: z.ZodType<
+  StreamRunAgentModelConfigurationId$Outbound,
+  z.ZodTypeDef,
+  StreamRunAgentModelConfigurationId
+> = z.union([StreamRunAgentId1$outboundSchema, z.string()]);
+
+export function streamRunAgentModelConfigurationIdToJSON(
+  streamRunAgentModelConfigurationId: StreamRunAgentModelConfigurationId,
+): string {
+  return JSON.stringify(
+    StreamRunAgentModelConfigurationId$outboundSchema.parse(
+      streamRunAgentModelConfigurationId,
+    ),
+  );
+}
+export function streamRunAgentModelConfigurationIdFromJSON(
+  jsonString: string,
+): SafeParseResult<StreamRunAgentModelConfigurationId, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      StreamRunAgentModelConfigurationId$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'StreamRunAgentModelConfigurationId' from JSON`,
+  );
+}
+
+/** @internal */
+export const StreamRunAgentModelConfigurationExecuteOn$inboundSchema:
+  z.ZodNativeEnum<typeof StreamRunAgentModelConfigurationExecuteOn> = z
+    .nativeEnum(StreamRunAgentModelConfigurationExecuteOn);
+/** @internal */
+export const StreamRunAgentModelConfigurationExecuteOn$outboundSchema:
+  z.ZodNativeEnum<typeof StreamRunAgentModelConfigurationExecuteOn> =
+    StreamRunAgentModelConfigurationExecuteOn$inboundSchema;
+
+/** @internal */
+export const StreamRunAgentModelConfigurationGuardrails$inboundSchema:
+  z.ZodType<StreamRunAgentModelConfigurationGuardrails, z.ZodTypeDef, unknown> =
+    z.object({
+      id: z.union([StreamRunAgentId1$inboundSchema, z.string()]),
+      execute_on: StreamRunAgentModelConfigurationExecuteOn$inboundSchema,
+    }).transform((v) => {
+      return remap$(v, {
+        "execute_on": "executeOn",
+      });
+    });
+/** @internal */
+export type StreamRunAgentModelConfigurationGuardrails$Outbound = {
+  id: string | string;
+  execute_on: string;
+};
+
+/** @internal */
+export const StreamRunAgentModelConfigurationGuardrails$outboundSchema:
+  z.ZodType<
+    StreamRunAgentModelConfigurationGuardrails$Outbound,
+    z.ZodTypeDef,
+    StreamRunAgentModelConfigurationGuardrails
+  > = z.object({
+    id: z.union([StreamRunAgentId1$outboundSchema, z.string()]),
+    executeOn: StreamRunAgentModelConfigurationExecuteOn$outboundSchema,
+  }).transform((v) => {
+    return remap$(v, {
+      executeOn: "execute_on",
+    });
+  });
+
+export function streamRunAgentModelConfigurationGuardrailsToJSON(
+  streamRunAgentModelConfigurationGuardrails:
+    StreamRunAgentModelConfigurationGuardrails,
+): string {
+  return JSON.stringify(
+    StreamRunAgentModelConfigurationGuardrails$outboundSchema.parse(
+      streamRunAgentModelConfigurationGuardrails,
+    ),
+  );
+}
+export function streamRunAgentModelConfigurationGuardrailsFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  StreamRunAgentModelConfigurationGuardrails,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      StreamRunAgentModelConfigurationGuardrails$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'StreamRunAgentModelConfigurationGuardrails' from JSON`,
+  );
+}
+
 /** @internal */
 export const StreamRunAgentModelConfigurationParameters$inboundSchema:
   z.ZodType<StreamRunAgentModelConfigurationParameters, z.ZodTypeDef, unknown> =
@@ -2262,7 +2453,9 @@ export const StreamRunAgentModelConfigurationParameters$inboundSchema:
         z.lazy(() => StreamRunAgentResponseFormatJSONObject$inboundSchema),
         z.lazy(() => StreamRunAgentResponseFormatJSONSchema$inboundSchema),
       ]).optional(),
-      reasoning_effort: z.string().optional(),
+      reasoning_effort:
+        StreamRunAgentModelConfigurationReasoningEffort$inboundSchema
+          .optional(),
       verbosity: z.string().optional(),
       seed: z.nullable(z.number()).optional(),
       stop: z.nullable(z.union([z.string(), z.array(z.string())])).optional(),
@@ -2271,9 +2464,10 @@ export const StreamRunAgentModelConfigurationParameters$inboundSchema:
           StreamRunAgentModelConfigurationStreamOptions$inboundSchema
         ),
       ).optional(),
-      thinking: z.lazy(() =>
-        StreamRunAgentModelConfigurationThinking$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(),
@@ -2285,6 +2479,9 @@ export const StreamRunAgentModelConfigurationParameters$inboundSchema:
       modalities: z.nullable(
         z.array(StreamRunAgentModelConfigurationModalities$inboundSchema),
       ).optional(),
+      guardrails: z.array(
+        z.lazy(() => StreamRunAgentModelConfigurationGuardrails$inboundSchema),
+      ).optional(),
     }).transform((v) => {
       return remap$(v, {
         "frequency_penalty": "frequencyPenalty",
@@ -2324,13 +2521,19 @@ export type StreamRunAgentModelConfigurationParameters$Outbound = {
     | StreamRunAgentModelConfigurationStreamOptions$Outbound
     | null
     | undefined;
-  thinking?: StreamRunAgentModelConfigurationThinking$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?: StreamRunAgentToolChoice2$Outbound | string | undefined;
   parallel_tool_calls?: boolean | undefined;
   modalities?: Array<string> | null | undefined;
+  guardrails?:
+    | Array<StreamRunAgentModelConfigurationGuardrails$Outbound>
+    | undefined;
 };
 
 /** @internal */
@@ -2355,7 +2558,8 @@ export const StreamRunAgentModelConfigurationParameters$outboundSchema:
       z.lazy(() => StreamRunAgentResponseFormatJSONObject$outboundSchema),
       z.lazy(() => StreamRunAgentResponseFormatJSONSchema$outboundSchema),
     ]).optional(),
-    reasoningEffort: z.string().optional(),
+    reasoningEffort:
+      StreamRunAgentModelConfigurationReasoningEffort$outboundSchema.optional(),
     verbosity: z.string().optional(),
     seed: z.nullable(z.number()).optional(),
     stop: z.nullable(z.union([z.string(), z.array(z.string())])).optional(),
@@ -2364,9 +2568,10 @@ export const StreamRunAgentModelConfigurationParameters$outboundSchema:
         StreamRunAgentModelConfigurationStreamOptions$outboundSchema
       ),
     ).optional(),
-    thinking: z.lazy(() =>
-      StreamRunAgentModelConfigurationThinking$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(),
@@ -2378,6 +2583,9 @@ export const StreamRunAgentModelConfigurationParameters$outboundSchema:
     modalities: z.nullable(
       z.array(StreamRunAgentModelConfigurationModalities$outboundSchema),
     ).optional(),
+    guardrails: z.array(
+      z.lazy(() => StreamRunAgentModelConfigurationGuardrails$outboundSchema),
+    ).optional(),
   }).transform((v) => {
     return remap$(v, {
       frequencyPenalty: "frequency_penalty",
@@ -2916,6 +3124,17 @@ export function streamRunAgentFallbackModelConfigurationResponseFormatFromJSON(
   );
 }
 
+/** @internal */
+export const StreamRunAgentFallbackModelConfigurationReasoningEffort$inboundSchema:
+  z.ZodNativeEnum<
+    typeof StreamRunAgentFallbackModelConfigurationReasoningEffort
+  > = z.nativeEnum(StreamRunAgentFallbackModelConfigurationReasoningEffort);
+/** @internal */
+export const StreamRunAgentFallbackModelConfigurationReasoningEffort$outboundSchema:
+  z.ZodNativeEnum<
+    typeof StreamRunAgentFallbackModelConfigurationReasoningEffort
+  > = StreamRunAgentFallbackModelConfigurationReasoningEffort$inboundSchema;
+
 /** @internal */
 export const StreamRunAgentFallbackModelConfigurationStop$inboundSchema:
   z.ZodType<
@@ -3020,50 +3239,20 @@ export function streamRunAgentFallbackModelConfigurationStreamOptionsFromJSON(
   );
 }
 
-/** @internal */
-export const StreamRunAgentFallbackModelConfigurationType$inboundSchema:
-  z.ZodNativeEnum<typeof StreamRunAgentFallbackModelConfigurationType> = z
-    .nativeEnum(StreamRunAgentFallbackModelConfigurationType);
-/** @internal */
-export const StreamRunAgentFallbackModelConfigurationType$outboundSchema:
-  z.ZodNativeEnum<typeof StreamRunAgentFallbackModelConfigurationType> =
-    StreamRunAgentFallbackModelConfigurationType$inboundSchema;
-
-/** @internal */
-export const StreamRunAgentFallbackModelConfigurationThinkingLevel$inboundSchema:
-  z.ZodNativeEnum<
-    typeof StreamRunAgentFallbackModelConfigurationThinkingLevel
-  > = z.nativeEnum(StreamRunAgentFallbackModelConfigurationThinkingLevel);
-/** @internal */
-export const StreamRunAgentFallbackModelConfigurationThinkingLevel$outboundSchema:
-  z.ZodNativeEnum<
-    typeof StreamRunAgentFallbackModelConfigurationThinkingLevel
-  > = StreamRunAgentFallbackModelConfigurationThinkingLevel$inboundSchema;
-
 /** @internal */
 export const StreamRunAgentFallbackModelConfigurationThinking$inboundSchema:
   z.ZodType<
     StreamRunAgentFallbackModelConfigurationThinking,
     z.ZodTypeDef,
     unknown
-  > = z.object({
-    type: StreamRunAgentFallbackModelConfigurationType$inboundSchema,
-    budget_tokens: z.number(),
-    thinking_level:
-      StreamRunAgentFallbackModelConfigurationThinkingLevel$inboundSchema
-        .optional(),
-  }).transform((v) => {
-    return remap$(v, {
-      "budget_tokens": "budgetTokens",
-      "thinking_level": "thinkingLevel",
-    });
-  });
+  > = z.union([
+    components.ThinkingConfigDisabledSchema$inboundSchema,
+    components.ThinkingConfigEnabledSchema$inboundSchema,
+  ]);
 /** @internal */
-export type StreamRunAgentFallbackModelConfigurationThinking$Outbound = {
-  type: string;
-  budget_tokens: number;
-  thinking_level?: string | undefined;
-};
+export type StreamRunAgentFallbackModelConfigurationThinking$Outbound =
+  | components.ThinkingConfigDisabledSchema$Outbound
+  | components.ThinkingConfigEnabledSchema$Outbound;
 
 /** @internal */
 export const StreamRunAgentFallbackModelConfigurationThinking$outboundSchema:
@@ -3071,18 +3260,10 @@ export const StreamRunAgentFallbackModelConfigurationThinking$outboundSchema:
     StreamRunAgentFallbackModelConfigurationThinking$Outbound,
     z.ZodTypeDef,
     StreamRunAgentFallbackModelConfigurationThinking
-  > = z.object({
-    type: StreamRunAgentFallbackModelConfigurationType$outboundSchema,
-    budgetTokens: z.number(),
-    thinkingLevel:
-      StreamRunAgentFallbackModelConfigurationThinkingLevel$outboundSchema
-        .optional(),
-  }).transform((v) => {
-    return remap$(v, {
-      budgetTokens: "budget_tokens",
-      thinkingLevel: "thinking_level",
-    });
-  });
+  > = z.union([
+    components.ThinkingConfigDisabledSchema$outboundSchema,
+    components.ThinkingConfigEnabledSchema$outboundSchema,
+  ]);
 
 export function streamRunAgentFallbackModelConfigurationThinkingToJSON(
   streamRunAgentFallbackModelConfigurationThinking:
@@ -3276,6 +3457,128 @@ export const StreamRunAgentFallbackModelConfigurationModalities$outboundSchema:
   z.ZodNativeEnum<typeof StreamRunAgentFallbackModelConfigurationModalities> =
     StreamRunAgentFallbackModelConfigurationModalities$inboundSchema;
 
+/** @internal */
+export const StreamRunAgentIdAgents1$inboundSchema: z.ZodNativeEnum<
+  typeof StreamRunAgentIdAgents1
+> = z.nativeEnum(StreamRunAgentIdAgents1);
+/** @internal */
+export const StreamRunAgentIdAgents1$outboundSchema: z.ZodNativeEnum<
+  typeof StreamRunAgentIdAgents1
+> = StreamRunAgentIdAgents1$inboundSchema;
+
+/** @internal */
+export const StreamRunAgentFallbackModelConfigurationId$inboundSchema:
+  z.ZodType<StreamRunAgentFallbackModelConfigurationId, z.ZodTypeDef, unknown> =
+    z.union([StreamRunAgentIdAgents1$inboundSchema, z.string()]);
+/** @internal */
+export type StreamRunAgentFallbackModelConfigurationId$Outbound =
+  | string
+  | string;
+
+/** @internal */
+export const StreamRunAgentFallbackModelConfigurationId$outboundSchema:
+  z.ZodType<
+    StreamRunAgentFallbackModelConfigurationId$Outbound,
+    z.ZodTypeDef,
+    StreamRunAgentFallbackModelConfigurationId
+  > = z.union([StreamRunAgentIdAgents1$outboundSchema, z.string()]);
+
+export function streamRunAgentFallbackModelConfigurationIdToJSON(
+  streamRunAgentFallbackModelConfigurationId:
+    StreamRunAgentFallbackModelConfigurationId,
+): string {
+  return JSON.stringify(
+    StreamRunAgentFallbackModelConfigurationId$outboundSchema.parse(
+      streamRunAgentFallbackModelConfigurationId,
+    ),
+  );
+}
+export function streamRunAgentFallbackModelConfigurationIdFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  StreamRunAgentFallbackModelConfigurationId,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      StreamRunAgentFallbackModelConfigurationId$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'StreamRunAgentFallbackModelConfigurationId' from JSON`,
+  );
+}
+
+/** @internal */
+export const StreamRunAgentFallbackModelConfigurationExecuteOn$inboundSchema:
+  z.ZodNativeEnum<typeof StreamRunAgentFallbackModelConfigurationExecuteOn> = z
+    .nativeEnum(StreamRunAgentFallbackModelConfigurationExecuteOn);
+/** @internal */
+export const StreamRunAgentFallbackModelConfigurationExecuteOn$outboundSchema:
+  z.ZodNativeEnum<typeof StreamRunAgentFallbackModelConfigurationExecuteOn> =
+    StreamRunAgentFallbackModelConfigurationExecuteOn$inboundSchema;
+
+/** @internal */
+export const StreamRunAgentFallbackModelConfigurationGuardrails$inboundSchema:
+  z.ZodType<
+    StreamRunAgentFallbackModelConfigurationGuardrails,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    id: z.union([StreamRunAgentIdAgents1$inboundSchema, z.string()]),
+    execute_on: StreamRunAgentFallbackModelConfigurationExecuteOn$inboundSchema,
+  }).transform((v) => {
+    return remap$(v, {
+      "execute_on": "executeOn",
+    });
+  });
+/** @internal */
+export type StreamRunAgentFallbackModelConfigurationGuardrails$Outbound = {
+  id: string | string;
+  execute_on: string;
+};
+
+/** @internal */
+export const StreamRunAgentFallbackModelConfigurationGuardrails$outboundSchema:
+  z.ZodType<
+    StreamRunAgentFallbackModelConfigurationGuardrails$Outbound,
+    z.ZodTypeDef,
+    StreamRunAgentFallbackModelConfigurationGuardrails
+  > = z.object({
+    id: z.union([StreamRunAgentIdAgents1$outboundSchema, z.string()]),
+    executeOn: StreamRunAgentFallbackModelConfigurationExecuteOn$outboundSchema,
+  }).transform((v) => {
+    return remap$(v, {
+      executeOn: "execute_on",
+    });
+  });
+
+export function streamRunAgentFallbackModelConfigurationGuardrailsToJSON(
+  streamRunAgentFallbackModelConfigurationGuardrails:
+    StreamRunAgentFallbackModelConfigurationGuardrails,
+): string {
+  return JSON.stringify(
+    StreamRunAgentFallbackModelConfigurationGuardrails$outboundSchema.parse(
+      streamRunAgentFallbackModelConfigurationGuardrails,
+    ),
+  );
+}
+export function streamRunAgentFallbackModelConfigurationGuardrailsFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  StreamRunAgentFallbackModelConfigurationGuardrails,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      StreamRunAgentFallbackModelConfigurationGuardrails$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'StreamRunAgentFallbackModelConfigurationGuardrails' from JSON`,
+  );
+}
+
 /** @internal */
 export const StreamRunAgentFallbackModelConfigurationParameters$inboundSchema:
   z.ZodType<
@@ -3300,7 +3603,9 @@ export const StreamRunAgentFallbackModelConfigurationParameters$inboundSchema:
         StreamRunAgentResponseFormatAgentsRequestJSONSchema$inboundSchema
       ),
     ]).optional(),
-    reasoning_effort: z.string().optional(),
+    reasoning_effort:
+      StreamRunAgentFallbackModelConfigurationReasoningEffort$inboundSchema
+        .optional(),
     verbosity: z.string().optional(),
     seed: z.nullable(z.number()).optional(),
     stop: z.nullable(z.union([z.string(), z.array(z.string())])).optional(),
@@ -3309,9 +3614,10 @@ export const StreamRunAgentFallbackModelConfigurationParameters$inboundSchema:
         StreamRunAgentFallbackModelConfigurationStreamOptions$inboundSchema
       ),
     ).optional(),
-    thinking: z.lazy(() =>
-      StreamRunAgentFallbackModelConfigurationThinking$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(),
@@ -3323,6 +3629,11 @@ export const StreamRunAgentFallbackModelConfigurationParameters$inboundSchema:
     modalities: z.nullable(
       z.array(StreamRunAgentFallbackModelConfigurationModalities$inboundSchema),
     ).optional(),
+    guardrails: z.array(
+      z.lazy(() =>
+        StreamRunAgentFallbackModelConfigurationGuardrails$inboundSchema
+      ),
+    ).optional(),
   }).transform((v) => {
     return remap$(v, {
       "frequency_penalty": "frequencyPenalty",
@@ -3366,7 +3677,8 @@ export type StreamRunAgentFallbackModelConfigurationParameters$Outbound = {
     | null
     | undefined;
   thinking?:
-    | StreamRunAgentFallbackModelConfigurationThinking$Outbound
+    | components.ThinkingConfigDisabledSchema$Outbound
+    | components.ThinkingConfigEnabledSchema$Outbound
     | undefined;
   temperature?: number | null | undefined;
   top_p?: number | null | undefined;
@@ -3374,6 +3686,9 @@ export type StreamRunAgentFallbackModelConfigurationParameters$Outbound = {
   tool_choice?: StreamRunAgentToolChoiceAgents2$Outbound | string | undefined;
   parallel_tool_calls?: boolean | undefined;
   modalities?: Array<string> | null | undefined;
+  guardrails?:
+    | Array<StreamRunAgentFallbackModelConfigurationGuardrails$Outbound>
+    | undefined;
 };
 
 /** @internal */
@@ -3402,7 +3717,9 @@ export const StreamRunAgentFallbackModelConfigurationParameters$outboundSchema:
         StreamRunAgentResponseFormatAgentsRequestJSONSchema$outboundSchema
       ),
     ]).optional(),
-    reasoningEffort: z.string().optional(),
+    reasoningEffort:
+      StreamRunAgentFallbackModelConfigurationReasoningEffort$outboundSchema
+        .optional(),
     verbosity: z.string().optional(),
     seed: z.nullable(z.number()).optional(),
     stop: z.nullable(z.union([z.string(), z.array(z.string())])).optional(),
@@ -3411,9 +3728,10 @@ export const StreamRunAgentFallbackModelConfigurationParameters$outboundSchema:
         StreamRunAgentFallbackModelConfigurationStreamOptions$outboundSchema
       ),
     ).optional(),
-    thinking: z.lazy(() =>
-      StreamRunAgentFallbackModelConfigurationThinking$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(),
@@ -3427,6 +3745,11 @@ export const StreamRunAgentFallbackModelConfigurationParameters$outboundSchema:
         StreamRunAgentFallbackModelConfigurationModalities$outboundSchema,
       ),
     ).optional(),
+    guardrails: z.array(
+      z.lazy(() =>
+        StreamRunAgentFallbackModelConfigurationGuardrails$outboundSchema
+      ),
+    ).optional(),
   }).transform((v) => {
     return remap$(v, {
       frequencyPenalty: "frequency_penalty",
@@ -4112,7 +4435,7 @@ export const AgentToolInputRunTools$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: z.string().default("01KBZ0NWNMAM12ARQZ26RVD977"),
+  id: z.string().default("01KE6QFGE9NNFSRGNPTESA8XMH"),
   name: z.string(),
   description: z.string().optional(),
   schema: z.lazy(() => AgentToolInputRunSchema$inboundSchema),
@@ -4131,7 +4454,7 @@ export const AgentToolInputRunTools$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   AgentToolInputRunTools
 > = z.object({
-  id: z.string().default("01KBZ0NWNMAM12ARQZ26RVD977"),
+  id: z.string().default("01KE6QFGE9NNFSRGNPTESA8XMH"),
   name: z.string(),
   description: z.string().optional(),
   schema: z.lazy(() => AgentToolInputRunSchema$outboundSchema),
@@ -6061,7 +6384,7 @@ export const StreamRunAgentSettings$inboundSchema: z.ZodType<
   tool_approval_required: StreamRunAgentToolApprovalRequired$inboundSchema
     .default("none"),
   max_iterations: z.number().int().default(100),
-  max_execution_time: z.number().int().default(300),
+  max_execution_time: z.number().int().default(600),
   evaluators: z.array(z.lazy(() => StreamRunAgentEvaluators$inboundSchema))
     .optional(),
   guardrails: z.array(z.lazy(() => StreamRunAgentGuardrails$inboundSchema))
@@ -6151,7 +6474,7 @@ export const StreamRunAgentSettings$outboundSchema: z.ZodType<
   toolApprovalRequired: StreamRunAgentToolApprovalRequired$outboundSchema
     .default("none"),
   maxIterations: z.number().int().default(100),
-  maxExecutionTime: z.number().int().default(300),
+  maxExecutionTime: z.number().int().default(600),
   evaluators: z.array(z.lazy(() => StreamRunAgentEvaluators$outboundSchema))
     .optional(),
   guardrails: z.array(z.lazy(() => StreamRunAgentGuardrails$outboundSchema))