@orq-ai/node 4.14.0-rc.20 → 4.14.0-rc.37

package/src/models/components/countmetadata.ts

@@ -0,0 +1,86 @@
+/*
+ * 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 CountMetadata = {
+  wordsCount?: number | undefined;
+  sentencesCount?: number | undefined;
+  paragraphsCount?: number | undefined;
+  tokensCount?: number | undefined;
+  charactersCount?: number | undefined;
+  chunksCount?: number | undefined;
+};
+
+/** @internal */
+export const CountMetadata$inboundSchema: z.ZodType<
+  CountMetadata,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  words_count: z.number().optional(),
+  sentences_count: z.number().optional(),
+  paragraphs_count: z.number().optional(),
+  tokens_count: z.number().optional(),
+  characters_count: z.number().optional(),
+  chunks_count: z.number().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "words_count": "wordsCount",
+    "sentences_count": "sentencesCount",
+    "paragraphs_count": "paragraphsCount",
+    "tokens_count": "tokensCount",
+    "characters_count": "charactersCount",
+    "chunks_count": "chunksCount",
+  });
+});
+/** @internal */
+export type CountMetadata$Outbound = {
+  words_count?: number | undefined;
+  sentences_count?: number | undefined;
+  paragraphs_count?: number | undefined;
+  tokens_count?: number | undefined;
+  characters_count?: number | undefined;
+  chunks_count?: number | undefined;
+};
+
+/** @internal */
+export const CountMetadata$outboundSchema: z.ZodType<
+  CountMetadata$Outbound,
+  z.ZodTypeDef,
+  CountMetadata
+> = z.object({
+  wordsCount: z.number().optional(),
+  sentencesCount: z.number().optional(),
+  paragraphsCount: z.number().optional(),
+  tokensCount: z.number().optional(),
+  charactersCount: z.number().optional(),
+  chunksCount: z.number().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    wordsCount: "words_count",
+    sentencesCount: "sentences_count",
+    paragraphsCount: "paragraphs_count",
+    tokensCount: "tokens_count",
+    charactersCount: "characters_count",
+    chunksCount: "chunks_count",
+  });
+});
+
+export function countMetadataToJSON(countMetadata: CountMetadata): string {
+  return JSON.stringify(CountMetadata$outboundSchema.parse(countMetadata));
+}
+export function countMetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<CountMetadata, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CountMetadata$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CountMetadata' from JSON`,
+  );
+}

package/src/models/components/createguardrailrulerequest.ts

@@ -34,7 +34,6 @@ export type CreateGuardrailRuleRequest = {
   expression?: GuardrailRuleExpression | undefined;
   guardrails?: Array<GuardrailRuleGuardrail> | undefined;
   plugins?: Array<GuardrailRulePlugin> | undefined;
-  timeout?: number | undefined;
 };
 
 /** @internal */
@@ -46,7 +45,6 @@ export type CreateGuardrailRuleRequest$Outbound = {
   expression?: GuardrailRuleExpression$Outbound | undefined;
   guardrails?: Array<GuardrailRuleGuardrail$Outbound> | undefined;
   plugins?: Array<GuardrailRulePlugin$Outbound> | undefined;
-  timeout?: number | undefined;
 };
 
 /** @internal */
@@ -62,7 +60,6 @@ export const CreateGuardrailRuleRequest$outboundSchema: z.ZodType<
   expression: GuardrailRuleExpression$outboundSchema.optional(),
   guardrails: z.array(GuardrailRuleGuardrail$outboundSchema).optional(),
   plugins: z.array(GuardrailRulePlugin$outboundSchema).optional(),
-  timeout: z.number().int().optional(),
 }).transform((v) => {
   return remap$(v, {
     displayName: "display_name",

package/src/models/components/creatememorydocumentrequest.ts

@@ -0,0 +1,42 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+
+export type CreateMemoryDocumentRequest = {
+  /**
+   * The content of the memory document (whitespace trimmed).
+   */
+  text: string;
+  /**
+   * Flexible key-value pairs for custom filtering and categorization. Clients can add arbitrary string metadata to enable future filtering of memory documents based on their specific needs.
+   */
+  metadata?: { [k: string]: string } | undefined;
+};
+
+/** @internal */
+export type CreateMemoryDocumentRequest$Outbound = {
+  text: string;
+  metadata?: { [k: string]: string } | undefined;
+};
+
+/** @internal */
+export const CreateMemoryDocumentRequest$outboundSchema: z.ZodType<
+  CreateMemoryDocumentRequest$Outbound,
+  z.ZodTypeDef,
+  CreateMemoryDocumentRequest
+> = z.object({
+  text: z.string(),
+  metadata: z.record(z.string()).optional(),
+});
+
+export function createMemoryDocumentRequestToJSON(
+  createMemoryDocumentRequest: CreateMemoryDocumentRequest,
+): string {
+  return JSON.stringify(
+    CreateMemoryDocumentRequest$outboundSchema.parse(
+      createMemoryDocumentRequest,
+    ),
+  );
+}

package/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/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/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/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/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/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/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/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`,
+  );
+}