@orq-ai/node 4.15.0-rc.9 → 4.16.0-rc.0

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/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). On its own this is a strict allowlist; alongside regions it adds to the region coverage. Omit to redact every type detected for the language and regions. See GET /v2/pii/capabilities for valid types.
    */
   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 selecting whole regions of coverage (e.g. nl, gb). Every entity type those regions cover is redacted, alongside the base catalog. ["all"] cannot be combined with other region codes, 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.
+   */
+  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",

package/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_01m1ds3xj0xdcax8xkkg8wpsdp"),
+  _id: z.string().default("reasoning_01m2pknb2qvaggt9xmpbm2qkmv"),
   metadata: z.record(z.any()).optional(),
   kind: z.literal("reasoning"),
   reasoning: z.string(),

package/src/models/components/redactrequest.ts

@@ -3,11 +3,53 @@
  */
 
 import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
 
 export type RedactRequest = {
   text?: string | undefined;
   language?: string | undefined;
   threshold?: number | undefined;
+  /**
+   * Region codes selecting whole regions of coverage, e.g. "nl", "gb". Every
+   *
+   * @remarks
+   *  entity type those regions cover is included, alongside the base catalog.
+   *  ["all"] is exclusive. Leaving this and `entities` both empty also runs every
+   *  region, so selecting nothing is the widest request rather than the narrowest.
+   *  Empty alongside a non-empty `entities` stays strict. See the capabilities
+   *  endpoint for the region list.
+   *
+   *  Combines with `entities`: the detector unions the two selections, so a
+   *  request carrying both covers the regions plus the named types. Note that
+   *  `entities` only narrows coverage when it travels alone.
+   */
+  regions?: Array<string> | undefined;
+  /**
+   * The entity types to cover. A named type fires even when it belongs to a
+   *
+   * @remarks
+   *  region, so a region's types can be selected individually without naming
+   *  the region. Alone this is a strict allowlist; alongside `regions` it adds
+   *  to the region coverage instead of narrowing it.
+   */
+  entities?: Array<string> | undefined;
+  /**
+   * Per-entity confidence cutoff overrides. An override REPLACES the global
+   *
+   * @remarks
+   *  `threshold` for that type and may sit above or below it: the gateway
+   *  lowers the first-pass floor it sends the detector to the smallest value
+   *  in the map, and every selected type carries its own cutoff, so a
+   *  sub-global override detects MORE of that type without widening the rest.
+   *
+   *  This only tunes confidence; it never changes which types are covered.
+   *  Coverage is decided by `entities` alone, so every key here must also
+   *  appear in `entities` — a key that does not is rejected, as is any key at
+   *  all when `entities` is empty.
+   *
+   *  Declarative [0,1] bound mirrors existing constraint on `threshold`.
+   */
+  entityThresholds?: { [k: string]: number } | undefined;
 };
 
 /** @internal */
@@ -15,6 +57,9 @@ export type RedactRequest$Outbound = {
   text?: string | undefined;
   language?: string | undefined;
   threshold?: number | undefined;
+  regions?: Array<string> | undefined;
+  entities?: Array<string> | undefined;
+  entity_thresholds?: { [k: string]: number } | undefined;
 };
 
 /** @internal */
@@ -26,6 +71,13 @@ export const RedactRequest$outboundSchema: z.ZodType<
   text: z.string().optional(),
   language: z.string().optional(),
   threshold: z.number().optional(),
+  regions: z.array(z.string()).optional(),
+  entities: z.array(z.string()).optional(),
+  entityThresholds: z.record(z.number()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    entityThresholds: "entity_thresholds",
+  });
 });
 
 export function redactRequestToJSON(redactRequest: RedactRequest): string {

package/src/models/components/responsehealingplugin.ts

@@ -4,50 +4,27 @@
 
 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";
 
-/**
- * Plugin discriminator. Must be `response_healing`.
- */
-export const ResponseHealingPluginId = {
-  ResponseHealing: "response_healing",
-} as const;
-/**
- * Plugin discriminator. Must be `response_healing`.
- */
-export type ResponseHealingPluginId = ClosedEnum<
-  typeof ResponseHealingPluginId
->;
-
 export type ResponseHealingPlugin = {
   /**
    * Plugin discriminator. Must be `response_healing`.
    */
-  id: ResponseHealingPluginId;
+  id: "response_healing";
 };
 
-/** @internal */
-export const ResponseHealingPluginId$inboundSchema: z.ZodNativeEnum<
-  typeof ResponseHealingPluginId
-> = z.nativeEnum(ResponseHealingPluginId);
-/** @internal */
-export const ResponseHealingPluginId$outboundSchema: z.ZodNativeEnum<
-  typeof ResponseHealingPluginId
-> = ResponseHealingPluginId$inboundSchema;
-
 /** @internal */
 export const ResponseHealingPlugin$inboundSchema: z.ZodType<
   ResponseHealingPlugin,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  id: ResponseHealingPluginId$inboundSchema,
+  id: z.literal("response_healing"),
 });
 /** @internal */
 export type ResponseHealingPlugin$Outbound = {
-  id: string;
+  id: "response_healing";
 };
 
 /** @internal */
@@ -56,7 +33,7 @@ export const ResponseHealingPlugin$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ResponseHealingPlugin
 > = z.object({
-  id: ResponseHealingPluginId$outboundSchema,
+  id: z.literal("response_healing"),
 });
 
 export function responseHealingPluginToJSON(

package/src/models/components/responsemeta.ts

@@ -25,13 +25,13 @@ export type EffectiveGrain = ClosedEnum<typeof EffectiveGrain>;
 /**
  * ISO 4217 currency code for cost fields. Always `USD` today.
  */
-export const ResponseMetaCurrency = {
+export const Currency = {
   Usd: "USD",
 } as const;
 /**
  * ISO 4217 currency code for cost fields. Always `USD` today.
  */
-export type ResponseMetaCurrency = ClosedEnum<typeof ResponseMetaCurrency>;
+export type Currency = ClosedEnum<typeof Currency>;
 
 export type ResponseMeta = {
   /**
@@ -56,7 +56,7 @@ export type ResponseMeta = {
   /**
    * ISO 4217 currency code for cost fields. Always `USD` today.
    */
-  currency?: ResponseMetaCurrency | undefined;
+  currency?: Currency | undefined;
   /**
    * Non-fatal warnings about the response. May contain `totals_unavailable` when totals were requested but failed.
    */
@@ -69,9 +69,8 @@ export const EffectiveGrain$inboundSchema: z.ZodNativeEnum<
 > = z.nativeEnum(EffectiveGrain);
 
 /** @internal */
-export const ResponseMetaCurrency$inboundSchema: z.ZodNativeEnum<
-  typeof ResponseMetaCurrency
-> = z.nativeEnum(ResponseMetaCurrency);
+export const Currency$inboundSchema: z.ZodNativeEnum<typeof Currency> = z
+  .nativeEnum(Currency);
 
 /** @internal */
 export const ResponseMeta$inboundSchema: z.ZodType<
@@ -82,7 +81,7 @@ export const ResponseMeta$inboundSchema: z.ZodType<
   effective_grain: EffectiveGrain$inboundSchema.optional(),
   row_count: z.number().int().optional(),
   request_id: z.string().optional(),
-  currency: ResponseMetaCurrency$inboundSchema.optional(),
+  currency: Currency$inboundSchema.optional(),
   warnings: z.array(z.string()).optional(),
 }).transform((v) => {
   return remap$(v, {

package/src/models/components/routingruleplugin.ts

@@ -13,11 +13,30 @@ export type RoutingRulePlugin = {
    * Plugin discriminator.
    */
   id?: string | undefined;
+  /**
+   * Languages, regions and entity types are checked against the live
+   *
+   * @remarks
+   *  pii-detection capabilities catalog when the rule is saved, not pinned
+   *  here, so a language or region the detector gains becomes writable without
+   *  a proto change.
+   */
   language?: string | undefined;
+  /**
+   * Entity types to redact. On their own a strict allowlist; alongside regions they add to the region coverage.
+   */
   entities?: Array<string> | undefined;
   onFailure?: string | undefined;
   threshold?: number | undefined;
   mask?: Array<string> | undefined;
+  /**
+   * Regions of coverage by ISO 3166-1 alpha-2 code, or ["all"]. Combines with entities: the two selections are unioned.
+   */
+  regions?: Array<string> | undefined;
+  /**
+   * Per-entity-type confidence cutoff. Every key must also appear in entities.
+   */
+  entityThresholds?: { [k: string]: number } | undefined;
 };
 
 /** @internal */
@@ -32,9 +51,12 @@ export const RoutingRulePlugin$inboundSchema: z.ZodType<
   on_failure: z.string().optional(),
   threshold: z.number().optional(),
   mask: z.array(z.string()).optional(),
+  regions: z.array(z.string()).optional(),
+  entity_thresholds: z.record(z.number()).optional(),
 }).transform((v) => {
   return remap$(v, {
     "on_failure": "onFailure",
+    "entity_thresholds": "entityThresholds",
   });
 });
 /** @internal */
@@ -45,6 +67,8 @@ export type RoutingRulePlugin$Outbound = {
   on_failure?: string | undefined;
   threshold?: number | undefined;
   mask?: Array<string> | undefined;
+  regions?: Array<string> | undefined;
+  entity_thresholds?: { [k: string]: number } | undefined;
 };
 
 /** @internal */
@@ -59,9 +83,12 @@ export const RoutingRulePlugin$outboundSchema: z.ZodType<
   onFailure: z.string().optional(),
   threshold: z.number().optional(),
   mask: z.array(z.string()).optional(),
+  regions: z.array(z.string()).optional(),
+  entityThresholds: z.record(z.number()).optional(),
 }).transform((v) => {
   return remap$(v, {
     onFailure: "on_failure",
+    entityThresholds: "entity_thresholds",
   });
 });
 

package/src/models/components/searchhubitemsresponse.ts

@@ -0,0 +1,32 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import { HubSearchHit, HubSearchHit$inboundSchema } from "./hubsearchhit.js";
+
+export type SearchHubItemsResponse = {
+  hits: Array<HubSearchHit>;
+};
+
+/** @internal */
+export const SearchHubItemsResponse$inboundSchema: z.ZodType<
+  SearchHubItemsResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  hits: z.array(HubSearchHit$inboundSchema),
+});
+
+export function searchHubItemsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<SearchHubItemsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SearchHubItemsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SearchHubItemsResponse' from JSON`,
+  );
+}

package/src/models/components/searchknowledgematch.ts

@@ -20,10 +20,7 @@ export type SearchKnowledgeMatch = {
   id: string;
   text: string;
   /**
-   * The service maps the internal embedding field to this public name. Empty
-   *
-   * @remarks
-   *  repeated fields are omitted by proto JSON, preserving optional vectors.
+   * Embedding vector of the chunk, returned only when requested.
    */
   vector?: Array<number> | undefined;
   /**