@anvia/core 0.26.0 → 1.0.0-rc.2

package/dist/chunk-77AIYARB.js

@@ -0,0 +1,654 @@
+import {
+  cosineSimilarity,
+  embedSparseQuery,
+  embedText
+} from "./chunk-FMHLROPQ.js";
+import {
+  isJsonValue,
+  parseMessage,
+  toProviderJsonSchema
+} from "./chunk-TIZYTPJO.js";
+import {
+  resolveRetryOptions,
+  runWithRetries,
+  throwIfAborted
+} from "./chunk-FN7HLLAZ.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("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?.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) {
+  return typeof value === "object" && value !== null && richToolOutput in value;
+}
+function parseToolArgs(args) {
+  if (args.trim() === "") {
+    return {};
+  }
+  return JSON.parse(args);
+}
+
+// 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 {
+    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/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 [];
+      }
+      return [
+        {
+          score,
+          id: document.id,
+          document: document.document,
+          ...document.metadata === void 0 ? {} : { metadata: document.metadata }
+        }
+      ];
+    }).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) => ({
+          id: document.id,
+          document: document.document,
+          ...document.metadata === void 0 ? {} : { metadata: document.metadata }
+        })
+      ),
+      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,
+  assertPositiveSearchLimit,
+  assertFiniteMinScore,
+  ToolCallError,
+  ToolNotFoundError,
+  ToolJsonError,
+  ToolResultSerializationError,
+  ToolOutput,
+  normalizeToolResultOutput,
+  toolResultContentToText,
+  parseToolArgs,
+  prepareToolCall,
+  createTool,
+  vectorFilter,
+  retrieveDocuments,
+  InMemoryVectorStore,
+  createVectorSearchTool
+};
+//# sourceMappingURL=chunk-77AIYARB.js.map