@orq-ai/node 4.5.0-rc.8 → 4.5.2

package/packages/orq-rc/src/models/operations/parse.ts

@@ -0,0 +1,777 @@
+/*
+ * 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";
+
+/**
+ * Return format: chunks (with metadata) or texts (plain strings)
+ */
+export const ParseChunkingRequestChunkingRequestRequestBodyReturnType = {
+  Chunks: "chunks",
+  Texts: "texts",
+} as const;
+/**
+ * Return format: chunks (with metadata) or texts (plain strings)
+ */
+export type ParseChunkingRequestChunkingRequestRequestBodyReturnType =
+  ClosedEnum<typeof ParseChunkingRequestChunkingRequestRequestBodyReturnType>;
+
+/**
+ * High-performance SIMD-optimized byte-level chunking. Best for large files (>1MB) where speed and memory efficiency are critical. 2x faster and 3x less memory than token-based chunking.
+ */
+export type FastChunkerStrategy = {
+  /**
+   * The text content to be chunked
+   */
+  text: string;
+  /**
+   * Whether to include metadata for each chunk
+   */
+  metadata?: boolean | undefined;
+  /**
+   * Return format: chunks (with metadata) or texts (plain strings)
+   */
+  returnType?:
+    | ParseChunkingRequestChunkingRequestRequestBodyReturnType
+    | undefined;
+  strategy: "fast";
+  /**
+   * Target chunk size in bytes
+   */
+  targetSize?: number | undefined;
+  /**
+   * Single-byte delimiter characters. Each character is treated as a separate delimiter (e.g., ".?!" splits on period, question mark, or exclamation). Use escaped sequences for special chars.
+   */
+  delimiters?: string | undefined;
+  /**
+   * Multi-byte pattern for splitting (e.g., "▁" for SentencePiece tokenizers). Takes precedence over delimiters if set.
+   */
+  pattern?: string | undefined;
+  /**
+   * Attach delimiter to start of next chunk instead of end of current chunk
+   */
+  prefix?: boolean | undefined;
+  /**
+   * When true, splits at the START of consecutive delimiter runs, keeping the run with the following chunk (e.g., splits before "\n\n\n" not in the middle)
+   */
+  consecutive?: boolean | undefined;
+  /**
+   * Search forward if no delimiter found in backward search window
+   */
+  forwardFallback?: boolean | undefined;
+};
+
+/**
+ * Return format: chunks (with metadata) or texts (plain strings)
+ */
+export const ParseChunkingRequestChunkingRequestReturnType = {
+  Chunks: "chunks",
+  Texts: "texts",
+} as const;
+/**
+ * Return format: chunks (with metadata) or texts (plain strings)
+ */
+export type ParseChunkingRequestChunkingRequestReturnType = ClosedEnum<
+  typeof ParseChunkingRequestChunkingRequestReturnType
+>;
+
+/**
+ * Agentic LLM-powered chunker that uses AI to determine optimal split points. Best for complex documents requiring intelligent segmentation.
+ */
+export type AgenticChunkerStrategy = {
+  /**
+   * The text content to be chunked
+   */
+  text: string;
+  /**
+   * Whether to include metadata for each chunk
+   */
+  metadata?: boolean | undefined;
+  /**
+   * Return format: chunks (with metadata) or texts (plain strings)
+   */
+  returnType?: ParseChunkingRequestChunkingRequestReturnType | undefined;
+  strategy: "agentic";
+  /**
+   * Model to use for chunking. (Available models)[https://docs.orq.ai/docs/proxy/supported-models#chat-models]
+   */
+  model: string;
+  /**
+   * Maximum tokens per chunk
+   */
+  chunkSize?: number | undefined;
+  /**
+   * Size of candidate splits for LLM evaluation
+   */
+  candidateSize?: number | undefined;
+  /**
+   * Minimum characters allowed per chunk
+   */
+  minCharactersPerChunk?: number | undefined;
+};
+
+/**
+ * Return format: chunks (with metadata) or texts (plain strings)
+ */
+export const ParseChunkingRequestChunkingReturnType = {
+  Chunks: "chunks",
+  Texts: "texts",
+} as const;
+/**
+ * Return format: chunks (with metadata) or texts (plain strings)
+ */
+export type ParseChunkingRequestChunkingReturnType = ClosedEnum<
+  typeof ParseChunkingRequestChunkingReturnType
+>;
+
+export const Threshold2 = {
+  Auto: "auto",
+} as const;
+export type Threshold2 = ClosedEnum<typeof Threshold2>;
+
+/**
+ * Similarity threshold for grouping (0-1) or "auto" for automatic detection
+ */
+export type Threshold = number | Threshold2;
+
+/**
+ * Chunking mode: window-based or sentence-based similarity
+ */
+export const Mode = {
+  Window: "window",
+  Sentence: "sentence",
+} as const;
+/**
+ * Chunking mode: window-based or sentence-based similarity
+ */
+export type Mode = ClosedEnum<typeof Mode>;
+
+/**
+ * Groups semantically similar sentences using embeddings. Excellent for maintaining topic coherence and context within chunks.
+ */
+export type SemanticChunkerStrategy = {
+  /**
+   * The text content to be chunked
+   */
+  text: string;
+  /**
+   * Whether to include metadata for each chunk
+   */
+  metadata?: boolean | undefined;
+  /**
+   * Return format: chunks (with metadata) or texts (plain strings)
+   */
+  returnType?: ParseChunkingRequestChunkingReturnType | undefined;
+  strategy: "semantic";
+  /**
+   * Maximum tokens per chunk
+   */
+  chunkSize?: number | undefined;
+  /**
+   * Similarity threshold for grouping (0-1) or "auto" for automatic detection
+   */
+  threshold?: number | Threshold2 | undefined;
+  /**
+   * Embedding model to use for semantic similarity. (Available embedding models)[https://docs.orq.ai/docs/proxy/supported-models#embedding-models]
+   */
+  embeddingModel: string;
+  /**
+   * Number of dimensions for the embedding output. Required for text-embedding-3 models. Supported range: 256-3072 for text-embedding-3-large, 256-1536 for text-embedding-3-small.
+   */
+  dimensions?: number | undefined;
+  /**
+   * Maximum number of tokens per embedding request. Default is 8191 for text-embedding-3 models.
+   */
+  maxTokens?: number | undefined;
+  /**
+   * Chunking mode: window-based or sentence-based similarity
+   */
+  mode?: Mode | undefined;
+  /**
+   * Window size for similarity comparison
+   */
+  similarityWindow?: number | undefined;
+};
+
+/**
+ * Return format: chunks (with metadata) or texts (plain strings)
+ */
+export const ParseChunkingRequestReturnType = {
+  Chunks: "chunks",
+  Texts: "texts",
+} as const;
+/**
+ * Return format: chunks (with metadata) or texts (plain strings)
+ */
+export type ParseChunkingRequestReturnType = ClosedEnum<
+  typeof ParseChunkingRequestReturnType
+>;
+
+/**
+ * Recursively splits text using a hierarchy of separators (paragraphs, sentences, words). Versatile general-purpose chunker that preserves document structure.
+ */
+export type RecursiveChunkerStrategy = {
+  /**
+   * The text content to be chunked
+   */
+  text: string;
+  /**
+   * Whether to include metadata for each chunk
+   */
+  metadata?: boolean | undefined;
+  /**
+   * Return format: chunks (with metadata) or texts (plain strings)
+   */
+  returnType?: ParseChunkingRequestReturnType | undefined;
+  strategy: "recursive";
+  /**
+   * Maximum tokens per chunk
+   */
+  chunkSize?: number | undefined;
+  /**
+   * Hierarchy of separators to use for splitting
+   */
+  separators?: Array<string> | undefined;
+  /**
+   * Minimum characters allowed per chunk
+   */
+  minCharactersPerChunk?: number | undefined;
+};
+
+/**
+ * Return format: chunks (with metadata) or texts (plain strings)
+ */
+export const ChunkingRequestReturnType = {
+  Chunks: "chunks",
+  Texts: "texts",
+} as const;
+/**
+ * Return format: chunks (with metadata) or texts (plain strings)
+ */
+export type ChunkingRequestReturnType = ClosedEnum<
+  typeof ChunkingRequestReturnType
+>;
+
+/**
+ * Splits text at sentence boundaries while respecting token limits. Ideal for maintaining semantic coherence and readability.
+ */
+export type SentenceChunkerStrategy = {
+  /**
+   * The text content to be chunked
+   */
+  text: string;
+  /**
+   * Whether to include metadata for each chunk
+   */
+  metadata?: boolean | undefined;
+  /**
+   * Return format: chunks (with metadata) or texts (plain strings)
+   */
+  returnType?: ChunkingRequestReturnType | undefined;
+  strategy: "sentence";
+  /**
+   * Maximum tokens per chunk
+   */
+  chunkSize?: number | undefined;
+  /**
+   * Number of overlapping tokens between chunks
+   */
+  chunkOverlap?: number | undefined;
+  /**
+   * Minimum number of sentences per chunk
+   */
+  minSentencesPerChunk?: number | undefined;
+};
+
+/**
+ * Return format: chunks (with metadata) or texts (plain strings)
+ */
+export const ReturnTypeT = {
+  Chunks: "chunks",
+  Texts: "texts",
+} as const;
+/**
+ * Return format: chunks (with metadata) or texts (plain strings)
+ */
+export type ReturnTypeT = ClosedEnum<typeof ReturnTypeT>;
+
+/**
+ * Splits text based on token count. Best for ensuring chunks fit within LLM context windows and maintaining consistent chunk sizes for embedding models.
+ */
+export type TokenChunkerStrategy = {
+  /**
+   * The text content to be chunked
+   */
+  text: string;
+  /**
+   * Whether to include metadata for each chunk
+   */
+  metadata?: boolean | undefined;
+  /**
+   * Return format: chunks (with metadata) or texts (plain strings)
+   */
+  returnType?: ReturnTypeT | undefined;
+  strategy: "token";
+  /**
+   * Maximum tokens per chunk
+   */
+  chunkSize?: number | undefined;
+  /**
+   * Number of tokens to overlap between chunks
+   */
+  chunkOverlap?: number | undefined;
+};
+
+/**
+ * Request payload for text chunking with strategy-specific configuration
+ */
+export type ParseChunkingRequest =
+  | TokenChunkerStrategy
+  | SentenceChunkerStrategy
+  | RecursiveChunkerStrategy
+  | SemanticChunkerStrategy
+  | AgenticChunkerStrategy
+  | FastChunkerStrategy;
+
+export type ParseMetadata = {
+  startIndex: number | null;
+  endIndex: number | null;
+  tokenCount: number | null;
+};
+
+export type Chunks = {
+  /**
+   * The text content of the chunk
+   */
+  text: string;
+  /**
+   * The position index of this chunk in the sequence
+   */
+  index: number;
+  metadata?: ParseMetadata | undefined;
+};
+
+/**
+ * Text successfully chunked
+ */
+export type ParseResponseBody = {
+  chunks: Array<Chunks>;
+};
+
+/** @internal */
+export const ParseChunkingRequestChunkingRequestRequestBodyReturnType$outboundSchema:
+  z.ZodNativeEnum<
+    typeof ParseChunkingRequestChunkingRequestRequestBodyReturnType
+  > = z.nativeEnum(ParseChunkingRequestChunkingRequestRequestBodyReturnType);
+
+/** @internal */
+export type FastChunkerStrategy$Outbound = {
+  text: string;
+  metadata: boolean;
+  return_type: string;
+  strategy: "fast";
+  target_size: number;
+  delimiters: string;
+  pattern?: string | undefined;
+  prefix: boolean;
+  consecutive: boolean;
+  forward_fallback: boolean;
+};
+
+/** @internal */
+export const FastChunkerStrategy$outboundSchema: z.ZodType<
+  FastChunkerStrategy$Outbound,
+  z.ZodTypeDef,
+  FastChunkerStrategy
+> = z.object({
+  text: z.string(),
+  metadata: z.boolean().default(true),
+  returnType:
+    ParseChunkingRequestChunkingRequestRequestBodyReturnType$outboundSchema
+      .default("chunks"),
+  strategy: 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, {
+    returnType: "return_type",
+    targetSize: "target_size",
+    forwardFallback: "forward_fallback",
+  });
+});
+
+export function fastChunkerStrategyToJSON(
+  fastChunkerStrategy: FastChunkerStrategy,
+): string {
+  return JSON.stringify(
+    FastChunkerStrategy$outboundSchema.parse(fastChunkerStrategy),
+  );
+}
+
+/** @internal */
+export const ParseChunkingRequestChunkingRequestReturnType$outboundSchema:
+  z.ZodNativeEnum<typeof ParseChunkingRequestChunkingRequestReturnType> = z
+    .nativeEnum(ParseChunkingRequestChunkingRequestReturnType);
+
+/** @internal */
+export type AgenticChunkerStrategy$Outbound = {
+  text: string;
+  metadata: boolean;
+  return_type: string;
+  strategy: "agentic";
+  model: string;
+  chunk_size: number;
+  candidate_size: number;
+  min_characters_per_chunk: number;
+};
+
+/** @internal */
+export const AgenticChunkerStrategy$outboundSchema: z.ZodType<
+  AgenticChunkerStrategy$Outbound,
+  z.ZodTypeDef,
+  AgenticChunkerStrategy
+> = z.object({
+  text: z.string(),
+  metadata: z.boolean().default(true),
+  returnType: ParseChunkingRequestChunkingRequestReturnType$outboundSchema
+    .default("chunks"),
+  strategy: z.literal("agentic"),
+  model: z.string(),
+  chunkSize: z.number().int().default(1024),
+  candidateSize: z.number().int().default(128),
+  minCharactersPerChunk: z.number().int().default(24),
+}).transform((v) => {
+  return remap$(v, {
+    returnType: "return_type",
+    chunkSize: "chunk_size",
+    candidateSize: "candidate_size",
+    minCharactersPerChunk: "min_characters_per_chunk",
+  });
+});
+
+export function agenticChunkerStrategyToJSON(
+  agenticChunkerStrategy: AgenticChunkerStrategy,
+): string {
+  return JSON.stringify(
+    AgenticChunkerStrategy$outboundSchema.parse(agenticChunkerStrategy),
+  );
+}
+
+/** @internal */
+export const ParseChunkingRequestChunkingReturnType$outboundSchema:
+  z.ZodNativeEnum<typeof ParseChunkingRequestChunkingReturnType> = z.nativeEnum(
+    ParseChunkingRequestChunkingReturnType,
+  );
+
+/** @internal */
+export const Threshold2$outboundSchema: z.ZodNativeEnum<typeof Threshold2> = z
+  .nativeEnum(Threshold2);
+
+/** @internal */
+export type Threshold$Outbound = number | string;
+
+/** @internal */
+export const Threshold$outboundSchema: z.ZodType<
+  Threshold$Outbound,
+  z.ZodTypeDef,
+  Threshold
+> = z.union([z.number(), Threshold2$outboundSchema]);
+
+export function thresholdToJSON(threshold: Threshold): string {
+  return JSON.stringify(Threshold$outboundSchema.parse(threshold));
+}
+
+/** @internal */
+export const Mode$outboundSchema: z.ZodNativeEnum<typeof Mode> = z.nativeEnum(
+  Mode,
+);
+
+/** @internal */
+export type SemanticChunkerStrategy$Outbound = {
+  text: string;
+  metadata: boolean;
+  return_type: string;
+  strategy: "semantic";
+  chunk_size: number;
+  threshold?: number | string | undefined;
+  embedding_model: string;
+  dimensions?: number | undefined;
+  max_tokens?: number | undefined;
+  mode: string;
+  similarity_window: number;
+};
+
+/** @internal */
+export const SemanticChunkerStrategy$outboundSchema: z.ZodType<
+  SemanticChunkerStrategy$Outbound,
+  z.ZodTypeDef,
+  SemanticChunkerStrategy
+> = z.object({
+  text: z.string(),
+  metadata: z.boolean().default(true),
+  returnType: ParseChunkingRequestChunkingReturnType$outboundSchema.default(
+    "chunks",
+  ),
+  strategy: z.literal("semantic"),
+  chunkSize: z.number().int().default(512),
+  threshold: z.union([z.number(), Threshold2$outboundSchema]).optional(),
+  embeddingModel: z.string(),
+  dimensions: z.number().int().optional(),
+  maxTokens: z.number().int().optional(),
+  mode: Mode$outboundSchema.default("window"),
+  similarityWindow: z.number().int().default(1),
+}).transform((v) => {
+  return remap$(v, {
+    returnType: "return_type",
+    chunkSize: "chunk_size",
+    embeddingModel: "embedding_model",
+    maxTokens: "max_tokens",
+    similarityWindow: "similarity_window",
+  });
+});
+
+export function semanticChunkerStrategyToJSON(
+  semanticChunkerStrategy: SemanticChunkerStrategy,
+): string {
+  return JSON.stringify(
+    SemanticChunkerStrategy$outboundSchema.parse(semanticChunkerStrategy),
+  );
+}
+
+/** @internal */
+export const ParseChunkingRequestReturnType$outboundSchema: z.ZodNativeEnum<
+  typeof ParseChunkingRequestReturnType
+> = z.nativeEnum(ParseChunkingRequestReturnType);
+
+/** @internal */
+export type RecursiveChunkerStrategy$Outbound = {
+  text: string;
+  metadata: boolean;
+  return_type: string;
+  strategy: "recursive";
+  chunk_size: number;
+  separators?: Array<string> | undefined;
+  min_characters_per_chunk: number;
+};
+
+/** @internal */
+export const RecursiveChunkerStrategy$outboundSchema: z.ZodType<
+  RecursiveChunkerStrategy$Outbound,
+  z.ZodTypeDef,
+  RecursiveChunkerStrategy
+> = z.object({
+  text: z.string(),
+  metadata: z.boolean().default(true),
+  returnType: ParseChunkingRequestReturnType$outboundSchema.default("chunks"),
+  strategy: 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, {
+    returnType: "return_type",
+    chunkSize: "chunk_size",
+    minCharactersPerChunk: "min_characters_per_chunk",
+  });
+});
+
+export function recursiveChunkerStrategyToJSON(
+  recursiveChunkerStrategy: RecursiveChunkerStrategy,
+): string {
+  return JSON.stringify(
+    RecursiveChunkerStrategy$outboundSchema.parse(recursiveChunkerStrategy),
+  );
+}
+
+/** @internal */
+export const ChunkingRequestReturnType$outboundSchema: z.ZodNativeEnum<
+  typeof ChunkingRequestReturnType
+> = z.nativeEnum(ChunkingRequestReturnType);
+
+/** @internal */
+export type SentenceChunkerStrategy$Outbound = {
+  text: string;
+  metadata: boolean;
+  return_type: string;
+  strategy: "sentence";
+  chunk_size: number;
+  chunk_overlap: number;
+  min_sentences_per_chunk: number;
+};
+
+/** @internal */
+export const SentenceChunkerStrategy$outboundSchema: z.ZodType<
+  SentenceChunkerStrategy$Outbound,
+  z.ZodTypeDef,
+  SentenceChunkerStrategy
+> = z.object({
+  text: z.string(),
+  metadata: z.boolean().default(true),
+  returnType: ChunkingRequestReturnType$outboundSchema.default("chunks"),
+  strategy: 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, {
+    returnType: "return_type",
+    chunkSize: "chunk_size",
+    chunkOverlap: "chunk_overlap",
+    minSentencesPerChunk: "min_sentences_per_chunk",
+  });
+});
+
+export function sentenceChunkerStrategyToJSON(
+  sentenceChunkerStrategy: SentenceChunkerStrategy,
+): string {
+  return JSON.stringify(
+    SentenceChunkerStrategy$outboundSchema.parse(sentenceChunkerStrategy),
+  );
+}
+
+/** @internal */
+export const ReturnTypeT$outboundSchema: z.ZodNativeEnum<typeof ReturnTypeT> = z
+  .nativeEnum(ReturnTypeT);
+
+/** @internal */
+export type TokenChunkerStrategy$Outbound = {
+  text: string;
+  metadata: boolean;
+  return_type: string;
+  strategy: "token";
+  chunk_size: number;
+  chunk_overlap: number;
+};
+
+/** @internal */
+export const TokenChunkerStrategy$outboundSchema: z.ZodType<
+  TokenChunkerStrategy$Outbound,
+  z.ZodTypeDef,
+  TokenChunkerStrategy
+> = z.object({
+  text: z.string(),
+  metadata: z.boolean().default(true),
+  returnType: ReturnTypeT$outboundSchema.default("chunks"),
+  strategy: z.literal("token"),
+  chunkSize: z.number().int().default(512),
+  chunkOverlap: z.number().int().default(0),
+}).transform((v) => {
+  return remap$(v, {
+    returnType: "return_type",
+    chunkSize: "chunk_size",
+    chunkOverlap: "chunk_overlap",
+  });
+});
+
+export function tokenChunkerStrategyToJSON(
+  tokenChunkerStrategy: TokenChunkerStrategy,
+): string {
+  return JSON.stringify(
+    TokenChunkerStrategy$outboundSchema.parse(tokenChunkerStrategy),
+  );
+}
+
+/** @internal */
+export type ParseChunkingRequest$Outbound =
+  | TokenChunkerStrategy$Outbound
+  | SentenceChunkerStrategy$Outbound
+  | RecursiveChunkerStrategy$Outbound
+  | SemanticChunkerStrategy$Outbound
+  | AgenticChunkerStrategy$Outbound
+  | FastChunkerStrategy$Outbound;
+
+/** @internal */
+export const ParseChunkingRequest$outboundSchema: z.ZodType<
+  ParseChunkingRequest$Outbound,
+  z.ZodTypeDef,
+  ParseChunkingRequest
+> = z.union([
+  z.lazy(() => TokenChunkerStrategy$outboundSchema),
+  z.lazy(() => SentenceChunkerStrategy$outboundSchema),
+  z.lazy(() => RecursiveChunkerStrategy$outboundSchema),
+  z.lazy(() => SemanticChunkerStrategy$outboundSchema),
+  z.lazy(() => AgenticChunkerStrategy$outboundSchema),
+  z.lazy(() => FastChunkerStrategy$outboundSchema),
+]);
+
+export function parseChunkingRequestToJSON(
+  parseChunkingRequest: ParseChunkingRequest,
+): string {
+  return JSON.stringify(
+    ParseChunkingRequest$outboundSchema.parse(parseChunkingRequest),
+  );
+}
+
+/** @internal */
+export const ParseMetadata$inboundSchema: z.ZodType<
+  ParseMetadata,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  start_index: z.nullable(z.number()),
+  end_index: z.nullable(z.number()),
+  token_count: z.nullable(z.number()),
+}).transform((v) => {
+  return remap$(v, {
+    "start_index": "startIndex",
+    "end_index": "endIndex",
+    "token_count": "tokenCount",
+  });
+});
+
+export function parseMetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<ParseMetadata, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ParseMetadata$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ParseMetadata' from JSON`,
+  );
+}
+
+/** @internal */
+export const Chunks$inboundSchema: z.ZodType<Chunks, z.ZodTypeDef, unknown> = z
+  .object({
+    text: z.string(),
+    index: z.number(),
+    metadata: z.lazy(() => ParseMetadata$inboundSchema).optional(),
+  });
+
+export function chunksFromJSON(
+  jsonString: string,
+): SafeParseResult<Chunks, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Chunks$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Chunks' from JSON`,
+  );
+}
+
+/** @internal */
+export const ParseResponseBody$inboundSchema: z.ZodType<
+  ParseResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  chunks: z.array(z.lazy(() => Chunks$inboundSchema)),
+});
+
+export function parseResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<ParseResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ParseResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ParseResponseBody' from JSON`,
+  );
+}