@anvia/core 1.1.2 → 1.2.0

package/dist/chunk-XC3LVC4K.js

@@ -1,753 +0,0 @@
-import {
-  chunkTextDocuments
-} from "./chunk-XEVOC433.js";
-import {
-  cosineSimilarity,
-  embedDocuments,
-  embedSparseQuery,
-  embedText
-} from "./chunk-K5L7R7XM.js";
-import {
-  parseMessage,
-  toProviderJsonSchema
-} from "./chunk-QGX73TSQ.js";
-import {
-  isJsonValue
-} from "./chunk-3XQGVDU5.js";
-import {
-  resolveRetryOptions,
-  runWithRetries,
-  throwIfAborted
-} from "./chunk-3RWESPUG.js";
-
-// src/vector-store/index.ts
-import { z } from "zod";
-
-// src/internal/vector-search-options.ts
-function assertPositiveSearchLimit(value, name = "topK") {
-  if (!Number.isSafeInteger(value) || value <= 0) {
-    throw new RangeError(`${name} must be a positive safe integer.`);
-  }
-  return value;
-}
-function assertFiniteMinScore(value, name = "minScore") {
-  if (value !== void 0 && !Number.isFinite(value)) {
-    throw new RangeError(`${name} must be a finite number.`);
-  }
-  return value;
-}
-
-// src/internal/agent-runtime/approval-requirement.ts
-function toolMayRequireApproval(requirement) {
-  return requirement !== void 0 && requirement !== false;
-}
-function assertToolApprovalRequirement(requirement, options) {
-  if (typeof requirement === "boolean") {
-    return;
-  }
-  if (options.allowFunction && typeof requirement === "function") {
-    return;
-  }
-  if (typeof requirement !== "object" || requirement === null || Array.isArray(requirement)) {
-    throw new TypeError(
-      'Tool "requiresApproval" must be a boolean, a function, or an object with an optional string reason.'
-    );
-  }
-  const reason = requirement.reason;
-  if (reason !== void 0 && typeof reason !== "string") {
-    throw new TypeError('Tool "requiresApproval.reason" must be a string.');
-  }
-}
-
-// src/tool/errors.ts
-var ToolCallError = class extends Error {
-  constructor(message, cause) {
-    super(message);
-    this.cause = cause;
-    this.name = "ToolCallError";
-  }
-  cause;
-};
-var ToolNotFoundError = class extends Error {
-  constructor(toolName) {
-    super(`Tool not found: ${toolName}`);
-    this.toolName = toolName;
-    this.name = "ToolNotFoundError";
-  }
-  toolName;
-};
-var ToolJsonError = class extends Error {
-  constructor(message, cause) {
-    super(message);
-    this.cause = cause;
-    this.name = "ToolJsonError";
-  }
-  cause;
-};
-
-// src/tool/tool.ts
-var richToolOutput = /* @__PURE__ */ Symbol.for("anvia.tool-output.content");
-var ToolResultSerializationError = class extends TypeError {
-  constructor(output) {
-    super("Tool output must be a string, a strict JSON value, or ToolOutput.content(...).");
-    this.output = output;
-    this.name = "ToolResultSerializationError";
-  }
-  output;
-};
-var ToolOutput = {
-  content(content) {
-    return { [richToolOutput]: true, content };
-  }
-};
-function normalizeToolResultOutput(output) {
-  if (typeof output === "string") {
-    return { type: "text", value: output };
-  }
-  if (isRichToolOutput(output)) {
-    try {
-      const message = parseMessage({
-        role: "tool",
-        content: [
-          {
-            type: "tool-result",
-            toolCallId: "validation",
-            toolName: "validation",
-            output: { type: "content", value: output.content }
-          }
-        ]
-      });
-      if (message.role !== "tool") throw new TypeError("Unexpected message role");
-      const result = message.content[0];
-      if (result?.type !== "tool-result") throw new TypeError("Unexpected tool result part");
-      if (result?.output.type !== "content") throw new TypeError("Unexpected tool output");
-      return result.output;
-    } catch {
-      throw new ToolResultSerializationError(output);
-    }
-  }
-  if (isJsonValue(output)) {
-    return { type: "json", value: output };
-  }
-  throw new ToolResultSerializationError(output);
-}
-function toolResultContentToText(content) {
-  return content.map((item) => item.type === "text" ? item.text : `[file:${item.mediaType}]`).join("\n");
-}
-function isRichToolOutput(value) {
-  if (typeof value !== "object" || value === null) return false;
-  return Object.getOwnPropertyDescriptor(value, richToolOutput)?.value === true;
-}
-function parseToolArgs(args) {
-  const value = JSON.parse(args);
-  if (!isJsonValue(value)) {
-    throw new TypeError("Tool arguments must be a JSON value.");
-  }
-  return value;
-}
-
-// src/internal/agent-runtime/prepared-tool-call.ts
-var preparedToolInputSymbol = /* @__PURE__ */ Symbol("preparedToolInput");
-var preparedToolOwnerSymbol = /* @__PURE__ */ Symbol("preparedToolOwner");
-function attachPreparedToolOwner(tool, owner) {
-  Object.defineProperty(tool, preparedToolOwnerSymbol, {
-    configurable: false,
-    enumerable: true,
-    value: owner,
-    writable: false
-  });
-  return tool;
-}
-function preparedToolInput(context, owner) {
-  if (context === void 0 || !(preparedToolInputSymbol in context)) {
-    return void 0;
-  }
-  const prepared = context[preparedToolInputSymbol];
-  return prepared?.owner === owner ? { input: prepared.input } : void 0;
-}
-function withoutPreparedToolInput(context) {
-  if (!(preparedToolInputSymbol in context)) {
-    return context;
-  }
-  const { [preparedToolInputSymbol]: _prepared, ...publicContext } = context;
-  return publicContext;
-}
-function prepareToolCall(tool, args) {
-  let rawInput;
-  try {
-    rawInput = parseToolArgs(args);
-  } catch (error) {
-    throw new ToolJsonError(`Invalid JSON arguments for tool ${tool.name}`, error);
-  }
-  let input;
-  try {
-    input = tool.parseInput === void 0 ? rawInput : tool.parseInput(rawInput);
-  } catch (error) {
-    throw asToolCallError(tool.name, error);
-  }
-  return prepareToolCallFromInput(tool, input);
-}
-function prepareToolCallFromInput(tool, input) {
-  return {
-    input,
-    async call(context) {
-      try {
-        const owner = tool[preparedToolOwnerSymbol];
-        return normalizeToolResultOutput(
-          await tool.call(
-            input,
-            owner === void 0 ? context : withPreparedToolInput(context, owner, input)
-          )
-        );
-      } catch (error) {
-        throw asToolCallError(tool.name, error);
-      }
-    }
-  };
-}
-function withPreparedToolInput(context, owner, input) {
-  const preparedContext = { ...context };
-  Object.defineProperty(preparedContext, preparedToolInputSymbol, {
-    configurable: false,
-    enumerable: true,
-    value: { owner, input },
-    writable: false
-  });
-  return preparedContext;
-}
-function asToolCallError(toolName, error) {
-  if (error instanceof ToolCallError) {
-    return error;
-  }
-  return error instanceof Error ? new ToolCallError(error.message, error) : new ToolCallError(`Tool ${toolName} failed`, error);
-}
-
-// src/tool/create-tool.ts
-function createTool(options) {
-  const { name, description, inputSchema, outputSchema, execute } = options;
-  const requiresApproval = snapshotApprovalRequirement(options.requiresApproval);
-  if (requiresApproval !== void 0) {
-    assertToolApprovalRequirement(requiresApproval, { allowFunction: true });
-  }
-  const parameters = toProviderJsonSchema(inputSchema);
-  const preparedInputOwner = {};
-  const definition = () => ({
-    name,
-    description,
-    parameters: globalThis.structuredClone(parameters)
-  });
-  const call = async (args, context = {}) => {
-    const prepared = preparedToolInput(context, preparedInputOwner);
-    const parsedArgs = prepared === void 0 ? inputSchema.parse(args) : prepared.input;
-    const executionContext = prepared === void 0 ? context : withoutPreparedToolInput(context);
-    const result = await execute(parsedArgs, executionContext);
-    return outputSchema === void 0 ? result : outputSchema.parse(result);
-  };
-  const parseInput = (args) => inputSchema.parse(args);
-  const tool = {
-    name,
-    definition,
-    call,
-    parseInput
-  };
-  if (requiresApproval !== void 0) {
-    Object.defineProperty(tool, "requiresApproval", {
-      configurable: false,
-      enumerable: true,
-      value: requiresApproval,
-      writable: false
-    });
-  }
-  return attachPreparedToolOwner(tool, preparedInputOwner);
-}
-function snapshotApprovalRequirement(requirement) {
-  return typeof requirement === "object" && requirement !== null ? Object.freeze({ ...requirement }) : requirement;
-}
-
-// src/vector-store/filter.ts
-var vectorFilter = {
-  eq(key, value) {
-    return { type: "eq", key, value };
-  },
-  gt(key, value) {
-    return { type: "gt", key, value };
-  },
-  lt(key, value) {
-    return { type: "lt", key, value };
-  },
-  and(left, right) {
-    return { type: "and", filters: [left, right] };
-  },
-  or(left, right) {
-    return { type: "or", filters: [left, right] };
-  }
-};
-function matchesVectorFilter(metadata, filter) {
-  if (filter === void 0) {
-    return true;
-  }
-  if (metadata === void 0) {
-    return false;
-  }
-  switch (filter.type) {
-    case "eq":
-      return metadata[filter.key] === filter.value;
-    case "gt":
-      return compare(metadata[filter.key], filter.value) > 0;
-    case "lt":
-      return compare(metadata[filter.key], filter.value) < 0;
-    case "and":
-      return matchesVectorFilter(metadata, filter.filters[0]) && matchesVectorFilter(metadata, filter.filters[1]);
-    case "or":
-      return matchesVectorFilter(metadata, filter.filters[0]) || matchesVectorFilter(metadata, filter.filters[1]);
-  }
-}
-function compare(left, right) {
-  if (typeof left === "number" && typeof right === "number") {
-    return left - right;
-  }
-  if (typeof left === "string" && typeof right === "string") {
-    return left.localeCompare(right);
-  }
-  if (typeof left === "boolean" && typeof right === "boolean") {
-    return Number(left) - Number(right);
-  }
-  return 0;
-}
-
-// src/vector-store/lsh.ts
-var LshIndex = class {
-  constructor(dimensions, options) {
-    this.options = options;
-    const rng = seededRandom(options.seed ?? 42);
-    this.hyperplanes = [];
-    for (let index = 0; index < options.numTables * options.numHyperplanes; index += 1) {
-      const plane = Array.from({ length: dimensions }, () => rng() * 2 - 1);
-      const norm = Math.sqrt(plane.reduce((sum, value) => sum + value ** 2, 0));
-      this.hyperplanes.push(norm === 0 ? plane : plane.map((value) => value / norm));
-    }
-    this.tables = Array.from({ length: options.numTables }, () => /* @__PURE__ */ new Map());
-  }
-  options;
-  hyperplanes;
-  tables;
-  insert(id, vector) {
-    for (let table = 0; table < this.options.numTables; table += 1) {
-      const hash = this.hash(vector, table);
-      const bucket = this.tables[table]?.get(hash) ?? /* @__PURE__ */ new Set();
-      bucket.add(id);
-      this.tables[table]?.set(hash, bucket);
-    }
-  }
-  query(vector) {
-    const candidates = /* @__PURE__ */ new Set();
-    for (let table = 0; table < this.options.numTables; table += 1) {
-      const hash = this.hash(vector, table);
-      for (const id of this.tables[table]?.get(hash) ?? []) {
-        candidates.add(id);
-      }
-    }
-    return candidates;
-  }
-  hash(vector, table) {
-    let hash = "";
-    const start = table * this.options.numHyperplanes;
-    for (let offset = 0; offset < this.options.numHyperplanes; offset += 1) {
-      const plane = this.hyperplanes[start + offset];
-      const dot = vector.reduce((sum, value, index) => sum + value * (plane[index] ?? 0), 0);
-      hash += dot >= 0 ? "1" : "0";
-    }
-    return hash;
-  }
-};
-function seededRandom(seed) {
-  let state = seed >>> 0;
-  return () => {
-    state = state * 1664525 + 1013904223 >>> 0;
-    return state / 4294967296;
-  };
-}
-
-// src/vector-store/retrieve.ts
-async function retrieveDocuments(options) {
-  assertPositiveSearchLimit(options.topK);
-  assertFiniteMinScore(options.minScore);
-  throwIfAborted(options.abortSignal);
-  const retries = resolveRetries(options.retries);
-  const search = (operation) => runWithRetries(operation, retries, {
-    streaming: false,
-    abortSignal: options.abortSignal
-  });
-  if ("model" in options && options.model !== void 0) {
-    const { embedding } = await embedText({
-      model: options.model,
-      text: options.query,
-      retries: options.retries,
-      abortSignal: options.abortSignal
-    });
-    return deduplicateResults(
-      await search(
-        () => options.store.search({
-          vector: embedding.vector,
-          topK: options.topK,
-          minScore: options.minScore,
-          filter: options.filter,
-          abortSignal: options.abortSignal
-        })
-      )
-    );
-  }
-  const [{ embedding: dense }, { embedding: sparse }] = await Promise.all([
-    embedText({
-      model: options.models.dense,
-      text: options.query,
-      retries: options.retries,
-      abortSignal: options.abortSignal
-    }),
-    embedSparseQuery({
-      model: options.models.sparse,
-      query: options.query,
-      retries: options.retries,
-      abortSignal: options.abortSignal
-    })
-  ]);
-  return deduplicateResults(
-    await search(
-      () => options.store.searchHybrid({
-        vector: dense.vector,
-        sparseVector: sparse.vector,
-        fusion: options.fusion,
-        topK: options.topK,
-        minScore: options.minScore,
-        filter: options.filter,
-        abortSignal: options.abortSignal
-      })
-    )
-  );
-}
-function deduplicateResults(results) {
-  const bestById = /* @__PURE__ */ new Map();
-  for (const result of results) {
-    const current = bestById.get(result.id);
-    if (current === void 0 || result.score > current.score) bestById.set(result.id, result);
-  }
-  return [...bestById.values()].sort((left, right) => right.score - left.score);
-}
-function resolveRetries(setting) {
-  return setting === void 0 || setting === false ? void 0 : resolveRetryOptions(setting);
-}
-
-// src/vector-store/ingest.ts
-async function ingestVectorText(options) {
-  return ingestVectorDocuments({
-    store: options.store,
-    documents: [options.document],
-    embeddingModel: options.embeddingModel,
-    chunking: options.chunking,
-    retries: options.retries,
-    concurrency: options.concurrency,
-    providerOptions: options.providerOptions,
-    abortSignal: options.abortSignal
-  });
-}
-async function ingestVectorDocuments(options) {
-  for (const document of options.documents) {
-    validateVectorMetadata(document.metadata, document.id);
-  }
-  const chunks = chunkTextDocuments({
-    documents: options.documents,
-    chunking: options.chunking
-  });
-  const chunksByDocument = groupChunksByDocument(chunks);
-  const embedded = await embedDocuments({
-    model: options.embeddingModel,
-    documents: [...options.documents],
-    id: (document) => document.id,
-    content: (document) => {
-      const documentChunks = chunksByDocument.get(document.id);
-      if (documentChunks === void 0) {
-        throw new TypeError(`Text document ${document.id} has no chunks`);
-      }
-      return documentChunks.map((chunk) => chunk.text);
-    },
-    metadata: (document) => document.metadata,
-    retries: options.retries,
-    concurrency: options.concurrency,
-    abortSignal: options.abortSignal
-  });
-  await options.store.upsert({
-    documents: embedded.documents,
-    providerOptions: options.providerOptions
-  });
-  return { documents: embedded.documents };
-}
-function validateVectorMetadata(metadata, documentId) {
-  if (metadata === void 0) {
-    return;
-  }
-  if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata)) {
-    throw new TypeError(`Text document ${documentId} metadata must be an object`);
-  }
-  for (const [key, value] of Object.entries(metadata)) {
-    validateVectorMetadataValue(value, `Text document ${documentId} metadata.${key}`);
-  }
-}
-function validateVectorMetadataValue(value, label) {
-  if (value === null || typeof value === "string" || typeof value === "boolean") {
-    return;
-  }
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    throw new TypeError(`${label} must be a finite vector metadata value`);
-  }
-  if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
-    throw new TypeError(`${label} must be a safe integer`);
-  }
-}
-function groupChunksByDocument(chunks) {
-  const grouped = /* @__PURE__ */ new Map();
-  for (const chunk of chunks) {
-    const documentChunks = grouped.get(chunk.documentId);
-    if (documentChunks === void 0) {
-      grouped.set(chunk.documentId, [chunk]);
-    } else {
-      documentChunks.push(chunk);
-    }
-  }
-  return grouped;
-}
-
-// src/vector-store/index.ts
-var InMemoryVectorStore = class _InMemoryVectorStore {
-  documents = /* @__PURE__ */ new Map();
-  indexStrategy;
-  lshIndex;
-  embeddingDimension;
-  constructor(options = {}) {
-    this.indexStrategy = options.index ?? { type: "bruteForce" };
-    if (options.dimensions !== void 0 && (!Number.isSafeInteger(options.dimensions) || options.dimensions < 1)) {
-      throw new RangeError("Vector dimensions must be a positive safe integer.");
-    }
-    this.embeddingDimension = options.dimensions;
-  }
-  static fromDocuments(options) {
-    const store = new _InMemoryVectorStore(options);
-    store.replaceDocuments(options.documents);
-    return store;
-  }
-  async ensure() {
-  }
-  async validate() {
-  }
-  async upsert(options) {
-    this.replaceDocuments(options.documents);
-  }
-  get(options) {
-    return this.documents.get(options.id);
-  }
-  values() {
-    return [...this.documents.values()];
-  }
-  len() {
-    return this.documents.size;
-  }
-  isEmpty() {
-    return this.documents.size === 0;
-  }
-  async search(request) {
-    throwIfAborted2(request.abortSignal);
-    assertPositiveSearchLimit(request.topK);
-    assertFiniteMinScore(request.minScore);
-    const queryEmbedding = { document: "", vector: request.vector };
-    const results = this.candidates(queryEmbedding).filter((document) => matchesVectorFilter(document.metadata, request.filter)).flatMap((document) => {
-      const score = bestScore(queryEmbedding, document.embeddings);
-      if (score === void 0 || request.minScore !== void 0 && score < request.minScore) {
-        return [];
-      }
-      let result = {
-        score,
-        id: document.id,
-        document: document.document
-      };
-      if (document.metadata !== void 0) {
-        result = { ...result, metadata: document.metadata };
-      }
-      return [result];
-    }).sort((left, right) => right.score - left.score).slice(0, request.topK);
-    throwIfAborted2(request.abortSignal);
-    return results;
-  }
-  async inspect(request) {
-    throwIfAborted2(request.abortSignal);
-    const limit = assertPositiveSearchLimit(request.limit);
-    const start = Math.max(0, Math.trunc(Number(request.cursor ?? "0")));
-    const documents = this.values().filter(
-      (document) => matchesVectorFilter(document.metadata, request.filter)
-    );
-    const page = documents.slice(start, start + limit);
-    const nextOffset = start + page.length;
-    const result = {
-      items: page.map((document) => {
-        let item = {
-          id: document.id,
-          document: document.document
-        };
-        if (document.metadata !== void 0) {
-          item = { ...item, metadata: document.metadata };
-        }
-        return item;
-      }),
-      totalCount: documents.length
-    };
-    if (nextOffset < documents.length) result.nextCursor = String(nextOffset);
-    throwIfAborted2(request.abortSignal);
-    return result;
-  }
-  replaceDocuments(documents) {
-    const ids = /* @__PURE__ */ new Set();
-    for (const document of documents) {
-      if (ids.has(document.id)) throw new TypeError(`Duplicate vector document id: ${document.id}`);
-      ids.add(document.id);
-      if (document.embeddings.length === 0) {
-        throw new TypeError(`Vector document ${document.id} must contain at least one embedding.`);
-      }
-      for (const embedding of document.embeddings)
-        assertFiniteVector(embedding.vector, document.id);
-    }
-    this.validateDocumentDimensions(documents);
-    for (const document of documents) this.documents.set(document.id, document);
-    this.rebuildLshIndex();
-  }
-  candidates(queryEmbedding) {
-    this.validateQueryDimension(queryEmbedding);
-    if (this.indexStrategy.type !== "lsh" || this.lshIndex === void 0) return this.values();
-    const candidateIds = this.lshIndex.query(queryEmbedding.vector);
-    if (candidateIds.size === 0) return this.values();
-    return [...candidateIds].flatMap((id) => {
-      const document = this.documents.get(id);
-      return document === void 0 ? [] : [document];
-    });
-  }
-  rebuildLshIndex() {
-    if (this.indexStrategy.type !== "lsh") {
-      this.lshIndex = void 0;
-      return;
-    }
-    const firstEmbedding = this.values().flatMap((document) => document.embeddings)[0];
-    if (firstEmbedding === void 0) {
-      this.lshIndex = void 0;
-      return;
-    }
-    const index = new LshIndex(firstEmbedding.vector.length, this.indexStrategy);
-    for (const document of this.documents.values()) {
-      for (const embedding of document.embeddings) index.insert(document.id, embedding.vector);
-    }
-    this.lshIndex = index;
-  }
-  validateDocumentDimensions(documents) {
-    let dimension = this.embeddingDimension;
-    for (const document of documents) {
-      for (const embedding of document.embeddings) {
-        dimension = validateEmbeddingDimension(dimension, embedding, document.id);
-      }
-    }
-    this.embeddingDimension = dimension;
-  }
-  validateQueryDimension(queryEmbedding) {
-    if (this.embeddingDimension !== void 0) {
-      validateEmbeddingDimension(this.embeddingDimension, queryEmbedding, "query");
-    }
-  }
-};
-function throwIfAborted2(signal) {
-  if (signal?.aborted) {
-    const error = new Error("The operation was aborted.");
-    error.name = "AbortError";
-    throw error;
-  }
-}
-function createVectorSearchTool(options) {
-  const configuredTopK = assertPositiveSearchLimit(options.topK ?? 5);
-  assertFiniteMinScore(options.minScore);
-  return createTool({
-    name: options.name,
-    description: options.description ?? "Search a vector store for documents relevant to the provided query.",
-    inputSchema: z.object({
-      query: z.string().min(1).describe("The query string to search for relevant documents."),
-      topK: z.number().int().positive().optional().describe("The maximum number of results.")
-    }),
-    outputSchema: z.array(
-      z.object({
-        score: z.number(),
-        id: z.string(),
-        document: z.any(),
-        metadata: z.record(z.string(), z.union([z.string(), z.number(), z.boolean(), z.null()])).optional()
-      })
-    ),
-    execute: ({ query, topK }, context) => {
-      const request = {
-        query,
-        topK: topK ?? configuredTopK,
-        minScore: options.minScore,
-        filter: options.filter,
-        retries: options.retries,
-        abortSignal: context.abortSignal
-      };
-      return "models" in options && options.models !== void 0 ? retrieveDocuments({
-        ...request,
-        store: options.store,
-        models: options.models,
-        fusion: options.fusion
-      }) : retrieveDocuments({ ...request, store: options.store, model: options.model });
-    }
-  });
-}
-function bestScore(queryEmbedding, embeddings) {
-  let best;
-  for (const embedding of embeddings) {
-    const score = cosineSimilarity(queryEmbedding.vector, embedding.vector);
-    best = best === void 0 ? score : Math.max(best, score);
-  }
-  return best;
-}
-function validateEmbeddingDimension(expectedDimension, embedding, id) {
-  assertFiniteVector(embedding.vector, id);
-  if (expectedDimension === void 0) return embedding.vector.length;
-  if (embedding.vector.length !== expectedDimension) {
-    throw new Error(
-      `Vector dimension mismatch: expected ${expectedDimension} dimensions but received ${embedding.vector.length} for ${id}`
-    );
-  }
-  return expectedDimension;
-}
-function assertFiniteVector(vector, id) {
-  if (vector.length === 0) throw new TypeError(`Vector for ${id} must not be empty.`);
-  if (!vector.every(Number.isFinite)) {
-    throw new TypeError(`Vector for ${id} must contain only finite numbers.`);
-  }
-}
-
-export {
-  toolMayRequireApproval,
-  assertToolApprovalRequirement,
-  ToolCallError,
-  ToolNotFoundError,
-  ToolJsonError,
-  ToolResultSerializationError,
-  ToolOutput,
-  normalizeToolResultOutput,
-  toolResultContentToText,
-  parseToolArgs,
-  prepareToolCall,
-  prepareToolCallFromInput,
-  createTool,
-  assertPositiveSearchLimit,
-  assertFiniteMinScore,
-  vectorFilter,
-  matchesVectorFilter,
-  retrieveDocuments,
-  ingestVectorText,
-  ingestVectorDocuments,
-  InMemoryVectorStore,
-  createVectorSearchTool
-};
-//# sourceMappingURL=chunk-XC3LVC4K.js.map