@anvia/core 1.0.0-rc.2 → 1.0.0-rc.4

package/dist/documents/index.js

@@ -0,0 +1,315 @@
+// src/documents/chunk-text.ts
+function chunkText(options) {
+  const validated = validateOptions(options);
+  if (validated.text.length === 0) {
+    return [];
+  }
+  if (validated.strategy === "fixed") {
+    return chunkFixed(validated.text, validated.maxSize, validated.overlap);
+  }
+  const ranges = resolveRecursiveRanges(
+    validated.text,
+    { start: 0, end: validated.text.length },
+    validated.maxSize,
+    validated.separators
+  );
+  return applyRecursiveOverlap(validated.text, ranges, validated.maxSize, validated.overlap);
+}
+function validateOptions(options) {
+  if (typeof options !== "object" || options === null) {
+    throw new TypeError("chunkText options must be an object");
+  }
+  const value = options;
+  if (typeof value.text !== "string") {
+    throw new TypeError("chunkText text must be a string");
+  }
+  if (!Number.isSafeInteger(value.maxSize) || value.maxSize <= 0) {
+    throw new RangeError("chunkText maxSize must be a positive safe integer");
+  }
+  const maxSize = value.maxSize;
+  const overlap = value.overlap === void 0 ? 0 : value.overlap;
+  if (!Number.isSafeInteger(overlap) || overlap < 0 || overlap >= maxSize) {
+    throw new RangeError(
+      "chunkText overlap must be a non-negative safe integer smaller than maxSize"
+    );
+  }
+  if (value.strategy === "fixed") {
+    if ("separators" in value) {
+      throw new TypeError("chunkText fixed strategy does not accept separators");
+    }
+    return {
+      text: value.text,
+      strategy: "fixed",
+      maxSize,
+      overlap
+    };
+  }
+  if (value.strategy !== "recursive") {
+    throw new TypeError('chunkText strategy must be either "fixed" or "recursive"');
+  }
+  if (!Array.isArray(value.separators) || value.separators.length === 0) {
+    throw new TypeError("chunkText recursive separators must be a non-empty array");
+  }
+  const separators = value.separators;
+  const seen = /* @__PURE__ */ new Set();
+  for (const separator of separators) {
+    if (typeof separator !== "string" || separator.length === 0) {
+      throw new TypeError("chunkText recursive separators must contain non-empty strings");
+    }
+    if (seen.has(separator)) {
+      throw new TypeError("chunkText recursive separators must not contain duplicates");
+    }
+    seen.add(separator);
+  }
+  return {
+    text: value.text,
+    strategy: "recursive",
+    maxSize,
+    overlap,
+    separators
+  };
+}
+function chunkFixed(text, maxSize, overlap) {
+  const chunks = [];
+  let start = 0;
+  while (start < text.length) {
+    const end = Math.min(start + maxSize, text.length);
+    chunks.push(createChunk(text, chunks.length, start, end));
+    if (end === text.length) {
+      break;
+    }
+    start = end - overlap;
+  }
+  return chunks;
+}
+function resolveRecursiveRanges(text, initialRange, maxSize, separators) {
+  const resolved = [];
+  const pending = [
+    { range: initialRange, separatorIndex: 0 }
+  ];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (current === void 0) {
+      break;
+    }
+    if (current.range.end - current.range.start <= maxSize) {
+      resolved.push(current.range);
+      continue;
+    }
+    let pieces;
+    let nextSeparatorIndex = separators.length;
+    for (let index = current.separatorIndex; index < separators.length; index += 1) {
+      const candidate = splitAfterSeparator(text, current.range, separators[index]);
+      if (candidate.length > 1) {
+        pieces = candidate;
+        nextSeparatorIndex = index + 1;
+        break;
+      }
+    }
+    if (pieces === void 0) {
+      resolved.push(...hardSplit(current.range, maxSize));
+      continue;
+    }
+    for (let index = pieces.length - 1; index >= 0; index -= 1) {
+      pending.push({ range: pieces[index], separatorIndex: nextSeparatorIndex });
+    }
+  }
+  return resolved;
+}
+function splitAfterSeparator(text, range, separator) {
+  const ranges = [];
+  let start = range.start;
+  let searchFrom = range.start;
+  while (searchFrom < range.end) {
+    const separatorStart = text.indexOf(separator, searchFrom);
+    if (separatorStart < 0 || separatorStart + separator.length > range.end) {
+      break;
+    }
+    const end = separatorStart + separator.length;
+    if (end > start) {
+      ranges.push({ start, end });
+    }
+    start = end;
+    searchFrom = end;
+  }
+  if (start < range.end) {
+    ranges.push({ start, end: range.end });
+  }
+  return ranges;
+}
+function hardSplit(range, maxSize) {
+  const ranges = [];
+  for (let start = range.start; start < range.end; start += maxSize) {
+    ranges.push({ start, end: Math.min(start + maxSize, range.end) });
+  }
+  return ranges;
+}
+function applyRecursiveOverlap(text, ranges, maxSize, overlap) {
+  const boundaries = ranges.map((range) => range.end);
+  const chunks = [];
+  let start = 0;
+  let previousEnd = 0;
+  while (start < text.length) {
+    const limit = Math.min(start + maxSize, text.length);
+    const boundary = findLastBoundaryAtMost(boundaries, limit);
+    const end = boundary !== void 0 && boundary > previousEnd ? boundary : limit;
+    chunks.push(createChunk(text, chunks.length, start, end));
+    if (end === text.length) {
+      break;
+    }
+    previousEnd = end;
+    start = Math.max(0, end - overlap);
+  }
+  return chunks;
+}
+function findLastBoundaryAtMost(boundaries, limit) {
+  let low = 0;
+  let high = boundaries.length;
+  while (low < high) {
+    const middle = low + Math.floor((high - low) / 2);
+    if (boundaries[middle] <= limit) {
+      low = middle + 1;
+    } else {
+      high = middle;
+    }
+  }
+  return boundaries[low - 1];
+}
+function createChunk(text, index, start, end) {
+  return { index, text: text.slice(start, end), start, end };
+}
+
+// src/documents/pdf.ts
+async function extractPdfText(options) {
+  if (typeof options !== "object" || options === null) {
+    throw new TypeError("extractPdfText options must be an object");
+  }
+  if (!(options.data instanceof Uint8Array)) {
+    throw new TypeError("extractPdfText data must be a Uint8Array");
+  }
+  if (options.abortSignal !== void 0 && !isAbortSignal(options.abortSignal)) {
+    throw new TypeError("extractPdfText abortSignal must be an AbortSignal");
+  }
+  const { abortSignal } = options;
+  abortSignal?.throwIfAborted();
+  const data = new Uint8Array(options.data);
+  const pdfjs = await import("pdfjs-dist/legacy/build/pdf.mjs");
+  abortSignal?.throwIfAborted();
+  const loadingTask = pdfjs.getDocument({ data });
+  let destroyPromise;
+  const destroy = () => {
+    destroyPromise ??= loadingTask.destroy();
+    return destroyPromise;
+  };
+  const abort = createAbortPromise(abortSignal, destroy);
+  return runWithCleanup(
+    async () => {
+      const document = await abort.wait(loadingTask.promise);
+      const pages = [];
+      for (let pageNumber = 1; pageNumber <= document.numPages; pageNumber += 1) {
+        abortSignal?.throwIfAborted();
+        const page = await abort.wait(document.getPage(pageNumber));
+        const content = await abort.wait(page.getTextContent());
+        pages.push({ pageNumber, text: extractPageText(content.items) });
+      }
+      return { pages };
+    },
+    async () => {
+      abort.dispose();
+      await destroy();
+    }
+  );
+}
+async function runWithCleanup(operation, cleanup) {
+  let outcome;
+  try {
+    outcome = { ok: true, value: await operation() };
+  } catch (error) {
+    outcome = { ok: false, error };
+  }
+  let cleanupError;
+  let cleanupFailed = false;
+  try {
+    await cleanup();
+  } catch (error) {
+    cleanupFailed = true;
+    cleanupError = error;
+  }
+  if (!outcome.ok) {
+    if (cleanupFailed) {
+      throw new AggregateError(
+        [outcome.error, cleanupError],
+        "PDF extraction and cleanup both failed",
+        { cause: outcome.error }
+      );
+    }
+    throw outcome.error;
+  }
+  if (cleanupFailed) {
+    throw cleanupError;
+  }
+  return outcome.value;
+}
+function isAbortSignal(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.aborted === "boolean" && typeof candidate.addEventListener === "function" && typeof candidate.removeEventListener === "function" && typeof candidate.throwIfAborted === "function";
+}
+function extractPageText(items) {
+  let text = "";
+  for (const item of items) {
+    if (typeof item !== "object" || item === null) {
+      throw new TypeError("PDF text content contains a malformed item");
+    }
+    if (!("str" in item)) {
+      if ("type" in item && (item.type === "beginMarkedContent" || item.type === "beginMarkedContentProps" || item.type === "endMarkedContent")) {
+        continue;
+      }
+      throw new TypeError("PDF text content contains an unknown non-text item");
+    }
+    if (typeof item.str !== "string") {
+      throw new TypeError("PDF text content item str must be a string");
+    }
+    if (!("hasEOL" in item) || typeof item.hasEOL !== "boolean") {
+      throw new TypeError("PDF text content item hasEOL must be a boolean");
+    }
+    text += item.str;
+    if (item.hasEOL) {
+      text += "\n";
+    }
+  }
+  return text;
+}
+function createAbortPromise(abortSignal, destroy) {
+  if (abortSignal === void 0) {
+    return {
+      wait: (promise) => promise,
+      dispose: () => void 0
+    };
+  }
+  let rejectAbort;
+  const aborted = new Promise((_resolve, reject) => {
+    rejectAbort = reject;
+  });
+  const onAbort = () => {
+    void destroy();
+    rejectAbort?.(
+      abortSignal.reason ?? new DOMException("The operation was aborted", "AbortError")
+    );
+  };
+  abortSignal.addEventListener("abort", onAbort, { once: true });
+  if (abortSignal.aborted) {
+    onAbort();
+  }
+  return {
+    wait: (promise) => Promise.race([promise, aborted]),
+    dispose: () => abortSignal.removeEventListener("abort", onAbort)
+  };
+}
+export {
+  chunkText,
+  extractPdfText
+};
+//# sourceMappingURL=index.js.map

package/dist/documents/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/documents/chunk-text.ts","../../src/documents/pdf.ts"],"sourcesContent":["export type TextChunk = Readonly<{\n  index: number;\n  text: string;\n  start: number;\n  end: number;\n}>;\n\nexport type ChunkTextOptions =\n  | Readonly<{\n      text: string;\n      strategy: \"fixed\";\n      maxSize: number;\n      overlap?: number;\n    }>\n  | Readonly<{\n      text: string;\n      strategy: \"recursive\";\n      maxSize: number;\n      overlap?: number;\n      separators: readonly string[];\n    }>;\n\ntype TextRange = Readonly<{\n  start: number;\n  end: number;\n}>;\n\nexport function chunkText(options: ChunkTextOptions): readonly TextChunk[] {\n  const validated = validateOptions(options);\n  if (validated.text.length === 0) {\n    return [];\n  }\n\n  if (validated.strategy === \"fixed\") {\n    return chunkFixed(validated.text, validated.maxSize, validated.overlap);\n  }\n\n  const ranges = resolveRecursiveRanges(\n    validated.text,\n    { start: 0, end: validated.text.length },\n    validated.maxSize,\n    validated.separators,\n  );\n  return applyRecursiveOverlap(validated.text, ranges, validated.maxSize, validated.overlap);\n}\n\nfunction validateOptions(options: ChunkTextOptions):\n  | Readonly<{\n      text: string;\n      strategy: \"fixed\";\n      maxSize: number;\n      overlap: number;\n    }>\n  | Readonly<{\n      text: string;\n      strategy: \"recursive\";\n      maxSize: number;\n      overlap: number;\n      separators: readonly string[];\n    }> {\n  if (typeof options !== \"object\" || options === null) {\n    throw new TypeError(\"chunkText options must be an object\");\n  }\n\n  const value = options as unknown as Record<string, unknown>;\n  if (typeof value.text !== \"string\") {\n    throw new TypeError(\"chunkText text must be a string\");\n  }\n  if (!Number.isSafeInteger(value.maxSize) || (value.maxSize as number) <= 0) {\n    throw new RangeError(\"chunkText maxSize must be a positive safe integer\");\n  }\n\n  const maxSize = value.maxSize as number;\n  const overlap = value.overlap === undefined ? 0 : value.overlap;\n  if (!Number.isSafeInteger(overlap) || (overlap as number) < 0 || (overlap as number) >= maxSize) {\n    throw new RangeError(\n      \"chunkText overlap must be a non-negative safe integer smaller than maxSize\",\n    );\n  }\n\n  if (value.strategy === \"fixed\") {\n    if (\"separators\" in value) {\n      throw new TypeError(\"chunkText fixed strategy does not accept separators\");\n    }\n    return {\n      text: value.text,\n      strategy: \"fixed\",\n      maxSize,\n      overlap: overlap as number,\n    };\n  }\n\n  if (value.strategy !== \"recursive\") {\n    throw new TypeError('chunkText strategy must be either \"fixed\" or \"recursive\"');\n  }\n  if (!Array.isArray(value.separators) || value.separators.length === 0) {\n    throw new TypeError(\"chunkText recursive separators must be a non-empty array\");\n  }\n\n  const separators = value.separators as unknown[];\n  const seen = new Set<string>();\n  for (const separator of separators) {\n    if (typeof separator !== \"string\" || separator.length === 0) {\n      throw new TypeError(\"chunkText recursive separators must contain non-empty strings\");\n    }\n    if (seen.has(separator)) {\n      throw new TypeError(\"chunkText recursive separators must not contain duplicates\");\n    }\n    seen.add(separator);\n  }\n\n  return {\n    text: value.text,\n    strategy: \"recursive\",\n    maxSize,\n    overlap: overlap as number,\n    separators: separators as string[],\n  };\n}\n\nfunction chunkFixed(text: string, maxSize: number, overlap: number): readonly TextChunk[] {\n  const chunks: TextChunk[] = [];\n  let start = 0;\n\n  while (start < text.length) {\n    const end = Math.min(start + maxSize, text.length);\n    chunks.push(createChunk(text, chunks.length, start, end));\n    if (end === text.length) {\n      break;\n    }\n    start = end - overlap;\n  }\n\n  return chunks;\n}\n\nfunction resolveRecursiveRanges(\n  text: string,\n  initialRange: TextRange,\n  maxSize: number,\n  separators: readonly string[],\n): readonly TextRange[] {\n  const resolved: TextRange[] = [];\n  const pending: Array<Readonly<{ range: TextRange; separatorIndex: number }>> = [\n    { range: initialRange, separatorIndex: 0 },\n  ];\n\n  while (pending.length > 0) {\n    const current = pending.pop();\n    if (current === undefined) {\n      break;\n    }\n    if (current.range.end - current.range.start <= maxSize) {\n      resolved.push(current.range);\n      continue;\n    }\n\n    let pieces: readonly TextRange[] | undefined;\n    let nextSeparatorIndex = separators.length;\n    for (let index = current.separatorIndex; index < separators.length; index += 1) {\n      const candidate = splitAfterSeparator(text, current.range, separators[index] as string);\n      if (candidate.length > 1) {\n        pieces = candidate;\n        nextSeparatorIndex = index + 1;\n        break;\n      }\n    }\n\n    if (pieces === undefined) {\n      resolved.push(...hardSplit(current.range, maxSize));\n      continue;\n    }\n\n    for (let index = pieces.length - 1; index >= 0; index -= 1) {\n      pending.push({ range: pieces[index] as TextRange, separatorIndex: nextSeparatorIndex });\n    }\n  }\n\n  return resolved;\n}\n\nfunction splitAfterSeparator(text: string, range: TextRange, separator: string): TextRange[] {\n  const ranges: TextRange[] = [];\n  let start = range.start;\n  let searchFrom = range.start;\n\n  while (searchFrom < range.end) {\n    const separatorStart = text.indexOf(separator, searchFrom);\n    if (separatorStart < 0 || separatorStart + separator.length > range.end) {\n      break;\n    }\n    const end = separatorStart + separator.length;\n    if (end > start) {\n      ranges.push({ start, end });\n    }\n    start = end;\n    searchFrom = end;\n  }\n\n  if (start < range.end) {\n    ranges.push({ start, end: range.end });\n  }\n  return ranges;\n}\n\nfunction hardSplit(range: TextRange, maxSize: number): readonly TextRange[] {\n  const ranges: TextRange[] = [];\n  for (let start = range.start; start < range.end; start += maxSize) {\n    ranges.push({ start, end: Math.min(start + maxSize, range.end) });\n  }\n  return ranges;\n}\n\nfunction applyRecursiveOverlap(\n  text: string,\n  ranges: readonly TextRange[],\n  maxSize: number,\n  overlap: number,\n): readonly TextChunk[] {\n  const boundaries = ranges.map((range) => range.end);\n  const chunks: TextChunk[] = [];\n  let start = 0;\n  let previousEnd = 0;\n\n  while (start < text.length) {\n    const limit = Math.min(start + maxSize, text.length);\n    const boundary = findLastBoundaryAtMost(boundaries, limit);\n    const end = boundary !== undefined && boundary > previousEnd ? boundary : limit;\n\n    chunks.push(createChunk(text, chunks.length, start, end));\n    if (end === text.length) {\n      break;\n    }\n    previousEnd = end;\n    start = Math.max(0, end - overlap);\n  }\n\n  return chunks;\n}\n\nfunction findLastBoundaryAtMost(boundaries: readonly number[], limit: number): number | undefined {\n  let low = 0;\n  let high = boundaries.length;\n  while (low < high) {\n    const middle = low + Math.floor((high - low) / 2);\n    if ((boundaries[middle] as number) <= limit) {\n      low = middle + 1;\n    } else {\n      high = middle;\n    }\n  }\n  return boundaries[low - 1];\n}\n\nfunction createChunk(text: string, index: number, start: number, end: number): TextChunk {\n  return { index, text: text.slice(start, end), start, end };\n}\n","export type PdfTextPage = Readonly<{\n  pageNumber: number;\n  text: string;\n}>;\n\nexport type ExtractPdfTextOptions = Readonly<{\n  data: Uint8Array;\n  abortSignal?: AbortSignal;\n}>;\n\nexport type ExtractPdfTextResult = Readonly<{\n  pages: readonly PdfTextPage[];\n}>;\n\nexport async function extractPdfText(\n  options: ExtractPdfTextOptions,\n): Promise<ExtractPdfTextResult> {\n  if (typeof options !== \"object\" || options === null) {\n    throw new TypeError(\"extractPdfText options must be an object\");\n  }\n  if (!(options.data instanceof Uint8Array)) {\n    throw new TypeError(\"extractPdfText data must be a Uint8Array\");\n  }\n  if (options.abortSignal !== undefined && !isAbortSignal(options.abortSignal)) {\n    throw new TypeError(\"extractPdfText abortSignal must be an AbortSignal\");\n  }\n\n  const { abortSignal } = options;\n  abortSignal?.throwIfAborted();\n  const data = new Uint8Array(options.data);\n  const pdfjs = await import(\"pdfjs-dist/legacy/build/pdf.mjs\");\n  abortSignal?.throwIfAborted();\n\n  const loadingTask = pdfjs.getDocument({ data });\n  let destroyPromise: Promise<void> | undefined;\n  const destroy = (): Promise<void> => {\n    destroyPromise ??= loadingTask.destroy();\n    return destroyPromise;\n  };\n  const abort = createAbortPromise(abortSignal, destroy);\n\n  return runWithCleanup(\n    async () => {\n      const document = await abort.wait(loadingTask.promise);\n      const pages: PdfTextPage[] = [];\n      for (let pageNumber = 1; pageNumber <= document.numPages; pageNumber += 1) {\n        abortSignal?.throwIfAborted();\n        const page = await abort.wait(document.getPage(pageNumber));\n        const content = await abort.wait(page.getTextContent());\n        pages.push({ pageNumber, text: extractPageText(content.items) });\n      }\n      return { pages };\n    },\n    async () => {\n      abort.dispose();\n      await destroy();\n    },\n  );\n}\n\nasync function runWithCleanup<Result>(\n  operation: () => Promise<Result>,\n  cleanup: () => Promise<void>,\n): Promise<Result> {\n  let outcome: { ok: true; value: Result } | { ok: false; error: unknown };\n  try {\n    outcome = { ok: true, value: await operation() };\n  } catch (error) {\n    outcome = { ok: false, error };\n  }\n\n  let cleanupError: unknown;\n  let cleanupFailed = false;\n  try {\n    await cleanup();\n  } catch (error) {\n    cleanupFailed = true;\n    cleanupError = error;\n  }\n\n  if (!outcome.ok) {\n    if (cleanupFailed) {\n      throw new AggregateError(\n        [outcome.error, cleanupError],\n        \"PDF extraction and cleanup both failed\",\n        { cause: outcome.error },\n      );\n    }\n    throw outcome.error;\n  }\n  if (cleanupFailed) {\n    throw cleanupError;\n  }\n  return outcome.value;\n}\n\nfunction isAbortSignal(value: unknown): value is AbortSignal {\n  if (typeof value !== \"object\" || value === null) {\n    return false;\n  }\n  const candidate = value as Partial<AbortSignal>;\n  return (\n    typeof candidate.aborted === \"boolean\" &&\n    typeof candidate.addEventListener === \"function\" &&\n    typeof candidate.removeEventListener === \"function\" &&\n    typeof candidate.throwIfAborted === \"function\"\n  );\n}\n\nfunction extractPageText(items: readonly unknown[]): string {\n  let text = \"\";\n  for (const item of items) {\n    if (typeof item !== \"object\" || item === null) {\n      throw new TypeError(\"PDF text content contains a malformed item\");\n    }\n    if (!(\"str\" in item)) {\n      if (\n        \"type\" in item &&\n        (item.type === \"beginMarkedContent\" ||\n          item.type === \"beginMarkedContentProps\" ||\n          item.type === \"endMarkedContent\")\n      ) {\n        continue;\n      }\n      throw new TypeError(\"PDF text content contains an unknown non-text item\");\n    }\n    if (typeof item.str !== \"string\") {\n      throw new TypeError(\"PDF text content item str must be a string\");\n    }\n    if (!(\"hasEOL\" in item) || typeof item.hasEOL !== \"boolean\") {\n      throw new TypeError(\"PDF text content item hasEOL must be a boolean\");\n    }\n    text += item.str;\n    if (item.hasEOL) {\n      text += \"\\n\";\n    }\n  }\n  return text;\n}\n\nfunction createAbortPromise(\n  abortSignal: AbortSignal | undefined,\n  destroy: () => Promise<void>,\n): {\n  wait<T>(promise: Promise<T>): Promise<T>;\n  dispose(): void;\n} {\n  if (abortSignal === undefined) {\n    return {\n      wait: (promise) => promise,\n      dispose: () => undefined,\n    };\n  }\n\n  let rejectAbort: ((reason?: unknown) => void) | undefined;\n  const aborted = new Promise<never>((_resolve, reject) => {\n    rejectAbort = reject;\n  });\n  const onAbort = () => {\n    void destroy();\n    rejectAbort?.(\n      abortSignal.reason ?? new DOMException(\"The operation was aborted\", \"AbortError\"),\n    );\n  };\n  abortSignal.addEventListener(\"abort\", onAbort, { once: true });\n  if (abortSignal.aborted) {\n    onAbort();\n  }\n\n  return {\n    wait: (promise) => Promise.race([promise, aborted]),\n    dispose: () => abortSignal.removeEventListener(\"abort\", onAbort),\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/{dynamic-tools-KwEGRbHp.d.ts → dynamic-tools-AEBOTgu1.d.ts}

@@ -1,8 +1,8 @@
 import { b as RetrySetting } from './retry-CjvSlKGW.js';
-import { v as ToolDefinition } from './types-CQ_ioXWK.js';
+import { v as ToolDefinition } from './types-D9rKQ_as.js';
 import { V as VectorMetadata, E as EmbeddingModel, a as EmbeddedDocument } from './types-Cr4uiYo5.js';
-import { A as AnyTool } from './tool--Mz4v1eL.js';
-import { V as VectorFilter, a as VectorSearchResult, b as VectorInspectRequest, c as VectorInspectPage } from './types-Dld1TpWj.js';
+import { A as AnyTool } from './tool-r62gf3QY.js';
+import { V as VectorFilter, a as VectorSearchResult, b as VectorInspectRequest, c as VectorInspectPage } from './types-C3gv9EX6.js';
 
 type ToolSearchDocument<Metadata extends VectorMetadata = VectorMetadata> = {
     toolName: string;

package/dist/embeddings/index.js

@@ -10,7 +10,8 @@ import {
   embedTexts,
   euclideanDistance,
   manhattanDistance
-} from "../chunk-FMHLROPQ.js";
+} from "../chunk-GQL5KRAH.js";
+import "../chunk-3RM57ZT2.js";
 import "../chunk-FN7HLLAZ.js";
 export {
   angularDistance,

package/dist/evals/index.d.ts

@@ -1,15 +1,15 @@
-import { U as Usage, J as JsonObject, C as CompletionModel, M as Message } from '../types-CQ_ioXWK.js';
+import { U as Usage, J as JsonObject, C as CompletionModel, M as Message } from '../types-D9rKQ_as.js';
 import { Z as ZodSchema } from '../zod-schema-C7F4clpm.js';
-import { b as AgentApprovalRequiredResult, m as AgentResponse, o as AgentRunOptions, n as AgentResult } from '../types-3x3mOLHU.js';
+import { a as AgentInteractionRequest, b as AgentInteractionResponse } from '../interactions-csssHYcN.js';
+import { t as AgentSuspendedResult, j as AgentResponse, l as AgentRunOptions, k as AgentResult } from '../types-CElwurHZ.js';
 import { E as EmbeddingModel } from '../types-Cr4uiYo5.js';
 import '../model-call-options-CZkSw_xN.js';
 import 'zod';
-import '../retry-CjvSlKGW.js';
-import '../guardrails/index.js';
 import '../type-utils-CtHVDRn_.js';
-import '../types-BVzM4RsC.js';
-import '../tool--Mz4v1eL.js';
-import '../middleware-C7PdmKF7.js';
+import '../retry-CjvSlKGW.js';
+import '../types-CIPaIbZo.js';
+import '../types-DbolvLtZ.js';
+import '../tool-r62gf3QY.js';
 
 type EvalOutcome<Score = unknown> = {
     outcome: "pass";
@@ -394,6 +394,14 @@ type AgentEvalTargetOptions<Input, AgentOutput = string, Output = AgentResponse<
         input: Input;
         testCase: EvalCase<Input, Expected>;
     }): AgentRunOptions<AgentOutput> | Promise<AgentRunOptions<AgentOutput>>;
+    interactions?: {
+        maxResponses?: number | undefined;
+        respond(args: {
+            interaction: AgentInteractionRequest;
+            testCase: EvalCase<Input, Expected>;
+            phase: number;
+        }): AgentInteractionResponse | Promise<AgentInteractionResponse>;
+    } | undefined;
 } & (IsExactly<Output, AgentResponse<AgentOutput>> extends true ? {
     output?(args: {
         response: AgentResponse<AgentOutput>;
@@ -405,9 +413,9 @@ type AgentEvalTargetOptions<Input, AgentOutput = string, Output = AgentResponse<
         testCase: EvalCase<Input, Expected>;
     }): Output | Promise<Output>;
 });
-declare class AgentEvalApprovalError extends Error {
-    readonly result: AgentApprovalRequiredResult;
-    constructor(result: AgentApprovalRequiredResult);
+declare class AgentEvalSuspensionError extends Error {
+    readonly result: AgentSuspendedResult;
+    constructor(result: AgentSuspendedResult, message?: string);
 }
 declare function agentEvalTarget<Input, AgentOutput = string, Output = AgentResponse<AgentOutput>, Expected = unknown>(options: AgentEvalTargetOptions<Input, AgentOutput, Output, Expected>): EvalTarget<Input, Output, Expected>;
 
@@ -660,4 +668,4 @@ declare function defineEvalSuite<const Cases extends readonly EvalCaseLike[], co
     target: Target;
 };
 
-export { type AbstentionCategory, type AbstentionOptions, AgentEvalApprovalError, type AgentEvalTargetOptions, type AnswerRelevancyOptions, type AnyEvalMetric, type ContainsAllOptions, type ContainsAnyOptions, type ContainsListOptions, type ContainsOptions, type DefaultEvalActual, type DefinedEvalSuite, type DoesNotMatchOptions, EvalAssertionError, type EvalCase, type EvalCaseRequirements, type EvalCaseResult, type EvalCasesExpected, type EvalCasesForMetrics, type EvalCasesInput, type EvalCostCalculatorArgs, type EvalCostOptions, type EvalCostSummary, type EvalDataType, type EvalExpectations, type EvalExpectedOutcomes, type EvalExpectedTotals, type EvalMetadata, type EvalMetric, type EvalMetricArgs, type EvalMetricDescriptor, type EvalMetricResult, type EvalMetricResultFor, type EvalMetricScore, EvalOutcome, type EvalOutcomeStatus, type EvalOutputFormat, type EvalOutputWriters, type EvalReportArgs, type EvalReporter, EvalReporterDispatchError, type EvalReporterErrorPolicy, type EvalRunContext, type EvalRunEndArgs, type EvalRunOptions, type EvalRunStartArgs, type EvalScoreDirection, type EvalScoreMap, type EvalScoreProjection, type EvalSuiteResult, type EvalTarget, type EvalTargetUsageSelector, type EvalTotals, type EvalTraceCarrier, type EvalTraceRef, type EvalTraceSelector, type EvalTraceSelectorArgs, type EvalTurn, type EvalUsageSummary, type ExactMatchOptions, type FaithfulnessOptions, type GEvalOptions, type GEvalParameter, type GEvalRubric, type HallucinationOptions, type JsonCorrectnessOptions, type KnowledgeRetentionOptions, type LlmJudgeOptions, type LlmScoreMetricScore, type LlmScoreOptions, type MatchesOptions, type MaxLengthOptions, type NotContainsOptions, type PrintEvalResultOptions, type PromptAlignmentOptions, type RequiredFieldsOptions, type RunEvalCliOptions, type RunEvalSuiteOptions, type SelectorOrValue, type SemanticSimilarityOptions, type SummarizationOptions, type TurnRelevancyOptions, type ValueSelector, abstention, agentEvalTarget, answerRelevancy, assertEvalOutcomes, assertEvalTotals, contains, containsAll, containsAny, defaultEvalTraceSelector, defineEvalCases, defineEvalSuite, defineMetric, doesNotMatch, evalExitCode, exactMatch, faithfulness, gEval, hallucination, jsonCorrectness, knowledgeRetention, llmJudge, llmScore, matches, maxLength, notContains, printEvalResult, projectEvalOutcome, promptAlignment, requiredFields, resolveEvalTraceRef, runEvalCli, runEvalSuite, selectPromptOutput, semanticSimilarity, summarization, turnRelevancy };
+export { type AbstentionCategory, type AbstentionOptions, AgentEvalSuspensionError, type AgentEvalTargetOptions, type AnswerRelevancyOptions, type AnyEvalMetric, type ContainsAllOptions, type ContainsAnyOptions, type ContainsListOptions, type ContainsOptions, type DefaultEvalActual, type DefinedEvalSuite, type DoesNotMatchOptions, EvalAssertionError, type EvalCase, type EvalCaseRequirements, type EvalCaseResult, type EvalCasesExpected, type EvalCasesForMetrics, type EvalCasesInput, type EvalCostCalculatorArgs, type EvalCostOptions, type EvalCostSummary, type EvalDataType, type EvalExpectations, type EvalExpectedOutcomes, type EvalExpectedTotals, type EvalMetadata, type EvalMetric, type EvalMetricArgs, type EvalMetricDescriptor, type EvalMetricResult, type EvalMetricResultFor, type EvalMetricScore, EvalOutcome, type EvalOutcomeStatus, type EvalOutputFormat, type EvalOutputWriters, type EvalReportArgs, type EvalReporter, EvalReporterDispatchError, type EvalReporterErrorPolicy, type EvalRunContext, type EvalRunEndArgs, type EvalRunOptions, type EvalRunStartArgs, type EvalScoreDirection, type EvalScoreMap, type EvalScoreProjection, type EvalSuiteResult, type EvalTarget, type EvalTargetUsageSelector, type EvalTotals, type EvalTraceCarrier, type EvalTraceRef, type EvalTraceSelector, type EvalTraceSelectorArgs, type EvalTurn, type EvalUsageSummary, type ExactMatchOptions, type FaithfulnessOptions, type GEvalOptions, type GEvalParameter, type GEvalRubric, type HallucinationOptions, type JsonCorrectnessOptions, type KnowledgeRetentionOptions, type LlmJudgeOptions, type LlmScoreMetricScore, type LlmScoreOptions, type MatchesOptions, type MaxLengthOptions, type NotContainsOptions, type PrintEvalResultOptions, type PromptAlignmentOptions, type RequiredFieldsOptions, type RunEvalCliOptions, type RunEvalSuiteOptions, type SelectorOrValue, type SemanticSimilarityOptions, type SummarizationOptions, type TurnRelevancyOptions, type ValueSelector, abstention, agentEvalTarget, answerRelevancy, assertEvalOutcomes, assertEvalTotals, contains, containsAll, containsAny, defaultEvalTraceSelector, defineEvalCases, defineEvalSuite, defineMetric, doesNotMatch, evalExitCode, exactMatch, faithfulness, gEval, hallucination, jsonCorrectness, knowledgeRetention, llmJudge, llmScore, matches, maxLength, notContains, printEvalResult, projectEvalOutcome, promptAlignment, requiredFields, resolveEvalTraceRef, runEvalCli, runEvalSuite, selectPromptOutput, semanticSimilarity, summarization, turnRelevancy };

package/dist/evals/index.js

@@ -1,28 +1,21 @@
 import {
-  AgentRunBlockedError,
-  cancelAgentApproval
-} from "../chunk-DBSCKTUL.js";
-import "../chunk-YK4WAAS4.js";
-import "../chunk-EINTGEGY.js";
-import "../chunk-CQNNSZPG.js";
-import "../chunk-D37WMSP6.js";
-import "../chunk-77AIYARB.js";
-import "../chunk-OJH6HWHX.js";
-import "../chunk-CWM7B2OO.js";
+  AgentRunBlockedError
+} from "../chunk-TRQ3XRFD.js";
 import {
   cosineSimilarity,
-  embedText,
+  embedText
+} from "../chunk-GQL5KRAH.js";
+import {
   mapWithConcurrency
-} from "../chunk-FMHLROPQ.js";
+} from "../chunk-3RM57ZT2.js";
 import {
   extract
-} from "../chunk-4WI3VGZK.js";
+} from "../chunk-ZCPOIDAQ.js";
 import "../chunk-MGNTXGTX.js";
 import {
   Usage
-} from "../chunk-KR3RCCHJ.js";
-import "../chunk-TIZYTPJO.js";
-import "../chunk-KIDGIJM7.js";
+} from "../chunk-D2ECOWN5.js";
+import "../chunk-PK5LKOFL.js";
 import "../chunk-FN7HLLAZ.js";
 
 // src/evals/advanced-metrics.ts
@@ -1122,26 +1115,61 @@ function contentText(content) {
 }
 
 // src/evals/agent-target.ts
-var AgentEvalApprovalError = class extends Error {
-  constructor(result) {
-    super("Agent eval targets cannot suspend for tool approval.");
+var AgentEvalSuspensionError = class extends Error {
+  constructor(result, message = "Agent eval target suspended without an interaction responder.") {
+    super(message);
     this.result = result;
-    this.name = "AgentEvalApprovalError";
+    this.name = "AgentEvalSuspensionError";
   }
   result;
 };
 function agentEvalTarget(options) {
   return async (input, testCase) => {
+    const maxResponses = options.interactions?.maxResponses ?? 10;
+    if (!Number.isSafeInteger(maxResponses) || maxResponses < 1) {
+      throw new TypeError("Agent eval interactions.maxResponses must be a positive integer.");
+    }
     const request = await options.request({ input, testCase });
-    const response = await options.agent.generate(request);
-    if (response.status === "approval_required") {
-      await cancelAgentApproval(response, "Agent eval targets cannot suspend for tool approval.");
-      throw new AgentEvalApprovalError(response);
+    const runSettings = agentRunSettings(request);
+    let response = await options.agent.generate(request);
+    let phase = 0;
+    while (response.status === "suspended") {
+      if (options.interactions === void 0) {
+        throw new AgentEvalSuspensionError(response);
+      }
+      if (phase >= maxResponses) {
+        throw new AgentEvalSuspensionError(
+          response,
+          `Agent eval target exceeded the interaction response limit of ${maxResponses}.`
+        );
+      }
+      phase += 1;
+      const interactionResponse = await options.interactions.respond({
+        interaction: response.interaction,
+        testCase,
+        phase
+      });
+      response = await options.agent.generate({
+        continuation: response.continuation,
+        response: interactionResponse,
+        ...runSettings
+      });
     }
     if (response.status === "blocked") throw new AgentRunBlockedError(response);
     return options.output === void 0 ? response : await options.output({ response, testCase });
   };
 }
+function agentRunSettings(request) {
+  const {
+    prompt: _prompt,
+    messages: _messages,
+    session: _session,
+    continuation: _continuation,
+    response: _response,
+    ...settings
+  } = request;
+  return settings;
+}
 
 // src/evals/reporting.ts
 function projectEvalOutcome(outcome, dataType, projectScore) {
@@ -1286,25 +1314,26 @@ async function runEvalSuite(options) {
     metrics: aggregates.metrics,
     cases: aggregates.cases,
     usage: aggregates.usage,
-    ...aggregates.cost === void 0 ? {} : { cost: aggregates.cost },
     durationMs: Date.now() - startedAtMs,
     reporterErrors
   };
+  if (aggregates.cost !== void 0) {
+    result.cost = aggregates.cost;
+  }
+  const runEndArgs = {
+    ...lifecycle,
+    status: "completed",
+    completedAt,
+    durationMs: result.durationMs,
+    metrics: result.metrics,
+    cases: result.cases,
+    usage: result.usage
+  };
+  if (result.cost !== void 0) {
+    runEndArgs.cost = result.cost;
+  }
   result.reporterErrors.push(
-    ...await notifyRunEnd(
-      reporters,
-      {
-        ...lifecycle,
-        status: "completed",
-        completedAt,
-        durationMs: result.durationMs,
-        metrics: result.metrics,
-        cases: result.cases,
-        usage: result.usage,
-        ...result.cost === void 0 ? {} : { cost: result.cost }
-      },
-      options.reporterErrorPolicy ?? "collect"
-    )
+    ...await notifyRunEnd(reporters, runEndArgs, options.reporterErrorPolicy ?? "collect")
   );
   return result;
 }
@@ -1444,13 +1473,14 @@ function resolveRun(options, startedAtMs) {
       throw new TypeError(`Evaluation run ${label} must contain 1 to 256 characters`);
     }
   }
-  return {
+  const run = {
     id,
-    startedAt: new Date(startedAtMs).toISOString(),
-    ...options.run?.datasetName === void 0 ? {} : { datasetName: options.run.datasetName },
-    ...options.run?.datasetVersion === void 0 ? {} : { datasetVersion: options.run.datasetVersion },
-    ...options.run?.metadata === void 0 ? {} : { metadata: options.run.metadata }
+    startedAt: new Date(startedAtMs).toISOString()
   };
+  if (options.run?.datasetName !== void 0) run.datasetName = options.run.datasetName;
+  if (options.run?.datasetVersion !== void 0) run.datasetVersion = options.run.datasetVersion;
+  if (options.run?.metadata !== void 0) run.metadata = options.run.metadata;
+  return run;
 }
 async function notifyRunStart(reporters, args, errorPolicy) {
   const errors = [];
@@ -1737,18 +1767,21 @@ function jsonResult(result) {
 }
 function expectationMismatches(result, expectations) {
   if (expectations === void 0) return [];
-  return [
-    ...expectations.totals === void 0 ? [] : totalMismatches(result, expectations.totals),
-    ...expectations.outcomes === void 0 ? [] : outcomeMismatches(result, expectations.outcomes)
-  ];
+  const mismatches = [];
+  if (expectations.totals !== void 0) {
+    mismatches.push(...totalMismatches(result, expectations.totals));
+  }
+  if (expectations.outcomes !== void 0) {
+    mismatches.push(...outcomeMismatches(result, expectations.outcomes));
+  }
+  return mismatches;
 }
 function totalMismatches(result, expected) {
-  const directMetrics = {
-    ...expected.total === void 0 ? {} : { total: expected.total },
-    ...expected.passed === void 0 ? {} : { passed: expected.passed },
-    ...expected.failed === void 0 ? {} : { failed: expected.failed },
-    ...expected.invalid === void 0 ? {} : { invalid: expected.invalid }
-  };
+  const directMetrics = {};
+  if (expected.total !== void 0) directMetrics.total = expected.total;
+  if (expected.passed !== void 0) directMetrics.passed = expected.passed;
+  if (expected.failed !== void 0) directMetrics.failed = expected.failed;
+  if (expected.invalid !== void 0) directMetrics.invalid = expected.invalid;
   return [
     ...totalsGroupMismatches("metrics", result.metrics, {
       ...directMetrics,
@@ -2115,7 +2148,7 @@ function defineEvalSuite(options) {
   };
 }
 export {
-  AgentEvalApprovalError,
+  AgentEvalSuspensionError,
   EvalAssertionError,
   EvalOutcome,
   EvalReporterDispatchError,