@orq-ai/node 4.10.12 → 4.10.13

package/models/operations/updatetool.js

@@ -371,7 +371,7 @@ function updateToolRequestBodyToolsSchemaToJSON(updateToolRequestBodyToolsSchema
 }
 /** @internal */
 exports.RequestBodyTools$outboundSchema = z.object({
-    id: z.string().default("01KTN221J0SM28ZDA4TDY05KHP"),
+    id: z.string().default("01KTRCGTMKDQ8QG8BWGK8CBXDS"),
     name: z.string(),
     description: z.string().optional(),
     schema: z.lazy(() => exports.UpdateToolRequestBodyToolsSchema$outboundSchema),
@@ -666,7 +666,7 @@ function updateToolResponseBodyCodeToolFromJSON(jsonString) {
 }
 /** @internal */
 exports.UpdateToolResponseBodyCodeExecutionTool$inboundSchema = z.object({
-    _id: z.string().default("tool_01KTN221HNXEY5Q0YXA58PYHNR"),
+    _id: z.string().default("tool_01KTRCGTMCKFG9Q147Q0TACD2P"),
     path: z.string(),
     key: z.string(),
     display_name: z.string().optional(),
@@ -719,7 +719,7 @@ function updateToolResponseBodyToolsSchemaFromJSON(jsonString) {
 }
 /** @internal */
 exports.UpdateToolResponseBodyTools$inboundSchema = z.object({
-    id: z.string().default("01KTN221HKRTCZR6RFXARJKZF9"),
+    id: z.string().default("01KTRCGTMBMVFAQGWD0M85MJXC"),
     name: z.string(),
     description: z.string().optional(),
     schema: z.lazy(() => exports.UpdateToolResponseBodyToolsSchema$inboundSchema),
@@ -749,7 +749,7 @@ function updateToolResponseBodyMcpFromJSON(jsonString) {
 }
 /** @internal */
 exports.UpdateToolResponseBodyMCPTool$inboundSchema = z.object({
-    _id: z.string().default("tool_01KTN221HHQ9B0TVV5ZM6BGVCX"),
+    _id: z.string().default("tool_01KTRCGTMA5XVCTFNR04JA09ZZ"),
     path: z.string(),
     key: z.string(),
     display_name: z.string().optional(),
@@ -836,7 +836,7 @@ function updateToolResponseBodyHttpFromJSON(jsonString) {
 }
 /** @internal */
 exports.UpdateToolResponseBodyHTTPTool$inboundSchema = z.object({
-    _id: z.string().default("tool_01KTN221HD3N2N02908DKTQKWT"),
+    _id: z.string().default("tool_01KTRCGTM7JSBG1FC223W7JXXD"),
     path: z.string(),
     key: z.string(),
     display_name: z.string().optional(),
@@ -886,7 +886,7 @@ function updateToolResponseBodyJsonSchemaFromJSON(jsonString) {
 }
 /** @internal */
 exports.UpdateToolResponseBodyJSONSchemaTool$inboundSchema = z.object({
-    _id: z.string().default("tool_01KTN221HB3VP7CJPBVBYFH2VN"),
+    _id: z.string().default("tool_01KTRCGTM67DSB1TEB6VHSM5AB"),
     path: z.string(),
     key: z.string(),
     display_name: z.string().optional(),
@@ -940,7 +940,7 @@ function updateToolResponseBodyFunctionFromJSON(jsonString) {
 }
 /** @internal */
 exports.UpdateToolResponseBodyFunctionTool$inboundSchema = z.object({
-    _id: z.string().default("tool_01KTN221H82QYD84ZK14Z2AJ8K"),
+    _id: z.string().default("tool_01KTRCGTM45Q93ZXRY2XHXMQ10"),
     path: z.string(),
     key: z.string(),
     display_name: z.string().optional(),

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@orq-ai/node",
-  "version": "4.10.12",
+  "version": "4.10.13",
   "author": "Orq",
   "exports": {
+    ".": {
+      "import": "./index.js",
+      "require": "./index.js",
+      "types": "./index.d.ts"
+    },
     "./*": "./*",
     "./langchain": {
       "import": "./langchain/index.mjs",
       "require": "./langchain/index.js",
       "types": "./langchain/index.d.mts"
-    },
-    ".": {
-      "types": "./index.d.ts",
-      "import": "./index.js",
-      "require": "./index.js"
     }
   },
   "main": "./index.js",

package/packages/orq-rc/src/hooks/types.ts

@@ -15,6 +15,7 @@ export type HookContext = {
   retryConfig: RetryConfig;
   resolvedSecurity: SecurityState | null;
   options: SDKOptions;
+  timeoutMs?: number;
 };
 
 export type Awaitable<T> = T | Promise<T>;

package/packages/orq-rc/src/lib/config.ts

@@ -58,7 +58,7 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "2.0",
-  sdkVersion: "4.11.0-rc.3",
-  genVersion: "2.893.0",
-  userAgent: "speakeasy-sdk/typescript 4.11.0-rc.3 2.893.0 2.0 @orq-ai/node",
+  sdkVersion: "4.11.0-rc.8",
+  genVersion: "2.899.1",
+  userAgent: "speakeasy-sdk/typescript 4.11.0-rc.8 2.899.1 2.0 @orq-ai/node",
 } as const;

package/packages/orq-rc/src/lib/sdks.ts

@@ -24,6 +24,7 @@ import {
   matchContentType,
 } from "./http.js";
 import { Logger } from "./logger.js";
+import { combineSignals } from "./primitives.js";
 import { retry, RetryConfig } from "./retries.js";
 import { SecurityState } from "./security.js";
 
@@ -198,9 +199,8 @@ export class ClientSDK {
       ...options?.fetchOptions,
       ...options,
     };
-    if (!fetchOptions?.signal && conf.timeoutMs && conf.timeoutMs > 0) {
-      const timeoutSignal = AbortSignal.timeout(conf.timeoutMs);
-      fetchOptions.signal = timeoutSignal;
+    if (!fetchOptions?.signal && conf.timeoutMs != null && conf.timeoutMs > 0) {
+      context.timeoutMs = conf.timeoutMs;
     }
 
     if (conf.body instanceof ReadableStream) {
@@ -247,10 +247,19 @@ export class ClientSDK {
     >
   > {
     const { context, isErrorStatusCode } = options;
+    const timeoutMs = context.timeoutMs;
 
     return retry(
       async () => {
-        const req = await this.#hooks.beforeRequest(context, request.clone());
+        const cloned = request.clone();
+        let attempt = cloned;
+        if (timeoutMs != null && timeoutMs > 0) {
+          const timeoutSignal = AbortSignal.timeout(timeoutMs);
+          const combined = combineSignals(cloned.signal, timeoutSignal)
+            ?? timeoutSignal;
+          attempt = new Request(cloned, { signal: combined });
+        }
+        const req = await this.#hooks.beforeRequest(context, attempt);
         await logRequest(this.#logger, req).catch((e) =>
           this.#logger?.log("Failed to log request:", e)
         );

package/packages/orq-rc/src/models/components/index.ts

@@ -116,6 +116,7 @@ export * from "./publicembeddingdata.js";
 export * from "./publicembeddingusage.js";
 export * from "./publicidentity.js";
 export * from "./publicmodelentry.js";
+export * from "./publicresponseresource.js";
 export * from "./publicschedule.js";
 export * from "./publicscheduleerrordetail.js";
 export * from "./publicschedulepayload.js";
@@ -131,16 +132,63 @@ export * from "./redactrequest.js";
 export * from "./redactresponse.js";
 export * from "./refusalpartschema.js";
 export * from "./requestlimit.js";
+export * from "./responsecodeinterpretercallcodedeltastreamevent.js";
+export * from "./responsecodeinterpretercallcodedonestreamevent.js";
+export * from "./responsecodeinterpretercallcompletedstreamevent.js";
+export * from "./responsecodeinterpretercallinprogressstreamevent.js";
+export * from "./responsecodeinterpretercallinterpretingstreamevent.js";
+export * from "./responsecompletedstreamevent.js";
+export * from "./responsecontentpartaddedstreamevent.js";
+export * from "./responsecontentpartdonestreamevent.js";
+export * from "./responsecreatedstreamevent.js";
 export * from "./responsedoneevent.js";
 export * from "./responseerror.js";
+export * from "./responseerrorstreamevent.js";
 export * from "./responseexecutionlimits.js";
 export * from "./responsefailedevent.js";
+export * from "./responsefailedstreamevent.js";
+export * from "./responsefilesearchcallcompletedstreamevent.js";
+export * from "./responsefilesearchcallinprogressstreamevent.js";
+export * from "./responsefilesearchcallsearchingstreamevent.js";
+export * from "./responsefunctioncallargumentsdeltastreamevent.js";
+export * from "./responsefunctioncallargumentsdonestreamevent.js";
 export * from "./responseidentity.js";
+export * from "./responseimagegenerationcallcompletedstreamevent.js";
+export * from "./responseimagegenerationcallgeneratingstreamevent.js";
+export * from "./responseimagegenerationcallinprogressstreamevent.js";
+export * from "./responseimagegenerationcallpartialimagestreamevent.js";
+export * from "./responseincompletestreamevent.js";
+export * from "./responseinprogressstreamevent.js";
+export * from "./responsemcpcallargumentsdeltastreamevent.js";
+export * from "./responsemcpcallargumentsdonestreamevent.js";
+export * from "./responsemcpcallcompletedstreamevent.js";
+export * from "./responsemcpcallfailedstreamevent.js";
+export * from "./responsemcpcallinprogressstreamevent.js";
 export * from "./responsemeta.js";
+export * from "./responseoutputitemaddedstreamevent.js";
+export * from "./responseoutputitemdonestreamevent.js";
+export * from "./responseoutputtextannotationaddedstreamevent.js";
+export * from "./responseoutputtextdeltastreamevent.js";
+export * from "./responseoutputtextdonestreamevent.js";
+export * from "./responsequeuedstreamevent.js";
+export * from "./responsereasoningdeltastreamevent.js";
+export * from "./responsereasoningdonestreamevent.js";
+export * from "./responsereasoningsummarypartaddedstreamevent.js";
+export * from "./responsereasoningsummarypartdonestreamevent.js";
+export * from "./responsereasoningsummarytextdeltastreamevent.js";
+export * from "./responsereasoningsummarytextdonestreamevent.js";
+export * from "./responsereasoningtextdeltastreamevent.js";
+export * from "./responsereasoningtextdonestreamevent.js";
+export * from "./responserefusaldeltastreamevent.js";
+export * from "./responserefusaldonestreamevent.js";
 export * from "./responseretryconfig.js";
 export * from "./responsestartedevent.js";
+export * from "./responsestreamevent.js";
 export * from "./responsestreamingevent.js";
 export * from "./responsethread.js";
+export * from "./responsewebsearchcallcompletedstreamevent.js";
+export * from "./responsewebsearchcallinprogressstreamevent.js";
+export * from "./responsewebsearchcallsearchingstreamevent.js";
 export * from "./restorerequest.js";
 export * from "./restoreresponse.js";
 export * from "./retrieveidentityresponse.js";

package/packages/orq-rc/src/models/components/modelmetadata.ts

@@ -84,6 +84,7 @@ export type ModelMetadata = {
   supportsAudioOutput?: boolean | undefined;
   supportsB64JsonResponseFormat?: boolean | undefined;
   supportsBatchApi?: boolean | undefined;
+  supportsCacheControl?: boolean | undefined;
   supportsCodeExecution?: boolean | undefined;
   supportsCommercialUse?: boolean | undefined;
   supportsComputerUse?: boolean | undefined;
@@ -202,6 +203,7 @@ export const ModelMetadata$inboundSchema: z.ZodType<
   supports_audio_output: z.boolean().optional(),
   supports_b64_json_response_format: z.boolean().optional(),
   supports_batch_api: z.boolean().optional(),
+  supports_cache_control: z.boolean().optional(),
   supports_code_execution: z.boolean().optional(),
   supports_commercial_use: z.boolean().optional(),
   supports_computer_use: z.boolean().optional(),
@@ -313,6 +315,7 @@ export const ModelMetadata$inboundSchema: z.ZodType<
     "supports_audio_output": "supportsAudioOutput",
     "supports_b64_json_response_format": "supportsB64JsonResponseFormat",
     "supports_batch_api": "supportsBatchApi",
+    "supports_cache_control": "supportsCacheControl",
     "supports_code_execution": "supportsCodeExecution",
     "supports_commercial_use": "supportsCommercialUse",
     "supports_computer_use": "supportsComputerUse",
@@ -427,6 +430,7 @@ export type ModelMetadata$Outbound = {
   supports_audio_output?: boolean | undefined;
   supports_b64_json_response_format?: boolean | undefined;
   supports_batch_api?: boolean | undefined;
+  supports_cache_control?: boolean | undefined;
   supports_code_execution?: boolean | undefined;
   supports_commercial_use?: boolean | undefined;
   supports_computer_use?: boolean | undefined;
@@ -545,6 +549,7 @@ export const ModelMetadata$outboundSchema: z.ZodType<
   supportsAudioOutput: z.boolean().optional(),
   supportsB64JsonResponseFormat: z.boolean().optional(),
   supportsBatchApi: z.boolean().optional(),
+  supportsCacheControl: z.boolean().optional(),
   supportsCodeExecution: z.boolean().optional(),
   supportsCommercialUse: z.boolean().optional(),
   supportsComputerUse: z.boolean().optional(),
@@ -656,6 +661,7 @@ export const ModelMetadata$outboundSchema: z.ZodType<
     supportsAudioOutput: "supports_audio_output",
     supportsB64JsonResponseFormat: "supports_b64_json_response_format",
     supportsBatchApi: "supports_batch_api",
+    supportsCacheControl: "supports_cache_control",
     supportsCodeExecution: "supports_code_execution",
     supportsCommercialUse: "supports_commercial_use",
     supportsComputerUse: "supports_computer_use",

package/packages/orq-rc/src/models/components/publicresponseresource.ts

@@ -0,0 +1,196 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+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 { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  ConversationParam,
+  ConversationParam$inboundSchema,
+} from "./conversationparam.js";
+import {
+  IncompleteDetails,
+  IncompleteDetails$inboundSchema,
+} from "./incompletedetails.js";
+import { MemoryParam, MemoryParam$inboundSchema } from "./memoryparam.js";
+import { PublicUsage, PublicUsage$inboundSchema } from "./publicusage.js";
+import { Reasoning, Reasoning$inboundSchema } from "./reasoning.js";
+import { ResponseError, ResponseError$inboundSchema } from "./responseerror.js";
+
+export const ServiceTier = {
+  Auto: "auto",
+  Default: "default",
+  Flex: "flex",
+  Priority: "priority",
+} as const;
+export type ServiceTier = ClosedEnum<typeof ServiceTier>;
+
+export const PublicResponseResourceStatus = {
+  Queued: "queued",
+  InProgress: "in_progress",
+  Completed: "completed",
+  Failed: "failed",
+  Incomplete: "incomplete",
+  RequiresAction: "requires_action",
+} as const;
+export type PublicResponseResourceStatus = ClosedEnum<
+  typeof PublicResponseResourceStatus
+>;
+
+export const Truncation = {
+  Disabled: "disabled",
+  Auto: "auto",
+} as const;
+export type Truncation = ClosedEnum<typeof Truncation>;
+
+export type PublicResponseResource = {
+  background: boolean;
+  completedAt: number | null;
+  conversation?: ConversationParam | undefined;
+  createdAt: number;
+  error: ResponseError | null;
+  frequencyPenalty: number;
+  id: string;
+  incompleteDetails: IncompleteDetails | null;
+  /**
+   * Array of input items (messages, function call outputs, etc.)
+   */
+  input: Array<any> | null;
+  instructions: string | null;
+  maxOutputTokens: number | null;
+  maxToolCalls: number | null;
+  memory?: MemoryParam | undefined;
+  /**
+   * Developer-defined key-value pairs attached to the response (OpenAI spec: Map<string, string>).
+   */
+  metadata: { [k: string]: string };
+  model: string;
+  /**
+   * Always "response"
+   */
+  object: string;
+  /**
+   * Array of output items (messages, function calls, reasoning, etc.)
+   */
+  output: Array<any> | null;
+  parallelToolCalls: boolean;
+  presencePenalty: number;
+  previousResponseId: string | null;
+  promptCacheKey: string | null;
+  promptCacheRetention: string | null;
+  reasoning: Reasoning | null;
+  safetyIdentifier: string | null;
+  serviceTier: ServiceTier;
+  status: PublicResponseResourceStatus;
+  store: boolean;
+  temperature: number;
+  /**
+   * Text output configuration including format and verbosity
+   */
+  text?: any | undefined;
+  /**
+   * Tool choice setting: "auto", "none", "required", or a specific function
+   */
+  toolChoice?: any | undefined;
+  /**
+   * Array of tool configurations used in this response
+   */
+  tools: Array<any> | null;
+  topLogprobs: number;
+  topP: number;
+  truncation: Truncation;
+  usage: PublicUsage | null;
+  user: string | null;
+  variables?: { [k: string]: any } | undefined;
+};
+
+/** @internal */
+export const ServiceTier$inboundSchema: z.ZodNativeEnum<typeof ServiceTier> = z
+  .nativeEnum(ServiceTier);
+
+/** @internal */
+export const PublicResponseResourceStatus$inboundSchema: z.ZodNativeEnum<
+  typeof PublicResponseResourceStatus
+> = z.nativeEnum(PublicResponseResourceStatus);
+
+/** @internal */
+export const Truncation$inboundSchema: z.ZodNativeEnum<typeof Truncation> = z
+  .nativeEnum(Truncation);
+
+/** @internal */
+export const PublicResponseResource$inboundSchema: z.ZodType<
+  PublicResponseResource,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  background: z.boolean(),
+  completed_at: z.nullable(z.number().int()),
+  conversation: ConversationParam$inboundSchema.optional(),
+  created_at: z.number().int(),
+  error: z.nullable(ResponseError$inboundSchema),
+  frequency_penalty: z.number(),
+  id: z.string(),
+  incomplete_details: z.nullable(IncompleteDetails$inboundSchema),
+  input: z.nullable(z.array(z.any())),
+  instructions: z.nullable(z.string()),
+  max_output_tokens: z.nullable(z.number().int()),
+  max_tool_calls: z.nullable(z.number().int()),
+  memory: MemoryParam$inboundSchema.optional(),
+  metadata: z.record(z.string()),
+  model: z.string(),
+  object: z.string(),
+  output: z.nullable(z.array(z.any())),
+  parallel_tool_calls: z.boolean(),
+  presence_penalty: z.number(),
+  previous_response_id: z.nullable(z.string()),
+  prompt_cache_key: z.nullable(z.string()),
+  prompt_cache_retention: z.nullable(z.string()),
+  reasoning: z.nullable(Reasoning$inboundSchema),
+  safety_identifier: z.nullable(z.string()),
+  service_tier: ServiceTier$inboundSchema,
+  status: PublicResponseResourceStatus$inboundSchema,
+  store: z.boolean(),
+  temperature: z.number(),
+  text: z.any().optional(),
+  tool_choice: z.any().optional(),
+  tools: z.nullable(z.array(z.any())),
+  top_logprobs: z.number().int(),
+  top_p: z.number(),
+  truncation: Truncation$inboundSchema,
+  usage: z.nullable(PublicUsage$inboundSchema),
+  user: z.nullable(z.string()),
+  variables: z.record(z.any()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "completed_at": "completedAt",
+    "created_at": "createdAt",
+    "frequency_penalty": "frequencyPenalty",
+    "incomplete_details": "incompleteDetails",
+    "max_output_tokens": "maxOutputTokens",
+    "max_tool_calls": "maxToolCalls",
+    "parallel_tool_calls": "parallelToolCalls",
+    "presence_penalty": "presencePenalty",
+    "previous_response_id": "previousResponseId",
+    "prompt_cache_key": "promptCacheKey",
+    "prompt_cache_retention": "promptCacheRetention",
+    "safety_identifier": "safetyIdentifier",
+    "service_tier": "serviceTier",
+    "tool_choice": "toolChoice",
+    "top_logprobs": "topLogprobs",
+    "top_p": "topP",
+  });
+});
+
+export function publicResponseResourceFromJSON(
+  jsonString: string,
+): SafeParseResult<PublicResponseResource, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PublicResponseResource$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PublicResponseResource' from JSON`,
+  );
+}

package/packages/orq-rc/src/models/components/reasoning.ts

@@ -4,22 +4,68 @@
 
 import * as z from "zod/v3";
 import { safeParse } from "../../lib/schemas.js";
+import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
+/**
+ * Constrains effort on reasoning for reasoning models. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
+ */
+export const ReasoningEffort = {
+  None: "none",
+  Minimal: "minimal",
+  Low: "low",
+  Medium: "medium",
+  High: "high",
+  Xhigh: "xhigh",
+} as const;
+/**
+ * Constrains effort on reasoning for reasoning models. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
+ */
+export type ReasoningEffort = ClosedEnum<typeof ReasoningEffort>;
+
+/**
+ * The format of the reasoning summary returned by the model.
+ */
+export const ReasoningSummary = {
+  Concise: "concise",
+  Detailed: "detailed",
+  Auto: "auto",
+} as const;
+/**
+ * The format of the reasoning summary returned by the model.
+ */
+export type ReasoningSummary = ClosedEnum<typeof ReasoningSummary>;
+
 export type Reasoning = {
-  effort?: string | undefined;
-  summary?: string | 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.
+   */
+  effort?: ReasoningEffort | undefined;
+  /**
+   * The format of the reasoning summary returned by the model.
+   */
+  summary?: ReasoningSummary | undefined;
 };
 
+/** @internal */
+export const ReasoningEffort$inboundSchema: z.ZodNativeEnum<
+  typeof ReasoningEffort
+> = z.nativeEnum(ReasoningEffort);
+
+/** @internal */
+export const ReasoningSummary$inboundSchema: z.ZodNativeEnum<
+  typeof ReasoningSummary
+> = z.nativeEnum(ReasoningSummary);
+
 /** @internal */
 export const Reasoning$inboundSchema: z.ZodType<
   Reasoning,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  effort: z.string().optional(),
-  summary: z.string().optional(),
+  effort: ReasoningEffort$inboundSchema.optional(),
+  summary: ReasoningSummary$inboundSchema.optional(),
 });
 
 export function reasoningFromJSON(

package/packages/orq-rc/src/models/components/reasoningparam.ts

@@ -3,12 +3,56 @@
  */
 
 import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+/**
+ * Constrains effort on reasoning for reasoning models. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
+ */
+export const Effort = {
+  None: "none",
+  Minimal: "minimal",
+  Low: "low",
+  Medium: "medium",
+  High: "high",
+  Xhigh: "xhigh",
+} as const;
+/**
+ * Constrains effort on reasoning for reasoning models. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
+ */
+export type Effort = ClosedEnum<typeof Effort>;
+
+/**
+ * The format of the reasoning summary returned by the model.
+ */
+export const Summary = {
+  Concise: "concise",
+  Detailed: "detailed",
+  Auto: "auto",
+} as const;
+/**
+ * The format of the reasoning summary returned by the model.
+ */
+export type Summary = ClosedEnum<typeof Summary>;
 
 export type ReasoningParam = {
-  effort?: string | undefined;
-  summary?: string | 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.
+   */
+  effort?: Effort | undefined;
+  /**
+   * The format of the reasoning summary returned by the model.
+   */
+  summary?: Summary | undefined;
 };
 
+/** @internal */
+export const Effort$outboundSchema: z.ZodNativeEnum<typeof Effort> = z
+  .nativeEnum(Effort);
+
+/** @internal */
+export const Summary$outboundSchema: z.ZodNativeEnum<typeof Summary> = z
+  .nativeEnum(Summary);
+
 /** @internal */
 export type ReasoningParam$Outbound = {
   effort?: string | undefined;
@@ -21,8 +65,8 @@ export const ReasoningParam$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ReasoningParam
 > = z.object({
-  effort: z.string().optional(),
-  summary: z.string().optional(),
+  effort: Effort$outboundSchema.optional(),
+  summary: Summary$outboundSchema.optional(),
 });
 
 export function reasoningParamToJSON(reasoningParam: ReasoningParam): string {

package/packages/orq-rc/src/models/components/reasoningpart.ts

@@ -40,7 +40,7 @@ export const ReasoningPart$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  _id: z.string().default("reasoning_01ktknh3847e3bkxw47qgzhjhd"),
+  _id: z.string().default("reasoning_01ktrbcdc8gdqtz28ppg213zxg"),
   metadata: z.record(z.any()).optional(),
   kind: z.literal("reasoning"),
   reasoning: z.string(),