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

package/src/models/components/budgetlimit.ts

@@ -8,10 +8,10 @@ import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
-export const Currency = {
+export const BudgetLimitCurrency = {
   Usd: "usd",
 } as const;
-export type Currency = ClosedEnum<typeof Currency>;
+export type BudgetLimitCurrency = ClosedEnum<typeof BudgetLimitCurrency>;
 
 export const Period = {
   Hour: "hour",
@@ -23,16 +23,18 @@ export type Period = ClosedEnum<typeof Period>;
 
 export type BudgetLimit = {
   amount: number;
-  currency: Currency;
+  currency: BudgetLimitCurrency;
   period: Period;
 };
 
 /** @internal */
-export const Currency$inboundSchema: z.ZodNativeEnum<typeof Currency> = z
-  .nativeEnum(Currency);
+export const BudgetLimitCurrency$inboundSchema: z.ZodNativeEnum<
+  typeof BudgetLimitCurrency
+> = z.nativeEnum(BudgetLimitCurrency);
 /** @internal */
-export const Currency$outboundSchema: z.ZodNativeEnum<typeof Currency> =
-  Currency$inboundSchema;
+export const BudgetLimitCurrency$outboundSchema: z.ZodNativeEnum<
+  typeof BudgetLimitCurrency
+> = BudgetLimitCurrency$inboundSchema;
 
 /** @internal */
 export const Period$inboundSchema: z.ZodNativeEnum<typeof Period> = z
@@ -48,7 +50,7 @@ export const BudgetLimit$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   amount: z.number(),
-  currency: Currency$inboundSchema,
+  currency: BudgetLimitCurrency$inboundSchema,
   period: Period$inboundSchema,
 });
 /** @internal */
@@ -65,7 +67,7 @@ export const BudgetLimit$outboundSchema: z.ZodType<
   BudgetLimit
 > = z.object({
   amount: z.number(),
-  currency: Currency$outboundSchema,
+  currency: BudgetLimitCurrency$outboundSchema,
   period: Period$outboundSchema,
 });
 

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/chatkitresource.ts

@@ -0,0 +1,45 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+
+export type ChatKitResource = {
+  id?: string | undefined;
+  displayName?: string | undefined;
+  resourceId?: string | undefined;
+  resourceType?: string | undefined;
+};
+
+/** @internal */
+export type ChatKitResource$Outbound = {
+  id?: string | undefined;
+  display_name?: string | undefined;
+  resource_id?: string | undefined;
+  resource_type?: string | undefined;
+};
+
+/** @internal */
+export const ChatKitResource$outboundSchema: z.ZodType<
+  ChatKitResource$Outbound,
+  z.ZodTypeDef,
+  ChatKitResource
+> = z.object({
+  id: z.string().optional(),
+  displayName: z.string().optional(),
+  resourceId: z.string().optional(),
+  resourceType: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    displayName: "display_name",
+    resourceId: "resource_id",
+    resourceType: "resource_type",
+  });
+});
+
+export function chatKitResourceToJSON(
+  chatKitResource: ChatKitResource,
+): string {
+  return JSON.stringify(ChatKitResource$outboundSchema.parse(chatKitResource));
+}

package/src/models/components/chatkitresources.ts

@@ -0,0 +1,36 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import {
+  ChatKitResource,
+  ChatKitResource$Outbound,
+  ChatKitResource$outboundSchema,
+} from "./chatkitresource.js";
+
+export type ChatKitResources = {
+  items?: Array<ChatKitResource> | undefined;
+};
+
+/** @internal */
+export type ChatKitResources$Outbound = {
+  items?: Array<ChatKitResource$Outbound> | undefined;
+};
+
+/** @internal */
+export const ChatKitResources$outboundSchema: z.ZodType<
+  ChatKitResources$Outbound,
+  z.ZodTypeDef,
+  ChatKitResources
+> = z.object({
+  items: z.array(ChatKitResource$outboundSchema).optional(),
+});
+
+export function chatKitResourcesToJSON(
+  chatKitResources: ChatKitResources,
+): string {
+  return JSON.stringify(
+    ChatKitResources$outboundSchema.parse(chatKitResources),
+  );
+}

package/src/models/components/chunkingconfiguration.ts

@@ -9,7 +9,7 @@ import { ClosedEnum } from "../../types/enums.js";
 /**
  * Asks a model to choose the boundaries. Slowest and most expensive, best on documents with irregular structure. Makes paid model calls.
  */
-export type Nine = {
+export type ChunkingConfiguration9 = {
   type: "agentic";
   /**
    * Maximum number of tokens per chunk.
@@ -36,7 +36,7 @@ export type Nine = {
 /**
  * Embeds the document before splitting it recursively, so each chunk is embedded with the surrounding document in context. Makes paid embedding calls.
  */
-export type Eight = {
+export type ChunkingConfiguration8 = {
   type: "late";
   /**
    * Maximum number of tokens per chunk.
@@ -77,7 +77,7 @@ export type ChunkingConfigurationMode = ClosedEnum<
 /**
  * Embeds the text and breaks where meaning shifts, so related passages stay together. Makes paid embedding calls.
  */
-export type Seven = {
+export type ChunkingConfiguration7 = {
   type: "semantic";
   /**
    * Maximum number of tokens per chunk.
@@ -108,7 +108,7 @@ export type Seven = {
 /**
  * Splits on delimiters or a regular expression without tokenizing. Fastest option; chunk sizes vary with where delimiters fall.
  */
-export type Six = {
+export type ChunkingConfiguration6 = {
   type: "fast";
   /**
    * Target chunk size in bytes.
@@ -139,7 +139,7 @@ export type Six = {
 /**
  * Splits on a separator hierarchy, falling back through paragraph, line, sentence, and word boundaries until chunks fit. Respects document structure.
  */
-export type Five = {
+export type ChunkingConfiguration5 = {
   type: "recursive";
   /**
    * Maximum number of tokens per chunk.
@@ -158,7 +158,7 @@ export type Five = {
 /**
  * Groups whole sentences up to the chunk size, so chunks never cut a sentence in half.
  */
-export type Four = {
+export type ChunkingConfiguration4 = {
   type: "sentence";
   /**
    * Maximum number of tokens per chunk.
@@ -177,7 +177,7 @@ export type Four = {
 /**
  * Splits text into fixed-size token windows with optional overlap. Predictable chunk sizes, no regard for sentence or paragraph boundaries.
  */
-export type Three = {
+export type ChunkingConfiguration3 = {
   type: "token";
   /**
    * Maximum number of tokens per chunk.
@@ -221,16 +221,16 @@ export type ChunkingConfiguration1 = {
 export type ChunkingConfiguration =
   | ChunkingConfiguration1
   | ChunkingConfiguration2
-  | Three
-  | Four
-  | Five
-  | Six
-  | Seven
-  | Eight
-  | Nine;
+  | ChunkingConfiguration3
+  | ChunkingConfiguration4
+  | ChunkingConfiguration5
+  | ChunkingConfiguration6
+  | ChunkingConfiguration7
+  | ChunkingConfiguration8
+  | ChunkingConfiguration9;
 
 /** @internal */
-export type Nine$Outbound = {
+export type ChunkingConfiguration9$Outbound = {
   type: "agentic";
   chunk_size: number;
   model: string;
@@ -240,29 +240,36 @@ export type Nine$Outbound = {
 };
 
 /** @internal */
-export const Nine$outboundSchema: z.ZodType<Nine$Outbound, z.ZodTypeDef, Nine> =
-  z.object({
-    type: z.literal("agentic"),
-    chunkSize: z.number().int().default(1024),
-    model: z.string().default("openai/gpt-4o"),
-    candidateSize: z.number().int().default(128),
-    minCharactersPerChunk: z.number().int().default(24),
-    systemPrompt: z.string().optional(),
-  }).transform((v) => {
-    return remap$(v, {
-      chunkSize: "chunk_size",
-      candidateSize: "candidate_size",
-      minCharactersPerChunk: "min_characters_per_chunk",
-      systemPrompt: "system_prompt",
-    });
+export const ChunkingConfiguration9$outboundSchema: z.ZodType<
+  ChunkingConfiguration9$Outbound,
+  z.ZodTypeDef,
+  ChunkingConfiguration9
+> = z.object({
+  type: z.literal("agentic"),
+  chunkSize: z.number().int().default(1024),
+  model: z.string().default("openai/gpt-4o"),
+  candidateSize: z.number().int().default(128),
+  minCharactersPerChunk: z.number().int().default(24),
+  systemPrompt: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    chunkSize: "chunk_size",
+    candidateSize: "candidate_size",
+    minCharactersPerChunk: "min_characters_per_chunk",
+    systemPrompt: "system_prompt",
   });
+});
 
-export function nineToJSON(nine: Nine): string {
-  return JSON.stringify(Nine$outboundSchema.parse(nine));
+export function chunkingConfiguration9ToJSON(
+  chunkingConfiguration9: ChunkingConfiguration9,
+): string {
+  return JSON.stringify(
+    ChunkingConfiguration9$outboundSchema.parse(chunkingConfiguration9),
+  );
 }
 
 /** @internal */
-export type Eight$Outbound = {
+export type ChunkingConfiguration8$Outbound = {
   type: "late";
   chunk_size: number;
   separators?: Array<string> | undefined;
@@ -272,10 +279,10 @@ export type Eight$Outbound = {
 };
 
 /** @internal */
-export const Eight$outboundSchema: z.ZodType<
-  Eight$Outbound,
+export const ChunkingConfiguration8$outboundSchema: z.ZodType<
+  ChunkingConfiguration8$Outbound,
   z.ZodTypeDef,
-  Eight
+  ChunkingConfiguration8
 > = z.object({
   type: z.literal("late"),
   chunkSize: z.number().int().default(512),
@@ -291,8 +298,12 @@ export const Eight$outboundSchema: z.ZodType<
   });
 });
 
-export function eightToJSON(eight: Eight): string {
-  return JSON.stringify(Eight$outboundSchema.parse(eight));
+export function chunkingConfiguration8ToJSON(
+  chunkingConfiguration8: ChunkingConfiguration8,
+): string {
+  return JSON.stringify(
+    ChunkingConfiguration8$outboundSchema.parse(chunkingConfiguration8),
+  );
 }
 
 /** @internal */
@@ -301,7 +312,7 @@ export const ChunkingConfigurationMode$outboundSchema: z.ZodNativeEnum<
 > = z.nativeEnum(ChunkingConfigurationMode);
 
 /** @internal */
-export type Seven$Outbound = {
+export type ChunkingConfiguration7$Outbound = {
   type: "semantic";
   chunk_size: number;
   embedding_model?: string | undefined;
@@ -312,10 +323,10 @@ export type Seven$Outbound = {
 };
 
 /** @internal */
-export const Seven$outboundSchema: z.ZodType<
-  Seven$Outbound,
+export const ChunkingConfiguration7$outboundSchema: z.ZodType<
+  ChunkingConfiguration7$Outbound,
   z.ZodTypeDef,
-  Seven
+  ChunkingConfiguration7
 > = z.object({
   type: z.literal("semantic"),
   chunkSize: z.number().int().default(512),
@@ -332,12 +343,16 @@ export const Seven$outboundSchema: z.ZodType<
   });
 });
 
-export function sevenToJSON(seven: Seven): string {
-  return JSON.stringify(Seven$outboundSchema.parse(seven));
+export function chunkingConfiguration7ToJSON(
+  chunkingConfiguration7: ChunkingConfiguration7,
+): string {
+  return JSON.stringify(
+    ChunkingConfiguration7$outboundSchema.parse(chunkingConfiguration7),
+  );
 }
 
 /** @internal */
-export type Six$Outbound = {
+export type ChunkingConfiguration6$Outbound = {
   type: "fast";
   target_size: number;
   delimiters: string;
@@ -348,28 +363,35 @@ export type Six$Outbound = {
 };
 
 /** @internal */
-export const Six$outboundSchema: z.ZodType<Six$Outbound, z.ZodTypeDef, Six> = z
-  .object({
-    type: z.literal("fast"),
-    targetSize: z.number().int().default(4096),
-    delimiters: z.string().default("\n.?"),
-    pattern: z.string().optional(),
-    prefix: z.boolean().default(false),
-    consecutive: z.boolean().default(false),
-    forwardFallback: z.boolean().default(false),
-  }).transform((v) => {
-    return remap$(v, {
-      targetSize: "target_size",
-      forwardFallback: "forward_fallback",
-    });
+export const ChunkingConfiguration6$outboundSchema: z.ZodType<
+  ChunkingConfiguration6$Outbound,
+  z.ZodTypeDef,
+  ChunkingConfiguration6
+> = z.object({
+  type: z.literal("fast"),
+  targetSize: z.number().int().default(4096),
+  delimiters: z.string().default("\n.?"),
+  pattern: z.string().optional(),
+  prefix: z.boolean().default(false),
+  consecutive: z.boolean().default(false),
+  forwardFallback: z.boolean().default(false),
+}).transform((v) => {
+  return remap$(v, {
+    targetSize: "target_size",
+    forwardFallback: "forward_fallback",
   });
+});
 
-export function sixToJSON(six: Six): string {
-  return JSON.stringify(Six$outboundSchema.parse(six));
+export function chunkingConfiguration6ToJSON(
+  chunkingConfiguration6: ChunkingConfiguration6,
+): string {
+  return JSON.stringify(
+    ChunkingConfiguration6$outboundSchema.parse(chunkingConfiguration6),
+  );
 }
 
 /** @internal */
-export type Five$Outbound = {
+export type ChunkingConfiguration5$Outbound = {
   type: "recursive";
   chunk_size: number;
   separators?: Array<string> | undefined;
@@ -377,25 +399,32 @@ export type Five$Outbound = {
 };
 
 /** @internal */
-export const Five$outboundSchema: z.ZodType<Five$Outbound, z.ZodTypeDef, Five> =
-  z.object({
-    type: z.literal("recursive"),
-    chunkSize: z.number().int().default(512),
-    separators: z.array(z.string()).optional(),
-    minCharactersPerChunk: z.number().int().default(24),
-  }).transform((v) => {
-    return remap$(v, {
-      chunkSize: "chunk_size",
-      minCharactersPerChunk: "min_characters_per_chunk",
-    });
+export const ChunkingConfiguration5$outboundSchema: z.ZodType<
+  ChunkingConfiguration5$Outbound,
+  z.ZodTypeDef,
+  ChunkingConfiguration5
+> = z.object({
+  type: z.literal("recursive"),
+  chunkSize: z.number().int().default(512),
+  separators: z.array(z.string()).optional(),
+  minCharactersPerChunk: z.number().int().default(24),
+}).transform((v) => {
+  return remap$(v, {
+    chunkSize: "chunk_size",
+    minCharactersPerChunk: "min_characters_per_chunk",
   });
+});
 
-export function fiveToJSON(five: Five): string {
-  return JSON.stringify(Five$outboundSchema.parse(five));
+export function chunkingConfiguration5ToJSON(
+  chunkingConfiguration5: ChunkingConfiguration5,
+): string {
+  return JSON.stringify(
+    ChunkingConfiguration5$outboundSchema.parse(chunkingConfiguration5),
+  );
 }
 
 /** @internal */
-export type Four$Outbound = {
+export type ChunkingConfiguration4$Outbound = {
   type: "sentence";
   chunk_size: number;
   chunk_overlap: number;
@@ -403,36 +432,43 @@ export type Four$Outbound = {
 };
 
 /** @internal */
-export const Four$outboundSchema: z.ZodType<Four$Outbound, z.ZodTypeDef, Four> =
-  z.object({
-    type: z.literal("sentence"),
-    chunkSize: z.number().int().default(512),
-    chunkOverlap: z.number().int().default(0),
-    minSentencesPerChunk: z.number().int().default(1),
-  }).transform((v) => {
-    return remap$(v, {
-      chunkSize: "chunk_size",
-      chunkOverlap: "chunk_overlap",
-      minSentencesPerChunk: "min_sentences_per_chunk",
-    });
+export const ChunkingConfiguration4$outboundSchema: z.ZodType<
+  ChunkingConfiguration4$Outbound,
+  z.ZodTypeDef,
+  ChunkingConfiguration4
+> = z.object({
+  type: z.literal("sentence"),
+  chunkSize: z.number().int().default(512),
+  chunkOverlap: z.number().int().default(0),
+  minSentencesPerChunk: z.number().int().default(1),
+}).transform((v) => {
+  return remap$(v, {
+    chunkSize: "chunk_size",
+    chunkOverlap: "chunk_overlap",
+    minSentencesPerChunk: "min_sentences_per_chunk",
   });
+});
 
-export function fourToJSON(four: Four): string {
-  return JSON.stringify(Four$outboundSchema.parse(four));
+export function chunkingConfiguration4ToJSON(
+  chunkingConfiguration4: ChunkingConfiguration4,
+): string {
+  return JSON.stringify(
+    ChunkingConfiguration4$outboundSchema.parse(chunkingConfiguration4),
+  );
 }
 
 /** @internal */
-export type Three$Outbound = {
+export type ChunkingConfiguration3$Outbound = {
   type: "token";
   chunk_size: number;
   chunk_overlap: number;
 };
 
 /** @internal */
-export const Three$outboundSchema: z.ZodType<
-  Three$Outbound,
+export const ChunkingConfiguration3$outboundSchema: z.ZodType<
+  ChunkingConfiguration3$Outbound,
   z.ZodTypeDef,
-  Three
+  ChunkingConfiguration3
 > = z.object({
   type: z.literal("token"),
   chunkSize: z.number().int().default(512),
@@ -444,8 +480,12 @@ export const Three$outboundSchema: z.ZodType<
   });
 });
 
-export function threeToJSON(three: Three): string {
-  return JSON.stringify(Three$outboundSchema.parse(three));
+export function chunkingConfiguration3ToJSON(
+  chunkingConfiguration3: ChunkingConfiguration3,
+): string {
+  return JSON.stringify(
+    ChunkingConfiguration3$outboundSchema.parse(chunkingConfiguration3),
+  );
 }
 
 /** @internal */
@@ -505,13 +545,13 @@ export function chunkingConfiguration1ToJSON(
 export type ChunkingConfiguration$Outbound =
   | ChunkingConfiguration1$Outbound
   | ChunkingConfiguration2$Outbound
-  | Three$Outbound
-  | Four$Outbound
-  | Five$Outbound
-  | Six$Outbound
-  | Seven$Outbound
-  | Eight$Outbound
-  | Nine$Outbound;
+  | ChunkingConfiguration3$Outbound
+  | ChunkingConfiguration4$Outbound
+  | ChunkingConfiguration5$Outbound
+  | ChunkingConfiguration6$Outbound
+  | ChunkingConfiguration7$Outbound
+  | ChunkingConfiguration8$Outbound
+  | ChunkingConfiguration9$Outbound;
 
 /** @internal */
 export const ChunkingConfiguration$outboundSchema: z.ZodType<
@@ -521,13 +561,13 @@ export const ChunkingConfiguration$outboundSchema: z.ZodType<
 > = z.union([
   z.lazy(() => ChunkingConfiguration1$outboundSchema),
   z.lazy(() => ChunkingConfiguration2$outboundSchema),
-  z.lazy(() => Three$outboundSchema),
-  z.lazy(() => Four$outboundSchema),
-  z.lazy(() => Five$outboundSchema),
-  z.lazy(() => Six$outboundSchema),
-  z.lazy(() => Seven$outboundSchema),
-  z.lazy(() => Eight$outboundSchema),
-  z.lazy(() => Nine$outboundSchema),
+  z.lazy(() => ChunkingConfiguration3$outboundSchema),
+  z.lazy(() => ChunkingConfiguration4$outboundSchema),
+  z.lazy(() => ChunkingConfiguration5$outboundSchema),
+  z.lazy(() => ChunkingConfiguration6$outboundSchema),
+  z.lazy(() => ChunkingConfiguration7$outboundSchema),
+  z.lazy(() => ChunkingConfiguration8$outboundSchema),
+  z.lazy(() => ChunkingConfiguration9$outboundSchema),
 ]);
 
 export function chunkingConfigurationToJSON(