@orq-ai/node 4.15.0-rc.5 → 4.15.0-rc.51

package/src/models/components/chunkingconfiguration.ts

@@ -4,9 +4,195 @@
 
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
+import { ClosedEnum } from "../../types/enums.js";
 
 /**
- * Provides advanced settings for customizing chunking behavior, enabling fine-grained control to better meet specific data processing needs.
+ * Asks a model to choose the boundaries. Slowest and most expensive, best on documents with irregular structure. Makes paid model calls.
+ */
+export type Nine = {
+  type: "agentic";
+  /**
+   * Maximum number of tokens per chunk.
+   */
+  chunkSize?: number | undefined;
+  /**
+   * Model that chooses the chunk boundaries.
+   */
+  model?: string | undefined;
+  /**
+   * Size of candidate splits offered to the model.
+   */
+  candidateSize?: number | undefined;
+  /**
+   * Minimum number of characters each chunk must contain.
+   */
+  minCharactersPerChunk?: number | undefined;
+  /**
+   * Custom system prompt for the boundary model.
+   */
+  systemPrompt?: string | undefined;
+};
+
+/**
+ * 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 = {
+  type: "late";
+  /**
+   * Maximum number of tokens per chunk.
+   */
+  chunkSize?: number | undefined;
+  /**
+   * Separator hierarchy to split on, tried in order. Defaults to paragraph, line, space, then character.
+   */
+  separators?: Array<string> | undefined;
+  /**
+   * Minimum number of characters each chunk must contain.
+   */
+  minCharactersPerChunk?: number | undefined;
+  /**
+   * Embedding model used to embed the document before it is split.
+   */
+  embeddingModel?: string | undefined;
+  /**
+   * Number of dimensions for the embedding output, when the model supports it.
+   */
+  dimensions?: number | undefined;
+};
+
+/**
+ * Comparison mode.
+ */
+export const ChunkingConfigurationMode = {
+  Window: "window",
+  Sentence: "sentence",
+} as const;
+/**
+ * Comparison mode.
+ */
+export type ChunkingConfigurationMode = ClosedEnum<
+  typeof ChunkingConfigurationMode
+>;
+
+/**
+ * Embeds the text and breaks where meaning shifts, so related passages stay together. Makes paid embedding calls.
+ */
+export type Seven = {
+  type: "semantic";
+  /**
+   * Maximum number of tokens per chunk.
+   */
+  chunkSize?: number | undefined;
+  /**
+   * Embedding model used to detect semantic boundaries.
+   */
+  embeddingModel?: string | undefined;
+  /**
+   * Number of dimensions for the embedding output, when the model supports it.
+   */
+  dimensions?: number | undefined;
+  /**
+   * Similarity threshold from 0 through 1, or "auto".
+   */
+  threshold?: string | undefined;
+  /**
+   * Comparison mode.
+   */
+  mode?: ChunkingConfigurationMode | undefined;
+  /**
+   * Window size for similarity comparison.
+   */
+  similarityWindow?: number | undefined;
+};
+
+/**
+ * Splits on delimiters or a regular expression without tokenizing. Fastest option; chunk sizes vary with where delimiters fall.
+ */
+export type Six = {
+  type: "fast";
+  /**
+   * Target chunk size in bytes.
+   */
+  targetSize?: number | undefined;
+  /**
+   * Single-byte characters to split on.
+   */
+  delimiters?: string | undefined;
+  /**
+   * Multi-byte split pattern. Takes precedence over delimiters when set.
+   */
+  pattern?: string | undefined;
+  /**
+   * Attach the delimiter to the start of the next chunk instead of the end of the previous one.
+   */
+  prefix?: boolean | undefined;
+  /**
+   * Split at the start of a run of consecutive delimiters rather than at each one.
+   */
+  consecutive?: boolean | undefined;
+  /**
+   * Search forward for a delimiter when searching backward finds none.
+   */
+  forwardFallback?: boolean | undefined;
+};
+
+/**
+ * Splits on a separator hierarchy, falling back through paragraph, line, sentence, and word boundaries until chunks fit. Respects document structure.
+ */
+export type Five = {
+  type: "recursive";
+  /**
+   * Maximum number of tokens per chunk.
+   */
+  chunkSize?: number | undefined;
+  /**
+   * Separator hierarchy to split on, tried in order. Defaults to paragraph, line, space, then character.
+   */
+  separators?: Array<string> | undefined;
+  /**
+   * Minimum number of characters each chunk must contain.
+   */
+  minCharactersPerChunk?: number | undefined;
+};
+
+/**
+ * Groups whole sentences up to the chunk size, so chunks never cut a sentence in half.
+ */
+export type Four = {
+  type: "sentence";
+  /**
+   * Maximum number of tokens per chunk.
+   */
+  chunkSize?: number | undefined;
+  /**
+   * Number of tokens to overlap between consecutive chunks. Helps preserve continuity across chunk boundaries.
+   */
+  chunkOverlap?: number | undefined;
+  /**
+   * Minimum number of sentences each chunk must contain.
+   */
+  minSentencesPerChunk?: number | undefined;
+};
+
+/**
+ * Splits text into fixed-size token windows with optional overlap. Predictable chunk sizes, no regard for sentence or paragraph boundaries.
+ */
+export type Three = {
+  type: "token";
+  /**
+   * Maximum number of tokens per chunk.
+   */
+  chunkSize?: number | undefined;
+  /**
+   * Number of tokens to overlap between consecutive chunks. Helps preserve continuity across chunk boundaries.
+   */
+  chunkOverlap?: number | undefined;
+};
+
+/**
+ * Provides advanced settings for customizing chunking behavior, enabling fine-grained control to better meet specific data processing needs. Deprecated: use one of the named chunking strategies instead.
+ *
+ * @deprecated class: This will be removed in a future release, please migrate away from it as soon as possible.
  */
 export type ChunkingConfiguration2 = {
   type: "advanced";
@@ -21,7 +207,9 @@ export type ChunkingConfiguration2 = {
 };
 
 /**
- * Optimized chunking strategy focusing on speed and avoiding duplication of content chunks.
+ * Optimized chunking strategy focusing on speed and avoiding duplication of content chunks. Deprecated: use one of the named chunking strategies instead.
+ *
+ * @deprecated class: This will be removed in a future release, please migrate away from it as soon as possible.
  */
 export type ChunkingConfiguration1 = {
   type: "default";
@@ -32,7 +220,233 @@ export type ChunkingConfiguration1 = {
  */
 export type ChunkingConfiguration =
   | ChunkingConfiguration1
-  | ChunkingConfiguration2;
+  | ChunkingConfiguration2
+  | Three
+  | Four
+  | Five
+  | Six
+  | Seven
+  | Eight
+  | Nine;
+
+/** @internal */
+export type Nine$Outbound = {
+  type: "agentic";
+  chunk_size: number;
+  model: string;
+  candidate_size: number;
+  min_characters_per_chunk: number;
+  system_prompt?: string | undefined;
+};
+
+/** @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 function nineToJSON(nine: Nine): string {
+  return JSON.stringify(Nine$outboundSchema.parse(nine));
+}
+
+/** @internal */
+export type Eight$Outbound = {
+  type: "late";
+  chunk_size: number;
+  separators?: Array<string> | undefined;
+  min_characters_per_chunk: number;
+  embedding_model?: string | undefined;
+  dimensions?: number | undefined;
+};
+
+/** @internal */
+export const Eight$outboundSchema: z.ZodType<
+  Eight$Outbound,
+  z.ZodTypeDef,
+  Eight
+> = z.object({
+  type: z.literal("late"),
+  chunkSize: z.number().int().default(512),
+  separators: z.array(z.string()).optional(),
+  minCharactersPerChunk: z.number().int().default(24),
+  embeddingModel: z.string().optional(),
+  dimensions: z.number().int().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    chunkSize: "chunk_size",
+    minCharactersPerChunk: "min_characters_per_chunk",
+    embeddingModel: "embedding_model",
+  });
+});
+
+export function eightToJSON(eight: Eight): string {
+  return JSON.stringify(Eight$outboundSchema.parse(eight));
+}
+
+/** @internal */
+export const ChunkingConfigurationMode$outboundSchema: z.ZodNativeEnum<
+  typeof ChunkingConfigurationMode
+> = z.nativeEnum(ChunkingConfigurationMode);
+
+/** @internal */
+export type Seven$Outbound = {
+  type: "semantic";
+  chunk_size: number;
+  embedding_model?: string | undefined;
+  dimensions?: number | undefined;
+  threshold: string;
+  mode: string;
+  similarity_window: number;
+};
+
+/** @internal */
+export const Seven$outboundSchema: z.ZodType<
+  Seven$Outbound,
+  z.ZodTypeDef,
+  Seven
+> = z.object({
+  type: z.literal("semantic"),
+  chunkSize: z.number().int().default(512),
+  embeddingModel: z.string().optional(),
+  dimensions: z.number().int().optional(),
+  threshold: z.string().default("auto"),
+  mode: ChunkingConfigurationMode$outboundSchema.default("window"),
+  similarityWindow: z.number().int().default(1),
+}).transform((v) => {
+  return remap$(v, {
+    chunkSize: "chunk_size",
+    embeddingModel: "embedding_model",
+    similarityWindow: "similarity_window",
+  });
+});
+
+export function sevenToJSON(seven: Seven): string {
+  return JSON.stringify(Seven$outboundSchema.parse(seven));
+}
+
+/** @internal */
+export type Six$Outbound = {
+  type: "fast";
+  target_size: number;
+  delimiters: string;
+  pattern?: string | undefined;
+  prefix: boolean;
+  consecutive: boolean;
+  forward_fallback: boolean;
+};
+
+/** @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 function sixToJSON(six: Six): string {
+  return JSON.stringify(Six$outboundSchema.parse(six));
+}
+
+/** @internal */
+export type Five$Outbound = {
+  type: "recursive";
+  chunk_size: number;
+  separators?: Array<string> | undefined;
+  min_characters_per_chunk: number;
+};
+
+/** @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 function fiveToJSON(five: Five): string {
+  return JSON.stringify(Five$outboundSchema.parse(five));
+}
+
+/** @internal */
+export type Four$Outbound = {
+  type: "sentence";
+  chunk_size: number;
+  chunk_overlap: number;
+  min_sentences_per_chunk: number;
+};
+
+/** @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 function fourToJSON(four: Four): string {
+  return JSON.stringify(Four$outboundSchema.parse(four));
+}
+
+/** @internal */
+export type Three$Outbound = {
+  type: "token";
+  chunk_size: number;
+  chunk_overlap: number;
+};
+
+/** @internal */
+export const Three$outboundSchema: z.ZodType<
+  Three$Outbound,
+  z.ZodTypeDef,
+  Three
+> = z.object({
+  type: z.literal("token"),
+  chunkSize: z.number().int().default(512),
+  chunkOverlap: z.number().int().default(0),
+}).transform((v) => {
+  return remap$(v, {
+    chunkSize: "chunk_size",
+    chunkOverlap: "chunk_overlap",
+  });
+});
+
+export function threeToJSON(three: Three): string {
+  return JSON.stringify(Three$outboundSchema.parse(three));
+}
 
 /** @internal */
 export type ChunkingConfiguration2$Outbound = {
@@ -90,7 +504,14 @@ export function chunkingConfiguration1ToJSON(
 /** @internal */
 export type ChunkingConfiguration$Outbound =
   | ChunkingConfiguration1$Outbound
-  | ChunkingConfiguration2$Outbound;
+  | ChunkingConfiguration2$Outbound
+  | Three$Outbound
+  | Four$Outbound
+  | Five$Outbound
+  | Six$Outbound
+  | Seven$Outbound
+  | Eight$Outbound
+  | Nine$Outbound;
 
 /** @internal */
 export const ChunkingConfiguration$outboundSchema: z.ZodType<
@@ -100,6 +521,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),
 ]);
 
 export function chunkingConfigurationToJSON(

package/src/models/components/createmcpgatewayrequest.ts

@@ -8,6 +8,11 @@ import {
   McpGatewayMode,
   McpGatewayMode$outboundSchema,
 } from "./mcpgatewaymode.js";
+import {
+  McpGatewayPlugin,
+  McpGatewayPlugin$Outbound,
+  McpGatewayPlugin$outboundSchema,
+} from "./mcpgatewayplugin.js";
 import {
   McpGatewayServerLink,
   McpGatewayServerLink$Outbound,
@@ -46,6 +51,10 @@ export type CreateMcpGatewayRequest = {
    * Which projects in the workspace may use this gateway. Defaults to every project.
    */
   sharing?: Sharing | undefined;
+  /**
+   * Plugins run on every tool call this gateway serves.
+   */
+  plugins?: Array<McpGatewayPlugin> | undefined;
 };
 
 /** @internal */
@@ -57,6 +66,7 @@ export type CreateMcpGatewayRequest$Outbound = {
   tool_naming?: string | undefined;
   mode?: string | undefined;
   sharing?: Sharing$Outbound | undefined;
+  plugins?: Array<McpGatewayPlugin$Outbound> | undefined;
 };
 
 /** @internal */
@@ -72,6 +82,7 @@ export const CreateMcpGatewayRequest$outboundSchema: z.ZodType<
   toolNaming: McpToolNaming$outboundSchema.optional(),
   mode: McpGatewayMode$outboundSchema.optional(),
   sharing: Sharing$outboundSchema.optional(),
+  plugins: z.array(McpGatewayPlugin$outboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     displayName: "display_name",

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