@orq-ai/node 4.15.0-rc.5 → 4.15.0-rc.51

package/src/models/components/modelmetadata.ts

@@ -41,6 +41,7 @@ export type ModelMetadata = {
   embeddingDimensions?: number | undefined;
   extendedContextPricingMode?: string | undefined;
   extendedContextThreshold?: number | undefined;
+  functionToolsRequireEffortNone?: boolean | undefined;
   generateAudio?: boolean | undefined;
   imageInputCost?: number | undefined;
   imageOutputCost?: number | undefined;
@@ -172,6 +173,7 @@ export const ModelMetadata$inboundSchema: z.ZodType<
   embedding_dimensions: z.number().int().optional(),
   extended_context_pricing_mode: z.string().optional(),
   extended_context_threshold: z.number().int().optional(),
+  function_tools_require_effort_none: z.boolean().optional(),
   generate_audio: z.boolean().optional(),
   image_input_cost: z.number().optional(),
   image_output_cost: z.number().optional(),
@@ -297,6 +299,7 @@ export const ModelMetadata$inboundSchema: z.ZodType<
     "embedding_dimensions": "embeddingDimensions",
     "extended_context_pricing_mode": "extendedContextPricingMode",
     "extended_context_threshold": "extendedContextThreshold",
+    "function_tools_require_effort_none": "functionToolsRequireEffortNone",
     "generate_audio": "generateAudio",
     "image_input_cost": "imageInputCost",
     "image_output_cost": "imageOutputCost",
@@ -424,6 +427,7 @@ export type ModelMetadata$Outbound = {
   embedding_dimensions?: number | undefined;
   extended_context_pricing_mode?: string | undefined;
   extended_context_threshold?: number | undefined;
+  function_tools_require_effort_none?: boolean | undefined;
   generate_audio?: boolean | undefined;
   image_input_cost?: number | undefined;
   image_output_cost?: number | undefined;
@@ -557,6 +561,7 @@ export const ModelMetadata$outboundSchema: z.ZodType<
   embeddingDimensions: z.number().int().optional(),
   extendedContextPricingMode: z.string().optional(),
   extendedContextThreshold: z.number().int().optional(),
+  functionToolsRequireEffortNone: z.boolean().optional(),
   generateAudio: z.boolean().optional(),
   imageInputCost: z.number().optional(),
   imageOutputCost: z.number().optional(),
@@ -682,6 +687,7 @@ export const ModelMetadata$outboundSchema: z.ZodType<
     embeddingDimensions: "embedding_dimensions",
     extendedContextPricingMode: "extended_context_pricing_mode",
     extendedContextThreshold: "extended_context_threshold",
+    functionToolsRequireEffortNone: "function_tools_require_effort_none",
     generateAudio: "generate_audio",
     imageInputCost: "image_input_cost",
     imageOutputCost: "image_output_cost",

package/src/models/components/modelsconfig.ts

@@ -14,26 +14,27 @@ import {
   ModelRef$outboundSchema,
 } from "./modelref.js";
 
-export const Mode = {
+export const ModelsConfigMode = {
   Fallback: "fallback",
   LatencyBased: "latency_based",
   Weighted: "weighted",
   RoundRobin: "round_robin",
 } as const;
-export type Mode = ClosedEnum<typeof Mode>;
+export type ModelsConfigMode = ClosedEnum<typeof ModelsConfigMode>;
 
 export type ModelsConfig = {
-  mode: Mode;
+  mode: ModelsConfigMode;
   models: Array<ModelRef> | null;
 };
 
 /** @internal */
-export const Mode$inboundSchema: z.ZodNativeEnum<typeof Mode> = z.nativeEnum(
-  Mode,
-);
+export const ModelsConfigMode$inboundSchema: z.ZodNativeEnum<
+  typeof ModelsConfigMode
+> = z.nativeEnum(ModelsConfigMode);
 /** @internal */
-export const Mode$outboundSchema: z.ZodNativeEnum<typeof Mode> =
-  Mode$inboundSchema;
+export const ModelsConfigMode$outboundSchema: z.ZodNativeEnum<
+  typeof ModelsConfigMode
+> = ModelsConfigMode$inboundSchema;
 
 /** @internal */
 export const ModelsConfig$inboundSchema: z.ZodType<
@@ -41,7 +42,7 @@ export const ModelsConfig$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
-  mode: Mode$inboundSchema,
+  mode: ModelsConfigMode$inboundSchema,
   models: z.nullable(z.array(ModelRef$inboundSchema)),
 });
 /** @internal */
@@ -56,7 +57,7 @@ export const ModelsConfig$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ModelsConfig
 > = z.object({
-  mode: Mode$outboundSchema,
+  mode: ModelsConfigMode$outboundSchema,
   models: z.nullable(z.array(ModelRef$outboundSchema)),
 });
 

package/src/models/components/monitorfilter.ts

@@ -11,16 +11,24 @@ import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 /**
  * Predicate operator. `eq` and `neq` accept exactly one value; `in` and `not_in` accept 1-100 values.
  */
-export const Op = {
+export const MonitorFilterOp = {
   Eq: "eq",
   Neq: "neq",
   In: "in",
   NotIn: "not_in",
+  Gt: "gt",
+  Gte: "gte",
+  Lt: "lt",
+  Lte: "lte",
+  Between: "between",
+  Contains: "contains",
+  Exists: "exists",
+  NotExists: "not_exists",
 } as const;
 /**
  * Predicate operator. `eq` and `neq` accept exactly one value; `in` and `not_in` accept 1-100 values.
  */
-export type Op = ClosedEnum<typeof Op>;
+export type MonitorFilterOp = ClosedEnum<typeof MonitorFilterOp>;
 
 export type MonitorFilter = {
   /**
@@ -33,7 +41,7 @@ export type MonitorFilter = {
   /**
    * Predicate operator. `eq` and `neq` accept exactly one value; `in` and `not_in` accept 1-100 values.
    */
-  op: Op;
+  op: MonitorFilterOp;
   /**
    * Values compared against the selected field.
    */
@@ -41,9 +49,13 @@ export type MonitorFilter = {
 };
 
 /** @internal */
-export const Op$inboundSchema: z.ZodNativeEnum<typeof Op> = z.nativeEnum(Op);
+export const MonitorFilterOp$inboundSchema: z.ZodNativeEnum<
+  typeof MonitorFilterOp
+> = z.nativeEnum(MonitorFilterOp);
 /** @internal */
-export const Op$outboundSchema: z.ZodNativeEnum<typeof Op> = Op$inboundSchema;
+export const MonitorFilterOp$outboundSchema: z.ZodNativeEnum<
+  typeof MonitorFilterOp
+> = MonitorFilterOp$inboundSchema;
 
 /** @internal */
 export const MonitorFilter$inboundSchema: z.ZodType<
@@ -52,7 +64,7 @@ export const MonitorFilter$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   field: z.string(),
-  op: Op$inboundSchema,
+  op: MonitorFilterOp$inboundSchema,
   values: z.array(z.string()),
 });
 /** @internal */
@@ -69,7 +81,7 @@ export const MonitorFilter$outboundSchema: z.ZodType<
   MonitorFilter
 > = z.object({
   field: z.string(),
-  op: Op$outboundSchema,
+  op: MonitorFilterOp$outboundSchema,
   values: z.array(z.string()),
 });
 

package/src/models/components/openaipromptcacheoptions.ts

@@ -0,0 +1,84 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+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";
+
+export const OpenAIPromptCacheOptionsMode = {
+  Implicit: "implicit",
+  Explicit: "explicit",
+} as const;
+export type OpenAIPromptCacheOptionsMode = ClosedEnum<
+  typeof OpenAIPromptCacheOptionsMode
+>;
+
+export const Ttl = {
+  Thirtym: "30m",
+} as const;
+export type Ttl = ClosedEnum<typeof Ttl>;
+
+export type OpenAIPromptCacheOptions = {
+  mode?: OpenAIPromptCacheOptionsMode | undefined;
+  ttl?: Ttl | undefined;
+};
+
+/** @internal */
+export const OpenAIPromptCacheOptionsMode$inboundSchema: z.ZodNativeEnum<
+  typeof OpenAIPromptCacheOptionsMode
+> = z.nativeEnum(OpenAIPromptCacheOptionsMode);
+/** @internal */
+export const OpenAIPromptCacheOptionsMode$outboundSchema: z.ZodNativeEnum<
+  typeof OpenAIPromptCacheOptionsMode
+> = OpenAIPromptCacheOptionsMode$inboundSchema;
+
+/** @internal */
+export const Ttl$inboundSchema: z.ZodNativeEnum<typeof Ttl> = z.nativeEnum(Ttl);
+/** @internal */
+export const Ttl$outboundSchema: z.ZodNativeEnum<typeof Ttl> =
+  Ttl$inboundSchema;
+
+/** @internal */
+export const OpenAIPromptCacheOptions$inboundSchema: z.ZodType<
+  OpenAIPromptCacheOptions,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  mode: OpenAIPromptCacheOptionsMode$inboundSchema.optional(),
+  ttl: Ttl$inboundSchema.optional(),
+});
+/** @internal */
+export type OpenAIPromptCacheOptions$Outbound = {
+  mode?: string | undefined;
+  ttl?: string | undefined;
+};
+
+/** @internal */
+export const OpenAIPromptCacheOptions$outboundSchema: z.ZodType<
+  OpenAIPromptCacheOptions$Outbound,
+  z.ZodTypeDef,
+  OpenAIPromptCacheOptions
+> = z.object({
+  mode: OpenAIPromptCacheOptionsMode$outboundSchema.optional(),
+  ttl: Ttl$outboundSchema.optional(),
+});
+
+export function openAIPromptCacheOptionsToJSON(
+  openAIPromptCacheOptions: OpenAIPromptCacheOptions,
+): string {
+  return JSON.stringify(
+    OpenAIPromptCacheOptions$outboundSchema.parse(openAIPromptCacheOptions),
+  );
+}
+export function openAIPromptCacheOptionsFromJSON(
+  jsonString: string,
+): SafeParseResult<OpenAIPromptCacheOptions, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => OpenAIPromptCacheOptions$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'OpenAIPromptCacheOptions' from JSON`,
+  );
+}

package/src/models/components/piiredactionconfig.ts

@@ -9,18 +9,16 @@ import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 /**
- * PiiRedactionConfig mirrors the workspace-default PII redaction plugin config
+ * PiiRedactionConfig mirrors the workspace-default PII redaction plugin
  *
  * @remarks
- *  (libs/go/models PIIRedactionPlugin / libs/models/gateway
- *  PIIRedactionPluginSchema). Every field is optional; the gateway applies its
- *  own defaults for unset fields.
+ *  configuration. Every field is optional; the gateway applies its own
+ *  defaults for unset fields.
  *
- *  The stored value is validated on write with the same
- *  models.PIIRedactionPlugin.Validate() the gateway runs per request. Without
- *  that, an invalid workspace default would 400 every gateway call for the
- *  workspace, since the default plugin is injected into each request and
- *  validated there.
+ *  The stored value is validated on write using the same rules the gateway
+ *  applies to live requests. Without that, an invalid workspace default
+ *  would 400 every gateway call for the workspace, since the default plugin
+ *  is injected into each request and validated there.
  */
 export type PiiRedactionConfig = {
   /**

package/src/models/components/piiredactionplugin.ts

@@ -0,0 +1,143 @@
+/*
+ * 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";
+
+/**
+ * PII redaction plugin.
+ */
+export const Id = {
+  PiiRedaction: "pii_redaction",
+} as const;
+/**
+ * PII redaction plugin.
+ */
+export type Id = ClosedEnum<typeof Id>;
+
+/**
+ * Behaviour when detection fails.
+ */
+export const OnFailure = {
+  Block: "block",
+  Passthrough: "passthrough",
+} as const;
+/**
+ * Behaviour when detection fails.
+ */
+export type OnFailure = ClosedEnum<typeof OnFailure>;
+
+export type PIIRedactionPlugin = {
+  /**
+   * PII redaction plugin.
+   */
+  id: Id;
+  /**
+   * Detector language. Use "auto" to auto-detect; omitting the field falls back to en.
+   */
+  language?: string | undefined;
+  /**
+   * Region codes selecting whole regions of coverage (e.g. "nl", "gb"). Every entity type those regions cover is redacted, alongside the base catalog. ["all"] is exclusive, and leaving both this and entities empty also runs every region, so selecting nothing is the widest request rather than the narrowest. Combines with entities: the two selections are unioned, so entities adds types on top of the region coverage.
+   */
+  regions?: Array<string> | undefined;
+  /**
+   * The entity types to redact. A named type is redacted even when it belongs to a region, so a region's types can be selected individually without naming the region. On its own this is a strict allowlist; alongside regions it adds to the region coverage. See GET /v2/pii/capabilities for valid types.
+   */
+  entities?: Array<string> | undefined;
+  /**
+   * Per-entity confidence cutoff overrides in [0,1]. Tunes confidence only and never changes which types are redacted, so every key must also appear in entities.
+   */
+  entityThresholds?: { [k: string]: number } | undefined;
+  /**
+   * Baseline confidence cutoff applied to every entity type without a per-entity override.
+   */
+  threshold?: number | undefined;
+  /**
+   * Behaviour when detection fails.
+   */
+  onFailure?: OnFailure | undefined;
+};
+
+/** @internal */
+export const Id$inboundSchema: z.ZodNativeEnum<typeof Id> = z.nativeEnum(Id);
+/** @internal */
+export const Id$outboundSchema: z.ZodNativeEnum<typeof Id> = Id$inboundSchema;
+
+/** @internal */
+export const OnFailure$inboundSchema: z.ZodNativeEnum<typeof OnFailure> = z
+  .nativeEnum(OnFailure);
+/** @internal */
+export const OnFailure$outboundSchema: z.ZodNativeEnum<typeof OnFailure> =
+  OnFailure$inboundSchema;
+
+/** @internal */
+export const PIIRedactionPlugin$inboundSchema: z.ZodType<
+  PIIRedactionPlugin,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: Id$inboundSchema,
+  language: z.string().optional(),
+  regions: z.array(z.string()).optional(),
+  entities: z.array(z.string()).optional(),
+  entity_thresholds: z.record(z.number()).optional(),
+  threshold: z.number().optional(),
+  on_failure: OnFailure$inboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "entity_thresholds": "entityThresholds",
+    "on_failure": "onFailure",
+  });
+});
+/** @internal */
+export type PIIRedactionPlugin$Outbound = {
+  id: string;
+  language?: string | undefined;
+  regions?: Array<string> | undefined;
+  entities?: Array<string> | undefined;
+  entity_thresholds?: { [k: string]: number } | undefined;
+  threshold?: number | undefined;
+  on_failure?: string | undefined;
+};
+
+/** @internal */
+export const PIIRedactionPlugin$outboundSchema: z.ZodType<
+  PIIRedactionPlugin$Outbound,
+  z.ZodTypeDef,
+  PIIRedactionPlugin
+> = z.object({
+  id: Id$outboundSchema,
+  language: z.string().optional(),
+  regions: z.array(z.string()).optional(),
+  entities: z.array(z.string()).optional(),
+  entityThresholds: z.record(z.number()).optional(),
+  threshold: z.number().optional(),
+  onFailure: OnFailure$outboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    entityThresholds: "entity_thresholds",
+    onFailure: "on_failure",
+  });
+});
+
+export function piiRedactionPluginToJSON(
+  piiRedactionPlugin: PIIRedactionPlugin,
+): string {
+  return JSON.stringify(
+    PIIRedactionPlugin$outboundSchema.parse(piiRedactionPlugin),
+  );
+}
+export function piiRedactionPluginFromJSON(
+  jsonString: string,
+): SafeParseResult<PIIRedactionPlugin, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PIIRedactionPlugin$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PIIRedactionPlugin' from JSON`,
+  );
+}

package/src/models/components/previewchunk.ts

@@ -0,0 +1,38 @@
+/*
+ * 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 { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type PreviewChunk = {
+  text: string;
+  pageNumber?: number | undefined;
+};
+
+/** @internal */
+export const PreviewChunk$inboundSchema: z.ZodType<
+  PreviewChunk,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  text: z.string(),
+  page_number: z.number().int().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "page_number": "pageNumber",
+  });
+});
+
+export function previewChunkFromJSON(
+  jsonString: string,
+): SafeParseResult<PreviewChunk, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PreviewChunk$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PreviewChunk' from JSON`,
+  );
+}

package/src/models/components/previewchunksmetadata.ts

@@ -0,0 +1,51 @@
+/*
+ * 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 { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type PreviewChunksMetadata = {
+  wordsCount: number;
+  sentencesCount: number;
+  paragraphsCount: number;
+  tokensCount: number;
+  charactersCount: number;
+  chunksCount: number;
+};
+
+/** @internal */
+export const PreviewChunksMetadata$inboundSchema: z.ZodType<
+  PreviewChunksMetadata,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  words_count: z.number().int(),
+  sentences_count: z.number().int(),
+  paragraphs_count: z.number().int(),
+  tokens_count: z.number().int(),
+  characters_count: z.number().int(),
+  chunks_count: z.number().int(),
+}).transform((v) => {
+  return remap$(v, {
+    "words_count": "wordsCount",
+    "sentences_count": "sentencesCount",
+    "paragraphs_count": "paragraphsCount",
+    "tokens_count": "tokensCount",
+    "characters_count": "charactersCount",
+    "chunks_count": "chunksCount",
+  });
+});
+
+export function previewChunksMetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<PreviewChunksMetadata, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => PreviewChunksMetadata$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'PreviewChunksMetadata' from JSON`,
+  );
+}

package/src/models/components/publicplugin.ts

@@ -19,18 +19,6 @@ export const PublicPluginId = {
  */
 export type PublicPluginId = ClosedEnum<typeof PublicPluginId>;
 
-/**
- * pii_redaction only. Detector language. Defaults to en.
- */
-export const PublicPluginLanguage = {
-  En: "en",
-  Nl: "nl",
-} as const;
-/**
- * pii_redaction only. Detector language. Defaults to en.
- */
-export type PublicPluginLanguage = ClosedEnum<typeof PublicPluginLanguage>;
-
 export const PublicPluginMask = {
   All: "all",
   System: "system",
@@ -55,17 +43,21 @@ export type PublicPluginOnFailure = ClosedEnum<typeof PublicPluginOnFailure>;
 
 export type PublicPlugin = {
   /**
-   * pii_redaction only. Entity types to redact (e.g. EMAIL_ADDRESS, BSN). Omit to redact every type detected for the language.
+   * pii_redaction only. Entity types to redact (e.g. EMAIL_ADDRESS, BSN). Omit to redact every type detected for the language and regions. Cannot be combined with regions.
    */
   entities?: Array<string> | null | undefined;
+  /**
+   * pii_redaction only. Per-entity confidence cutoff overrides in [0,1], keyed by entity type. An override replaces threshold for that type and may sit above or below it. Every key must also appear in entities.
+   */
+  entityThresholds?: { [k: string]: number } | undefined;
   /**
    * Plugin discriminator. pii_redaction redacts PII, response_healing repairs malformed JSON, and trace_scrubbing removes selected sensitive fields from exported traces.
    */
   id: PublicPluginId;
   /**
-   * pii_redaction only. Detector language. Defaults to en.
+   * pii_redaction only. Detector language, or "auto" to detect it per request. Defaults to en. The accepted values are whatever GET /v2/pii/capabilities lists, so they are not enumerated here: a fixed enum would reject a language the detector has since added.
    */
-  language?: PublicPluginLanguage | undefined;
+  language?: string | undefined;
   /**
    * trace_scrubbing only. Trace surfaces to scrub. At least one value required.
    */
@@ -74,6 +66,10 @@ export type PublicPlugin = {
    * pii_redaction only. Behavior when redaction is unavailable. block (default) fails the request; passthrough sends the original text.
    */
   onFailure?: PublicPluginOnFailure | undefined;
+  /**
+   * pii_redaction only. Region codes gating regional recognizers (e.g. nl, gb). ["all"] is exclusive. Omit for base entities only. Cannot be combined with entities.
+   */
+  regions?: Array<string> | null | undefined;
   /**
    * pii_redaction only. Detector confidence cutoff in [0,1].
    */
@@ -85,11 +81,6 @@ export const PublicPluginId$outboundSchema: z.ZodNativeEnum<
   typeof PublicPluginId
 > = z.nativeEnum(PublicPluginId);
 
-/** @internal */
-export const PublicPluginLanguage$outboundSchema: z.ZodNativeEnum<
-  typeof PublicPluginLanguage
-> = z.nativeEnum(PublicPluginLanguage);
-
 /** @internal */
 export const PublicPluginMask$outboundSchema: z.ZodNativeEnum<
   typeof PublicPluginMask
@@ -103,10 +94,12 @@ export const PublicPluginOnFailure$outboundSchema: z.ZodNativeEnum<
 /** @internal */
 export type PublicPlugin$Outbound = {
   entities?: Array<string> | null | undefined;
+  entity_thresholds?: { [k: string]: number } | undefined;
   id: string;
   language?: string | undefined;
   mask?: Array<string> | null | undefined;
   on_failure?: string | undefined;
+  regions?: Array<string> | null | undefined;
   threshold?: number | undefined;
 };
 
@@ -117,13 +110,16 @@ export const PublicPlugin$outboundSchema: z.ZodType<
   PublicPlugin
 > = z.object({
   entities: z.nullable(z.array(z.string())).optional(),
+  entityThresholds: z.record(z.number()).optional(),
   id: PublicPluginId$outboundSchema,
-  language: PublicPluginLanguage$outboundSchema.optional(),
+  language: z.string().optional(),
   mask: z.nullable(z.array(PublicPluginMask$outboundSchema)).optional(),
   onFailure: PublicPluginOnFailure$outboundSchema.optional(),
+  regions: z.nullable(z.array(z.string())).optional(),
   threshold: z.number().optional(),
 }).transform((v) => {
   return remap$(v, {
+    entityThresholds: "entity_thresholds",
     onFailure: "on_failure",
   });
 });

package/src/models/components/publicresponseresource.ts

@@ -17,6 +17,10 @@ import {
   IncompleteDetails$inboundSchema,
 } from "./incompletedetails.js";
 import { MemoryParam, MemoryParam$inboundSchema } from "./memoryparam.js";
+import {
+  OpenAIPromptCacheOptions,
+  OpenAIPromptCacheOptions$inboundSchema,
+} from "./openaipromptcacheoptions.js";
 import { PublicUsage, PublicUsage$inboundSchema } from "./publicusage.js";
 import { Reasoning, Reasoning$inboundSchema } from "./reasoning.js";
 import { ResponseError, ResponseError$inboundSchema } from "./responseerror.js";
@@ -86,6 +90,7 @@ export type PublicResponseResource = {
   presencePenalty: number;
   previousResponseId: string | null;
   promptCacheKey: string | null;
+  promptCacheOptions: OpenAIPromptCacheOptions | null;
   promptCacheRetention: string | null;
   reasoning: Reasoning | null;
   safetyIdentifier: string | null;
@@ -158,6 +163,7 @@ export const PublicResponseResource$inboundSchema: z.ZodType<
   presence_penalty: z.number(),
   previous_response_id: z.nullable(z.string()),
   prompt_cache_key: z.nullable(z.string()),
+  prompt_cache_options: z.nullable(OpenAIPromptCacheOptions$inboundSchema),
   prompt_cache_retention: z.nullable(z.string()),
   reasoning: z.nullable(Reasoning$inboundSchema),
   safety_identifier: z.nullable(z.string()),
@@ -188,6 +194,7 @@ export const PublicResponseResource$inboundSchema: z.ZodType<
     "presence_penalty": "presencePenalty",
     "previous_response_id": "previousResponseId",
     "prompt_cache_key": "promptCacheKey",
+    "prompt_cache_options": "promptCacheOptions",
     "prompt_cache_retention": "promptCacheRetention",
     "safety_identifier": "safetyIdentifier",
     "service_tier": "serviceTier",