@orq-ai/node 4.15.0-rc.4 → 4.15.0-rc.41

package/src/models/components/datasourcesservicepreviewchunksrequest.ts

@@ -0,0 +1,48 @@
+/*
+ * 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 {
+  DatasourceChunkingOptions,
+  DatasourceChunkingOptions$Outbound,
+  DatasourceChunkingOptions$outboundSchema,
+} from "./datasourcechunkingoptions.js";
+
+export type DatasourcesServicePreviewChunksRequest = {
+  fileId: string;
+  chunkingOptions?: DatasourceChunkingOptions | undefined;
+};
+
+/** @internal */
+export type DatasourcesServicePreviewChunksRequest$Outbound = {
+  file_id: string;
+  chunking_options?: DatasourceChunkingOptions$Outbound | undefined;
+};
+
+/** @internal */
+export const DatasourcesServicePreviewChunksRequest$outboundSchema: z.ZodType<
+  DatasourcesServicePreviewChunksRequest$Outbound,
+  z.ZodTypeDef,
+  DatasourcesServicePreviewChunksRequest
+> = z.object({
+  fileId: z.string(),
+  chunkingOptions: DatasourceChunkingOptions$outboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    fileId: "file_id",
+    chunkingOptions: "chunking_options",
+  });
+});
+
+export function datasourcesServicePreviewChunksRequestToJSON(
+  datasourcesServicePreviewChunksRequest:
+    DatasourcesServicePreviewChunksRequest,
+): string {
+  return JSON.stringify(
+    DatasourcesServicePreviewChunksRequest$outboundSchema.parse(
+      datasourcesServicePreviewChunksRequest,
+    ),
+  );
+}

package/src/models/components/datasourcesservicepreviewchunksresponse.ts

@@ -0,0 +1,44 @@
+/*
+ * 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 { PreviewChunk, PreviewChunk$inboundSchema } from "./previewchunk.js";
+import {
+  PreviewChunksMetadata,
+  PreviewChunksMetadata$inboundSchema,
+} from "./previewchunksmetadata.js";
+
+export type DatasourcesServicePreviewChunksResponse = {
+  chunks: Array<PreviewChunk>;
+  metadata: PreviewChunksMetadata;
+};
+
+/** @internal */
+export const DatasourcesServicePreviewChunksResponse$inboundSchema: z.ZodType<
+  DatasourcesServicePreviewChunksResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  chunks: z.array(PreviewChunk$inboundSchema),
+  metadata: PreviewChunksMetadata$inboundSchema,
+});
+
+export function datasourcesServicePreviewChunksResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  DatasourcesServicePreviewChunksResponse,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DatasourcesServicePreviewChunksResponse$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'DatasourcesServicePreviewChunksResponse' from JSON`,
+  );
+}

package/src/models/components/deleteannotationqueueresponse.ts

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

package/src/models/components/deleteevaluatorresponse.ts

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

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

@@ -4,6 +4,34 @@
 
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
+import { ClosedEnum } from "../../types/enums.js";
+
+/**
+ * Whether the agent may only read this file system, or also write to it.
+ */
+export const AccessMode = {
+  ReadOnly: "read_only",
+  ReadWrite: "read_write",
+} as const;
+/**
+ * Whether the agent may only read this file system, or also write to it.
+ */
+export type AccessMode = ClosedEnum<typeof AccessMode>;
+
+export type Configuration = {
+  /**
+   * The id of the file system to attach.
+   */
+  fileSystemId?: string | undefined;
+  /**
+   * The key of the file system to attach.
+   */
+  fileSystemKey?: string | undefined;
+  /**
+   * Whether the agent may only read this file system, or also write to it.
+   */
+  accessMode?: AccessMode | undefined;
+};
 
 /**
  * Attaches a persistent file system to the agent, named by file_system_id or file_system_key in the configuration. The agent may only read it unless the configured access_mode is read_write.
@@ -14,17 +42,46 @@ export type FileSystemToolInput = {
    * Whether this tool requires approval before execution
    */
   requiresApproval?: boolean | undefined;
-  /**
-   * Static tool configuration set at design time. Merged over LLM-provided arguments at execution time.
-   */
-  configuration?: { [k: string]: any } | undefined;
+  configuration: Configuration;
 };
 
+/** @internal */
+export const AccessMode$outboundSchema: z.ZodNativeEnum<typeof AccessMode> = z
+  .nativeEnum(AccessMode);
+
+/** @internal */
+export type Configuration$Outbound = {
+  file_system_id?: string | undefined;
+  file_system_key?: string | undefined;
+  access_mode: string;
+};
+
+/** @internal */
+export const Configuration$outboundSchema: z.ZodType<
+  Configuration$Outbound,
+  z.ZodTypeDef,
+  Configuration
+> = z.object({
+  fileSystemId: z.string().optional(),
+  fileSystemKey: z.string().optional(),
+  accessMode: AccessMode$outboundSchema.default("read_only"),
+}).transform((v) => {
+  return remap$(v, {
+    fileSystemId: "file_system_id",
+    fileSystemKey: "file_system_key",
+    accessMode: "access_mode",
+  });
+});
+
+export function configurationToJSON(configuration: Configuration): string {
+  return JSON.stringify(Configuration$outboundSchema.parse(configuration));
+}
+
 /** @internal */
 export type FileSystemToolInput$Outbound = {
   type: "file_system";
   requires_approval?: boolean | undefined;
-  configuration?: { [k: string]: any } | undefined;
+  configuration: Configuration$Outbound;
 };
 
 /** @internal */
@@ -35,7 +92,7 @@ export const FileSystemToolInput$outboundSchema: z.ZodType<
 > = z.object({
   type: z.literal("file_system"),
   requiresApproval: z.boolean().optional(),
-  configuration: z.record(z.any()).optional(),
+  configuration: z.lazy(() => Configuration$outboundSchema),
 }).transform((v) => {
   return remap$(v, {
     requiresApproval: "requires_approval",

package/src/models/components/filter.ts

@@ -56,7 +56,7 @@ export type Field = ClosedEnum<typeof Field>;
 /**
  * Predicate operator. `eq` and `neq` accept exactly one value; `in` and `not_in` accept 1-100 values.
  */
-export const FilterOp = {
+export const Op = {
   Eq: "eq",
   Neq: "neq",
   In: "in",
@@ -65,7 +65,7 @@ export const FilterOp = {
 /**
  * Predicate operator. `eq` and `neq` accept exactly one value; `in` and `not_in` accept 1-100 values.
  */
-export type FilterOp = ClosedEnum<typeof FilterOp>;
+export type Op = ClosedEnum<typeof Op>;
 
 export type Filter = {
   /**
@@ -75,7 +75,7 @@ export type Filter = {
   /**
    * Predicate operator. `eq` and `neq` accept exactly one value; `in` and `not_in` accept 1-100 values.
    */
-  op?: FilterOp | undefined;
+  op?: Op | undefined;
   /**
    * Values compared against the selected field. Values are interpreted
    *
@@ -94,17 +94,15 @@ export const Field$outboundSchema: z.ZodNativeEnum<typeof Field> =
   Field$inboundSchema;
 
 /** @internal */
-export const FilterOp$inboundSchema: z.ZodNativeEnum<typeof FilterOp> = z
-  .nativeEnum(FilterOp);
+export const Op$inboundSchema: z.ZodNativeEnum<typeof Op> = z.nativeEnum(Op);
 /** @internal */
-export const FilterOp$outboundSchema: z.ZodNativeEnum<typeof FilterOp> =
-  FilterOp$inboundSchema;
+export const Op$outboundSchema: z.ZodNativeEnum<typeof Op> = Op$inboundSchema;
 
 /** @internal */
 export const Filter$inboundSchema: z.ZodType<Filter, z.ZodTypeDef, unknown> = z
   .object({
     field: Field$inboundSchema.optional(),
-    op: FilterOp$inboundSchema.optional(),
+    op: Op$inboundSchema.optional(),
     values: z.array(z.string()).optional(),
   });
 /** @internal */
@@ -121,7 +119,7 @@ export const Filter$outboundSchema: z.ZodType<
   Filter
 > = z.object({
   field: Field$outboundSchema.optional(),
-  op: FilterOp$outboundSchema.optional(),
+  op: Op$outboundSchema.optional(),
   values: z.array(z.string()).optional(),
 });
 

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

@@ -14,6 +14,10 @@ import {
 export type GetUploadFileUrlResponse = {
   objectName: string;
   postPolicy: UploadPostPolicy;
+  /**
+   * Identifier of the file record registered for this upload
+   */
+  fileId: string;
 };
 
 /** @internal */
@@ -24,6 +28,7 @@ export const GetUploadFileUrlResponse$inboundSchema: z.ZodType<
 > = z.object({
   objectName: z.string(),
   postPolicy: UploadPostPolicy$inboundSchema,
+  fileId: z.string(),
 });
 
 export function getUploadFileUrlResponseFromJSON(

package/src/models/components/getworkspaceresponse.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 { Workspace, Workspace$inboundSchema } from "./workspace.js";
+
+export type GetWorkspaceResponse = {
+  workspace: Workspace;
+};
+
+/** @internal */
+export const GetWorkspaceResponse$inboundSchema: z.ZodType<
+  GetWorkspaceResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  workspace: Workspace$inboundSchema,
+});
+
+export function getWorkspaceResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetWorkspaceResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetWorkspaceResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetWorkspaceResponse' 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",
   });
 });