@orq-ai/node 4.15.0-rc.21 → 4.15.0-rc.23

package/src/models/components/agentresponserequest.ts

@@ -145,7 +145,7 @@ export type Contact = {
 /**
  * Thread information to group related requests
  */
-export type Thread = {
+export type AgentResponseRequestThread = {
   /**
    * Unique thread identifier to group related invocations.
    */
@@ -228,7 +228,7 @@ export type AgentResponseRequest = {
   /**
    * Thread information to group related requests
    */
-  thread?: Thread | undefined;
+  thread?: AgentResponseRequestThread | undefined;
   /**
    * Memory configuration for the agent execution. Used to associate memory stores with specific entities like users or sessions.
    */
@@ -419,23 +419,27 @@ export function contactToJSON(contact: Contact): string {
 }
 
 /** @internal */
-export type Thread$Outbound = {
+export type AgentResponseRequestThread$Outbound = {
   id: string;
   tags?: Array<string> | undefined;
 };
 
 /** @internal */
-export const Thread$outboundSchema: z.ZodType<
-  Thread$Outbound,
+export const AgentResponseRequestThread$outboundSchema: z.ZodType<
+  AgentResponseRequestThread$Outbound,
   z.ZodTypeDef,
-  Thread
+  AgentResponseRequestThread
 > = z.object({
   id: z.string(),
   tags: z.array(z.string()).optional(),
 });
 
-export function threadToJSON(thread: Thread): string {
-  return JSON.stringify(Thread$outboundSchema.parse(thread));
+export function agentResponseRequestThreadToJSON(
+  agentResponseRequestThread: AgentResponseRequestThread,
+): string {
+  return JSON.stringify(
+    AgentResponseRequestThread$outboundSchema.parse(agentResponseRequestThread),
+  );
 }
 
 /** @internal */
@@ -521,7 +525,7 @@ export type AgentResponseRequest$Outbound = {
   variables?: { [k: string]: any } | undefined;
   identity?: AgentResponseRequestIdentity$Outbound | undefined;
   contact?: Contact$Outbound | undefined;
-  thread?: Thread$Outbound | undefined;
+  thread?: AgentResponseRequestThread$Outbound | undefined;
   memory?: AgentResponseRequestMemory$Outbound | undefined;
   metadata?: { [k: string]: any } | undefined;
   engine?: string | undefined;
@@ -543,7 +547,7 @@ export const AgentResponseRequest$outboundSchema: z.ZodType<
   identity: z.lazy(() => AgentResponseRequestIdentity$outboundSchema)
     .optional(),
   contact: z.lazy(() => Contact$outboundSchema).optional(),
-  thread: z.lazy(() => Thread$outboundSchema).optional(),
+  thread: z.lazy(() => AgentResponseRequestThread$outboundSchema).optional(),
   memory: z.lazy(() => AgentResponseRequestMemory$outboundSchema).optional(),
   metadata: z.record(z.any()).optional(),
   engine: Engine$outboundSchema.optional(),

package/src/models/components/agentstartedstreamingevent.ts

@@ -140,6 +140,10 @@ export type Evaluators = {
    * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
    */
   executeOn: AgentStartedStreamingEventDataExecuteOn;
+  /**
+   * Evaluator-specific configuration, passed through to the evaluator at run time. For orq_pii_detection this carries regions, entities, entity_thresholds, language and threshold, and is validated against PIIDetectionGuardrailOptions: regions and entities are two mutually exclusive coverage modes, and every entity_thresholds key must also appear in entities. on_failure is rejected: an evaluator acting as a guardrail always fails closed.
+   */
+  options?: { [k: string]: any } | undefined;
 };
 
 /**
@@ -169,6 +173,10 @@ export type Guardrails = {
    * Determines whether the evaluator runs on the agent input (user message) or output (agent response).
    */
   executeOn: AgentStartedStreamingEventExecuteOn;
+  /**
+   * Evaluator-specific configuration, passed through to the evaluator at run time. For orq_pii_detection this carries regions, entities, entity_thresholds, language and threshold, and is validated against PIIDetectionGuardrailOptions: regions and entities are two mutually exclusive coverage modes, and every entity_thresholds key must also appear in entities. on_failure is rejected: an evaluator acting as a guardrail always fails closed.
+   */
+  options?: { [k: string]: any } | undefined;
 };
 
 export type Settings = {
@@ -198,7 +206,7 @@ export type Settings = {
    */
   evaluators?: Array<Evaluators> | undefined;
   /**
-   * Configuration for a guardrail applied to the agent
+   * Configuration for a guardrail applied to the agent. sample_rate has no effect here: a guardrail is a gate rather than a measurement, so it runs on every request.
    */
   guardrails?: Array<Guardrails> | undefined;
 };
@@ -376,6 +384,7 @@ export const Evaluators$inboundSchema: z.ZodType<
   id: z.string(),
   sample_rate: z.number().default(50),
   execute_on: AgentStartedStreamingEventDataExecuteOn$inboundSchema,
+  options: z.record(z.any()).optional(),
 }).transform((v) => {
   return remap$(v, {
     "sample_rate": "sampleRate",
@@ -407,6 +416,7 @@ export const Guardrails$inboundSchema: z.ZodType<
   id: z.string(),
   sample_rate: z.number().default(50),
   execute_on: AgentStartedStreamingEventExecuteOn$inboundSchema,
+  options: z.record(z.any()).optional(),
 }).transform((v) => {
   return remap$(v, {
     "sample_rate": "sampleRate",

package/src/models/components/capabilitiesresponse.ts

@@ -0,0 +1,96 @@
+/*
+ * 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";
+import { EntityList, EntityList$inboundSchema } from "./entitylist.js";
+
+export type CapabilitiesResponse = {
+  /**
+   * Supported detector languages, e.g. "en", "nl". There is no "auto" value.
+   */
+  languages?: Array<string> | undefined;
+  /**
+   * Universal entity types available regardless of region, e.g. PASSPORT,
+   *
+   * @remarks
+   *  LICENSE_PLATE, UUID, JWT, BIC.
+   */
+  baseEntities?: Array<string> | undefined;
+  /**
+   * Every entity type the service can detect across all regions and the
+   *
+   * @remarks
+   *  base catalog.
+   */
+  allEntities?: Array<string> | undefined;
+  /**
+   * Region codes the service recognizes, e.g. "nl", "gb", "all".
+   */
+  regions?: Array<string> | undefined;
+  /**
+   * Maps each region code to the entity types it gates. Use this to find the
+   *
+   * @remarks
+   *  type to name in `entities` when you need a per-entity threshold on a type
+   *  a region gates.
+   */
+  regionEntities?: { [k: string]: EntityList } | undefined;
+  /**
+   * Sparse per-entity default thresholds; entities absent here fall back to
+   *
+   * @remarks
+   *  default_threshold.
+   */
+  entityThresholds?: { [k: string]: number } | undefined;
+  /**
+   * Confidence cutoff applied when neither `threshold` nor an entity-specific
+   *
+   * @remarks
+   *  override is supplied.
+   */
+  defaultThreshold?: number | undefined;
+  /**
+   * Maximum number of characters accepted per request.
+   */
+  maxTextChars?: number | undefined;
+};
+
+/** @internal */
+export const CapabilitiesResponse$inboundSchema: z.ZodType<
+  CapabilitiesResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  languages: z.array(z.string()).optional(),
+  base_entities: z.array(z.string()).optional(),
+  all_entities: z.array(z.string()).optional(),
+  regions: z.array(z.string()).optional(),
+  region_entities: z.record(EntityList$inboundSchema).optional(),
+  entity_thresholds: z.record(z.number()).optional(),
+  default_threshold: z.number().optional(),
+  max_text_chars: z.number().int().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "base_entities": "baseEntities",
+    "all_entities": "allEntities",
+    "region_entities": "regionEntities",
+    "entity_thresholds": "entityThresholds",
+    "default_threshold": "defaultThreshold",
+    "max_text_chars": "maxTextChars",
+  });
+});
+
+export function capabilitiesResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<CapabilitiesResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CapabilitiesResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CapabilitiesResponse' from JSON`,
+  );
+}

package/src/models/components/createthreadrequest.ts

@@ -0,0 +1,91 @@
+/*
+ * 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 {
+  ThreadBilling,
+  ThreadBilling$Outbound,
+  ThreadBilling$outboundSchema,
+} from "./threadbilling.js";
+import { ThreadKind, ThreadKind$outboundSchema } from "./threadkind.js";
+import {
+  ThreadUsage,
+  ThreadUsage$Outbound,
+  ThreadUsage$outboundSchema,
+} from "./threadusage.js";
+
+export type CreateThreadRequest = {
+  externalId: string;
+  duration: number;
+  contactIds: Array<string>;
+  billing: ThreadBilling;
+  usage: ThreadUsage;
+  tracesCount: number;
+  tags: Array<string>;
+  projectId?: string | undefined;
+  startedAt?: Date | undefined;
+  updatedAt?: Date | undefined;
+  title?: string | undefined;
+  client?: string | undefined;
+  repo?: string | undefined;
+  kind?: ThreadKind | undefined;
+};
+
+/** @internal */
+export type CreateThreadRequest$Outbound = {
+  external_id: string;
+  duration: number;
+  contact_ids: Array<string>;
+  billing: ThreadBilling$Outbound;
+  usage: ThreadUsage$Outbound;
+  traces_count: number;
+  tags: Array<string>;
+  project_id?: string | undefined;
+  started_at?: string | undefined;
+  updated_at?: string | undefined;
+  title?: string | undefined;
+  client?: string | undefined;
+  repo?: string | undefined;
+  kind?: string | undefined;
+};
+
+/** @internal */
+export const CreateThreadRequest$outboundSchema: z.ZodType<
+  CreateThreadRequest$Outbound,
+  z.ZodTypeDef,
+  CreateThreadRequest
+> = z.object({
+  externalId: z.string(),
+  duration: z.number(),
+  contactIds: z.array(z.string()),
+  billing: ThreadBilling$outboundSchema,
+  usage: ThreadUsage$outboundSchema,
+  tracesCount: z.number().int(),
+  tags: z.array(z.string()),
+  projectId: z.string().optional(),
+  startedAt: z.date().transform(v => v.toISOString()).optional(),
+  updatedAt: z.date().transform(v => v.toISOString()).optional(),
+  title: z.string().optional(),
+  client: z.string().optional(),
+  repo: z.string().optional(),
+  kind: ThreadKind$outboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    externalId: "external_id",
+    contactIds: "contact_ids",
+    tracesCount: "traces_count",
+    projectId: "project_id",
+    startedAt: "started_at",
+    updatedAt: "updated_at",
+  });
+});
+
+export function createThreadRequestToJSON(
+  createThreadRequest: CreateThreadRequest,
+): string {
+  return JSON.stringify(
+    CreateThreadRequest$outboundSchema.parse(createThreadRequest),
+  );
+}

package/src/models/components/detectrequest.ts

@@ -25,6 +25,47 @@ export type DetectRequest = {
    * When true, the response includes a per-type entity breakdown.
    */
   includeEntities?: boolean | 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 */
@@ -33,6 +74,9 @@ export type DetectRequest$Outbound = {
   language?: string | undefined;
   threshold?: number | undefined;
   include_entities?: boolean | undefined;
+  regions?: Array<string> | undefined;
+  entities?: Array<string> | undefined;
+  entity_thresholds?: { [k: string]: number } | undefined;
 };
 
 /** @internal */
@@ -45,9 +89,13 @@ export const DetectRequest$outboundSchema: z.ZodType<
   language: z.string().optional(),
   threshold: z.number().optional(),
   includeEntities: z.boolean().optional(),
+  regions: z.array(z.string()).optional(),
+  entities: z.array(z.string()).optional(),
+  entityThresholds: z.record(z.number()).optional(),
 }).transform((v) => {
   return remap$(v, {
     includeEntities: "include_entities",
+    entityThresholds: "entity_thresholds",
   });
 });
 

package/src/models/components/entitylist.ts

@@ -0,0 +1,37 @@
+/*
+ * 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";
+
+/**
+ * EntityList wraps a repeated string because proto3 maps cannot hold
+ *
+ * @remarks
+ *  repeated values directly.
+ */
+export type EntityList = {
+  entities?: Array<string> | undefined;
+};
+
+/** @internal */
+export const EntityList$inboundSchema: z.ZodType<
+  EntityList,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  entities: z.array(z.string()).optional(),
+});
+
+export function entityListFromJSON(
+  jsonString: string,
+): SafeParseResult<EntityList, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => EntityList$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'EntityList' from JSON`,
+  );
+}

package/src/models/components/gethubitemresponse.ts

@@ -0,0 +1,37 @@
+/*
+ * 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";
+import { HubItem, HubItem$inboundSchema } from "./hubitem.js";
+
+export type GetHubItemResponse = {
+  hubItem: HubItem;
+};
+
+/** @internal */
+export const GetHubItemResponse$inboundSchema: z.ZodType<
+  GetHubItemResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  hub_item: HubItem$inboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    "hub_item": "hubItem",
+  });
+});
+
+export function getHubItemResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetHubItemResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetHubItemResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetHubItemResponse' from JSON`,
+  );
+}

package/src/models/components/getthreadcountrequest.ts

@@ -0,0 +1,42 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import {
+  ThreadFilters,
+  ThreadFilters$Outbound,
+  ThreadFilters$outboundSchema,
+} from "./threadfilters.js";
+
+export type GetThreadCountRequest = {
+  filters: ThreadFilters;
+  limit?: number | undefined;
+  page?: number | undefined;
+};
+
+/** @internal */
+export type GetThreadCountRequest$Outbound = {
+  filters: ThreadFilters$Outbound;
+  limit?: number | undefined;
+  page?: number | undefined;
+};
+
+/** @internal */
+export const GetThreadCountRequest$outboundSchema: z.ZodType<
+  GetThreadCountRequest$Outbound,
+  z.ZodTypeDef,
+  GetThreadCountRequest
+> = z.object({
+  filters: ThreadFilters$outboundSchema,
+  limit: z.number().int().optional(),
+  page: z.number().int().optional(),
+});
+
+export function getThreadCountRequestToJSON(
+  getThreadCountRequest: GetThreadCountRequest,
+): string {
+  return JSON.stringify(
+    GetThreadCountRequest$outboundSchema.parse(getThreadCountRequest),
+  );
+}

package/src/models/components/getthreadcountresponse.ts

@@ -0,0 +1,31 @@
+/*
+ * 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";
+
+export type GetThreadCountResponse = {
+  count: number;
+};
+
+/** @internal */
+export const GetThreadCountResponse$inboundSchema: z.ZodType<
+  GetThreadCountResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  count: z.number().int(),
+});
+
+export function getThreadCountResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetThreadCountResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetThreadCountResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetThreadCountResponse' from JSON`,
+  );
+}

package/src/models/components/guardrailruleplugin.ts

@@ -13,10 +13,29 @@ export type GuardrailRulePlugin = {
    * 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. Mutually exclusive with regions.
+   */
   entities?: Array<string> | undefined;
   onFailure?: string | undefined;
   threshold?: number | undefined;
+  /**
+   * Regions of coverage by ISO 3166-1 alpha-2 code, or ["all"]. Mutually exclusive with entities.
+   */
+  regions?: Array<string> | undefined;
+  /**
+   * Per-entity-type confidence cutoff. Every key must also appear in entities.
+   */
+  entityThresholds?: { [k: string]: number } | undefined;
 };
 
 /** @internal */
@@ -30,9 +49,12 @@ export const GuardrailRulePlugin$inboundSchema: z.ZodType<
   entities: z.array(z.string()).optional(),
   on_failure: z.string().optional(),
   threshold: z.number().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 */
@@ -42,6 +64,8 @@ export type GuardrailRulePlugin$Outbound = {
   entities?: Array<string> | undefined;
   on_failure?: string | undefined;
   threshold?: number | undefined;
+  regions?: Array<string> | undefined;
+  entity_thresholds?: { [k: string]: number } | undefined;
 };
 
 /** @internal */
@@ -55,9 +79,12 @@ export const GuardrailRulePlugin$outboundSchema: z.ZodType<
   entities: z.array(z.string()).optional(),
   onFailure: z.string().optional(),
   threshold: z.number().optional(),
+  regions: z.array(z.string()).optional(),
+  entityThresholds: z.record(z.number()).optional(),
 }).transform((v) => {
   return remap$(v, {
     onFailure: "on_failure",
+    entityThresholds: "entity_thresholds",
   });
 });