@orq-ai/node 4.14.4 → 4.14.7

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

@@ -13,12 +13,6 @@ import {
   ApiKeyBudgetScope$Outbound,
   ApiKeyBudgetScope$outboundSchema,
 } from "./apikeybudgetscope.js";
-import {
-  FactoryBudgetScope,
-  FactoryBudgetScope$inboundSchema,
-  FactoryBudgetScope$Outbound,
-  FactoryBudgetScope$outboundSchema,
-} from "./factorybudgetscope.js";
 import {
   IdentityBudgetScope,
   IdentityBudgetScope$inboundSchema,
@@ -51,11 +45,7 @@ import {
 } from "./workspacebudgetscope.js";
 
 /**
- * BudgetScope is a closed oneof. Exactly one variant must be set. The
- *
- * @remarks
- *  variants are ordered by enforcement precedence (most specific to
- *  most general) and mirror the BudgetScopeKind filter enum.
+ * Closed oneof of workspace, project, identity, api_key, provider, or model. Exactly one variant must be set. Variants are ordered by enforcement precedence (most specific to most general).
  */
 export type BudgetScope = {
   /**
@@ -95,13 +85,6 @@ export type BudgetScope = {
    *  models), rather than an internal identifier.
    */
   model?: ModelBudgetScope | undefined;
-  /**
-   * Per-factory cap. Matches requests whose api key carries the label
-   *
-   * @remarks
-   *  `factory=<factory_id>` (keys minted for agent sessions of that factory).
-   */
-  factory?: FactoryBudgetScope | undefined;
 };
 
 /** @internal */
@@ -116,7 +99,6 @@ export const BudgetScope$inboundSchema: z.ZodType<
   api_key: ApiKeyBudgetScope$inboundSchema.optional(),
   provider: ProviderBudgetScope$inboundSchema.optional(),
   model: ModelBudgetScope$inboundSchema.optional(),
-  factory: FactoryBudgetScope$inboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     "api_key": "apiKey",
@@ -130,7 +112,6 @@ export type BudgetScope$Outbound = {
   api_key?: ApiKeyBudgetScope$Outbound | undefined;
   provider?: ProviderBudgetScope$Outbound | undefined;
   model?: ModelBudgetScope$Outbound | undefined;
-  factory?: FactoryBudgetScope$Outbound | undefined;
 };
 
 /** @internal */
@@ -145,7 +126,6 @@ export const BudgetScope$outboundSchema: z.ZodType<
   apiKey: ApiKeyBudgetScope$outboundSchema.optional(),
   provider: ProviderBudgetScope$outboundSchema.optional(),
   model: ModelBudgetScope$outboundSchema.optional(),
-  factory: FactoryBudgetScope$outboundSchema.optional(),
 }).transform((v) => {
   return remap$(v, {
     apiKey: "api_key",

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

@@ -13,7 +13,6 @@ export const BudgetScopeKind = {
   BudgetScopeKindApiKey: "BUDGET_SCOPE_KIND_API_KEY",
   BudgetScopeKindProvider: "BUDGET_SCOPE_KIND_PROVIDER",
   BudgetScopeKindModel: "BUDGET_SCOPE_KIND_MODEL",
-  BudgetScopeKindFactory: "BUDGET_SCOPE_KIND_FACTORY",
 } as const;
 export type BudgetScopeKind = ClosedEnum<typeof BudgetScopeKind>;
 

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

@@ -10,10 +10,6 @@ import {
   ApiKeyBudgetScopeRestResponse,
   ApiKeyBudgetScopeRestResponse$inboundSchema,
 } from "./apikeybudgetscoperestresponse.js";
-import {
-  FactoryBudgetScopeRestResponse,
-  FactoryBudgetScopeRestResponse$inboundSchema,
-} from "./factorybudgetscoperestresponse.js";
 import {
   IdentityBudgetScopeRestResponse,
   IdentityBudgetScopeRestResponse$inboundSchema,
@@ -36,11 +32,7 @@ import {
 } from "./workspacebudgetscope.js";
 
 /**
- * BudgetScope is a closed oneof. Exactly one variant must be set. The
- *
- * @remarks
- *  variants are ordered by enforcement precedence (most specific to
- *  most general) and mirror the BudgetScopeKind filter enum.
+ * Closed oneof of workspace, project, identity, api_key, provider, or model. Exactly one variant must be set. Variants are ordered by enforcement precedence (most specific to most general).
  */
 export type BudgetScopeRestResponse = {
   /**
@@ -80,13 +72,6 @@ export type BudgetScopeRestResponse = {
    *  models), rather than an internal identifier.
    */
   model?: ModelBudgetScopeRestResponse | undefined;
-  /**
-   * Per-factory cap. Matches requests whose api key carries the label
-   *
-   * @remarks
-   *  `factory=<factory_id>` (keys minted for agent sessions of that factory).
-   */
-  factory?: FactoryBudgetScopeRestResponse | undefined;
 };
 
 /** @internal */
@@ -101,7 +86,6 @@ export const BudgetScopeRestResponse$inboundSchema: z.ZodType<
   apiKey: ApiKeyBudgetScopeRestResponse$inboundSchema.optional(),
   provider: ProviderBudgetScope$inboundSchema.optional(),
   model: ModelBudgetScopeRestResponse$inboundSchema.optional(),
-  factory: FactoryBudgetScopeRestResponse$inboundSchema.optional(),
 });
 
 export function budgetScopeRestResponseFromJSON(

package/packages/orq-rc/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/packages/orq-rc/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/packages/orq-rc/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/packages/orq-rc/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(