@orq-ai/node 4.13.13 → 4.13.16

package/packages/orq-rc/src/models/components/creatememoryrequest.ts

@@ -0,0 +1,39 @@
+/*
+ * 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 CreateMemoryRequest = {
+  /**
+   * Unique identifier for the entity this memory is associated with (e.g., user ID, session ID, conversation ID).
+   */
+  entityId: string;
+};
+
+/** @internal */
+export type CreateMemoryRequest$Outbound = {
+  entity_id: string;
+};
+
+/** @internal */
+export const CreateMemoryRequest$outboundSchema: z.ZodType<
+  CreateMemoryRequest$Outbound,
+  z.ZodTypeDef,
+  CreateMemoryRequest
+> = z.object({
+  entityId: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    entityId: "entity_id",
+  });
+});
+
+export function createMemoryRequestToJSON(
+  createMemoryRequest: CreateMemoryRequest,
+): string {
+  return JSON.stringify(
+    CreateMemoryRequest$outboundSchema.parse(createMemoryRequest),
+  );
+}

package/packages/orq-rc/src/models/components/creatememorystorerequest.ts

@@ -0,0 +1,59 @@
+/*
+ * 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 {
+  MemoryStoreEmbeddingConfig,
+  MemoryStoreEmbeddingConfig$Outbound,
+  MemoryStoreEmbeddingConfig$outboundSchema,
+} from "./memorystoreembeddingconfig.js";
+
+export type CreateMemoryStoreRequest = {
+  /**
+   * The unique key of the memory store. The key is unique and inmmutable and cannot be repeated within the same workspace.
+   */
+  key: string;
+  embeddingConfig: MemoryStoreEmbeddingConfig;
+  description: string;
+  ttl?: number | null | undefined;
+  /**
+   * Entity storage path. With workspace-level API keys, the first element identifies the project. With project-level API keys, the path is relative to that project.
+   */
+  path: string;
+};
+
+/** @internal */
+export type CreateMemoryStoreRequest$Outbound = {
+  key: string;
+  embedding_config: MemoryStoreEmbeddingConfig$Outbound;
+  description: string;
+  ttl?: number | null | undefined;
+  path: string;
+};
+
+/** @internal */
+export const CreateMemoryStoreRequest$outboundSchema: z.ZodType<
+  CreateMemoryStoreRequest$Outbound,
+  z.ZodTypeDef,
+  CreateMemoryStoreRequest
+> = z.object({
+  key: z.string(),
+  embeddingConfig: MemoryStoreEmbeddingConfig$outboundSchema,
+  description: z.string(),
+  ttl: z.nullable(z.number()).optional(),
+  path: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    embeddingConfig: "embedding_config",
+  });
+});
+
+export function createMemoryStoreRequestToJSON(
+  createMemoryStoreRequest: CreateMemoryStoreRequest,
+): string {
+  return JSON.stringify(
+    CreateMemoryStoreRequest$outboundSchema.parse(createMemoryStoreRequest),
+  );
+}

package/packages/orq-rc/src/models/components/datasource.ts

@@ -0,0 +1,108 @@
+/*
+ * 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";
+import { CountMetadata, CountMetadata$inboundSchema } from "./countmetadata.js";
+import {
+  DatasourceAttachment,
+  DatasourceAttachment$inboundSchema,
+} from "./datasourceattachment.js";
+import {
+  ProcessingAttempt,
+  ProcessingAttempt$inboundSchema,
+} from "./processingattempt.js";
+
+export const DatasourceStatus = {
+  Pending: "pending",
+  Processing: "processing",
+  Completed: "completed",
+  Failed: "failed",
+  Queued: "queued",
+} as const;
+export type DatasourceStatus = ClosedEnum<typeof DatasourceStatus>;
+
+export type Datasource = {
+  displayName: string;
+  /**
+   * The description of the knowledge base
+   */
+  description?: string | null | undefined;
+  status: DatasourceStatus;
+  /**
+   * The unique identifier of the file used to create the datasource.
+   */
+  fileId?: string | null | undefined;
+  created: string;
+  updated: string;
+  /**
+   * The user ID of the creator of the knowledge base
+   */
+  createdById?: string | null | undefined;
+  /**
+   * The user ID of the last user who updated the knowledge base
+   */
+  updateById?: string | null | undefined;
+  knowledgeId: string;
+  chunksCount: number;
+  /**
+   * Additive compatibility fields formerly available only from database-shaped responses.
+   */
+  processingAttempts?: Array<ProcessingAttempt> | undefined;
+  metadata?: CountMetadata | undefined;
+  attachment?: DatasourceAttachment | undefined;
+  id: string;
+};
+
+/** @internal */
+export const DatasourceStatus$inboundSchema: z.ZodNativeEnum<
+  typeof DatasourceStatus
+> = z.nativeEnum(DatasourceStatus);
+
+/** @internal */
+export const Datasource$inboundSchema: z.ZodType<
+  Datasource,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  display_name: z.string(),
+  description: z.nullable(z.string()).optional(),
+  status: DatasourceStatus$inboundSchema,
+  file_id: z.nullable(z.string()).optional(),
+  created: z.string(),
+  updated: z.string(),
+  created_by_id: z.nullable(z.string()).optional(),
+  update_by_id: z.nullable(z.string()).optional(),
+  knowledge_id: z.string(),
+  chunks_count: z.number(),
+  processing_attempts: z.array(ProcessingAttempt$inboundSchema).optional(),
+  metadata: CountMetadata$inboundSchema.optional(),
+  attachment: DatasourceAttachment$inboundSchema.optional(),
+  _id: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    "display_name": "displayName",
+    "file_id": "fileId",
+    "created_by_id": "createdById",
+    "update_by_id": "updateById",
+    "knowledge_id": "knowledgeId",
+    "chunks_count": "chunksCount",
+    "processing_attempts": "processingAttempts",
+    "_id": "id",
+  });
+});
+
+export function datasourceFromJSON(
+  jsonString: string,
+): SafeParseResult<Datasource, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Datasource$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Datasource' from JSON`,
+  );
+}

package/packages/orq-rc/src/models/components/datasourceattachment.ts

@@ -0,0 +1,64 @@
+/*
+ * 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 DatasourceAttachment = {
+  id?: string | undefined;
+  objectName?: string | undefined;
+};
+
+/** @internal */
+export const DatasourceAttachment$inboundSchema: z.ZodType<
+  DatasourceAttachment,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string().optional(),
+  object_name: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "object_name": "objectName",
+  });
+});
+/** @internal */
+export type DatasourceAttachment$Outbound = {
+  id?: string | undefined;
+  object_name?: string | undefined;
+};
+
+/** @internal */
+export const DatasourceAttachment$outboundSchema: z.ZodType<
+  DatasourceAttachment$Outbound,
+  z.ZodTypeDef,
+  DatasourceAttachment
+> = z.object({
+  id: z.string().optional(),
+  objectName: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    objectName: "object_name",
+  });
+});
+
+export function datasourceAttachmentToJSON(
+  datasourceAttachment: DatasourceAttachment,
+): string {
+  return JSON.stringify(
+    DatasourceAttachment$outboundSchema.parse(datasourceAttachment),
+  );
+}
+export function datasourceAttachmentFromJSON(
+  jsonString: string,
+): SafeParseResult<DatasourceAttachment, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DatasourceAttachment$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DatasourceAttachment' from JSON`,
+  );
+}

package/packages/orq-rc/src/models/components/datasourcechunkingoptions.ts

@@ -0,0 +1,53 @@
+/*
+ * 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 {
+  ChunkingCleanupOptions,
+  ChunkingCleanupOptions$Outbound,
+  ChunkingCleanupOptions$outboundSchema,
+} from "./chunkingcleanupoptions.js";
+import {
+  ChunkingConfiguration,
+  ChunkingConfiguration$Outbound,
+  ChunkingConfiguration$outboundSchema,
+} from "./chunkingconfiguration.js";
+
+export type DatasourceChunkingOptions = {
+  /**
+   * The chunking configuration settings for the datasource. Defaults to the system's standard chunking configuration if not specified.
+   */
+  chunkingConfiguration?: ChunkingConfiguration | undefined;
+  chunkingCleanupOptions?: ChunkingCleanupOptions | undefined;
+};
+
+/** @internal */
+export type DatasourceChunkingOptions$Outbound = {
+  chunking_configuration?: ChunkingConfiguration$Outbound | undefined;
+  chunking_cleanup_options?: ChunkingCleanupOptions$Outbound | undefined;
+};
+
+/** @internal */
+export const DatasourceChunkingOptions$outboundSchema: z.ZodType<
+  DatasourceChunkingOptions$Outbound,
+  z.ZodTypeDef,
+  DatasourceChunkingOptions
+> = z.object({
+  chunkingConfiguration: ChunkingConfiguration$outboundSchema.optional(),
+  chunkingCleanupOptions: ChunkingCleanupOptions$outboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    chunkingConfiguration: "chunking_configuration",
+    chunkingCleanupOptions: "chunking_cleanup_options",
+  });
+});
+
+export function datasourceChunkingOptionsToJSON(
+  datasourceChunkingOptions: DatasourceChunkingOptions,
+): string {
+  return JSON.stringify(
+    DatasourceChunkingOptions$outboundSchema.parse(datasourceChunkingOptions),
+  );
+}

package/packages/orq-rc/src/models/components/datasourcesservicecreaterequest.ts

@@ -0,0 +1,79 @@
+/*
+ * 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 {
+  CountMetadata,
+  CountMetadata$Outbound,
+  CountMetadata$outboundSchema,
+} from "./countmetadata.js";
+import {
+  DatasourceAttachment,
+  DatasourceAttachment$Outbound,
+  DatasourceAttachment$outboundSchema,
+} from "./datasourceattachment.js";
+import {
+  DatasourceChunkingOptions,
+  DatasourceChunkingOptions$Outbound,
+  DatasourceChunkingOptions$outboundSchema,
+} from "./datasourcechunkingoptions.js";
+
+export type DatasourcesServiceCreateRequest = {
+  displayName?: string | undefined;
+  /**
+   * The description of the knowledge base
+   */
+  description?: string | null | undefined;
+  fileId?: string | undefined;
+  chunkingOptions?: DatasourceChunkingOptions | undefined;
+  /**
+   * Compatibility fields used by the former datasource shell/legacy route.
+   */
+  id?: string | undefined;
+  attachment?: DatasourceAttachment | undefined;
+  metadata?: CountMetadata | undefined;
+};
+
+/** @internal */
+export type DatasourcesServiceCreateRequest$Outbound = {
+  display_name?: string | undefined;
+  description?: string | null | undefined;
+  file_id?: string | undefined;
+  chunking_options?: DatasourceChunkingOptions$Outbound | undefined;
+  id?: string | undefined;
+  attachment?: DatasourceAttachment$Outbound | undefined;
+  metadata?: CountMetadata$Outbound | undefined;
+};
+
+/** @internal */
+export const DatasourcesServiceCreateRequest$outboundSchema: z.ZodType<
+  DatasourcesServiceCreateRequest$Outbound,
+  z.ZodTypeDef,
+  DatasourcesServiceCreateRequest
+> = z.object({
+  displayName: z.string().optional(),
+  description: z.nullable(z.string()).optional(),
+  fileId: z.string().optional(),
+  chunkingOptions: DatasourceChunkingOptions$outboundSchema.optional(),
+  id: z.string().optional(),
+  attachment: DatasourceAttachment$outboundSchema.optional(),
+  metadata: CountMetadata$outboundSchema.optional(),
+}).transform((v) => {
+  return remap$(v, {
+    displayName: "display_name",
+    fileId: "file_id",
+    chunkingOptions: "chunking_options",
+  });
+});
+
+export function datasourcesServiceCreateRequestToJSON(
+  datasourcesServiceCreateRequest: DatasourcesServiceCreateRequest,
+): string {
+  return JSON.stringify(
+    DatasourcesServiceCreateRequest$outboundSchema.parse(
+      datasourcesServiceCreateRequest,
+    ),
+  );
+}

package/packages/orq-rc/src/models/components/datasourcesservicegetprocessingstatusresponse.ts

@@ -0,0 +1,69 @@
+/*
+ * 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 {
+  ChunkProcessingAttempts,
+  ChunkProcessingAttempts$inboundSchema,
+} from "./chunkprocessingattempts.js";
+import {
+  ProcessingAttempt,
+  ProcessingAttempt$inboundSchema,
+} from "./processingattempt.js";
+
+export type DatasourcesServiceGetProcessingStatusResponse = {
+  totalQueued: number;
+  totalCompleted: number;
+  totalPassed: number;
+  totalFailed: number;
+  overallTotalProcessing: number;
+  chunksProcessingAttempts: Array<ChunkProcessingAttempts>;
+  datasourceProcessingAttempts: Array<ProcessingAttempt>;
+};
+
+/** @internal */
+export const DatasourcesServiceGetProcessingStatusResponse$inboundSchema:
+  z.ZodType<
+    DatasourcesServiceGetProcessingStatusResponse,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    total_queued: z.number(),
+    total_completed: z.number(),
+    total_passed: z.number(),
+    total_failed: z.number(),
+    overall_total_processing: z.number(),
+    chunks_processing_attempts: z.array(ChunkProcessingAttempts$inboundSchema),
+    datasource_processing_attempts: z.array(ProcessingAttempt$inboundSchema),
+  }).transform((v) => {
+    return remap$(v, {
+      "total_queued": "totalQueued",
+      "total_completed": "totalCompleted",
+      "total_passed": "totalPassed",
+      "total_failed": "totalFailed",
+      "overall_total_processing": "overallTotalProcessing",
+      "chunks_processing_attempts": "chunksProcessingAttempts",
+      "datasource_processing_attempts": "datasourceProcessingAttempts",
+    });
+  });
+
+export function datasourcesServiceGetProcessingStatusResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  DatasourcesServiceGetProcessingStatusResponse,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      DatasourcesServiceGetProcessingStatusResponse$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'DatasourcesServiceGetProcessingStatusResponse' from JSON`,
+  );
+}

package/packages/orq-rc/src/models/components/datasourcesservicelistresponse.ts

@@ -0,0 +1,55 @@
+/*
+ * 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";
+import { Datasource, Datasource$inboundSchema } from "./datasource.js";
+
+export const DatasourcesServiceListResponseObject = {
+  List: "list",
+} as const;
+export type DatasourcesServiceListResponseObject = ClosedEnum<
+  typeof DatasourcesServiceListResponseObject
+>;
+
+export type DatasourcesServiceListResponse = {
+  object: DatasourcesServiceListResponseObject;
+  data: Array<Datasource>;
+  hasMore: boolean;
+};
+
+/** @internal */
+export const DatasourcesServiceListResponseObject$inboundSchema:
+  z.ZodNativeEnum<typeof DatasourcesServiceListResponseObject> = z.nativeEnum(
+    DatasourcesServiceListResponseObject,
+  );
+
+/** @internal */
+export const DatasourcesServiceListResponse$inboundSchema: z.ZodType<
+  DatasourcesServiceListResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  object: DatasourcesServiceListResponseObject$inboundSchema,
+  data: z.array(Datasource$inboundSchema),
+  has_more: z.boolean(),
+}).transform((v) => {
+  return remap$(v, {
+    "has_more": "hasMore",
+  });
+});
+
+export function datasourcesServiceListResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<DatasourcesServiceListResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DatasourcesServiceListResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DatasourcesServiceListResponse' from JSON`,
+  );
+}

package/packages/orq-rc/src/models/components/datasourcesserviceupdaterequest.ts

@@ -0,0 +1,41 @@
+/*
+ * 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 DatasourcesServiceUpdateRequest = {
+  displayName: string;
+  description?: string | null | undefined;
+};
+
+/** @internal */
+export type DatasourcesServiceUpdateRequest$Outbound = {
+  display_name: string;
+  description?: string | null | undefined;
+};
+
+/** @internal */
+export const DatasourcesServiceUpdateRequest$outboundSchema: z.ZodType<
+  DatasourcesServiceUpdateRequest$Outbound,
+  z.ZodTypeDef,
+  DatasourcesServiceUpdateRequest
+> = z.object({
+  displayName: z.string(),
+  description: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    displayName: "display_name",
+  });
+});
+
+export function datasourcesServiceUpdateRequestToJSON(
+  datasourcesServiceUpdateRequest: DatasourcesServiceUpdateRequest,
+): string {
+  return JSON.stringify(
+    DatasourcesServiceUpdateRequest$outboundSchema.parse(
+      datasourcesServiceUpdateRequest,
+    ),
+  );
+}

package/packages/orq-rc/src/models/components/domain.ts

@@ -14,7 +14,8 @@ import { ScopeMode, ScopeMode$inboundSchema } from "./scopemode.js";
  * Domain describes a permission domain that can be granted to an
  *
  * @remarks
- *  API key. Verbs are derived from id + group + readable/writable.
+ *  API key. Standard verbs are derived from id + group +
+ *  readable/writable; exceptional write verbs are explicit data.
  */
 export type Domain = {
   /**
@@ -45,6 +46,14 @@ export type Domain = {
    * Whether this domain can be granted write access.
    */
   writable?: boolean | undefined;
+  /**
+   * Additional full verb names granted only with write access. This is
+   *
+   * @remarks
+   *  additive to the standard group-derived verbs and intentionally does
+   *  not affect read access (e.g. "insights.run").
+   */
+  extraWriteVerbs?: Array<string> | undefined;
 };
 
 /** @internal */
@@ -56,10 +65,12 @@ export const Domain$inboundSchema: z.ZodType<Domain, z.ZodTypeDef, unknown> = z
     allowed_scopes: z.array(ScopeMode$inboundSchema).optional(),
     readable: z.boolean().optional(),
     writable: z.boolean().optional(),
+    extra_write_verbs: z.array(z.string()).optional(),
   }).transform((v) => {
     return remap$(v, {
       "display_name": "displayName",
       "allowed_scopes": "allowedScopes",
+      "extra_write_verbs": "extraWriteVerbs",
     });
   });