@anvia/core 1.0.0-rc.1 → 1.0.0-rc.11

package/dist/{chunk-I6G7BC42.js → chunk-D4PACGPA.js}

@@ -1,13 +1,9 @@
-import {
-  Message
-} from "./chunk-ADH7NNCS.js";
-
 // src/completion/documents.ts
 function normalizeDocuments(documents) {
   if (documents.length === 0) {
     return void 0;
   }
-  return Message.user(documents.map(formatDocument).join("\n"));
+  return { role: "user", content: documents.map(formatDocument).join("\n") };
 }
 function formatDocument(document) {
   return `<file id: ${document.id}>
@@ -38,4 +34,4 @@ export {
   normalizeDocuments,
   formatDocument
 };
-//# sourceMappingURL=chunk-I6G7BC42.js.map
+//# sourceMappingURL=chunk-D4PACGPA.js.map

package/dist/chunk-D4PACGPA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/completion/documents.ts"],"sourcesContent":["import type { Document, Message } from \"./types\";\n\nexport function normalizeDocuments(documents: Document[]): Message | undefined {\n  if (documents.length === 0) {\n    return undefined;\n  }\n\n  return { role: \"user\", content: documents.map(formatDocument).join(\"\\n\") };\n}\n\nexport function formatDocument(document: Document): string {\n  return `<file id: ${document.id}>\\n${formatDocumentBody(document)}\\n</file>\\n`;\n}\n\nfunction formatDocumentBody(document: Document): string {\n  const metadata = formatMetadata(document.additionalProps);\n  return metadata === undefined ? document.text : `${metadata}\\n${document.text}`;\n}\n\nfunction formatMetadata(additionalProps: Record<string, string> | undefined): string | undefined {\n  if (additionalProps === undefined) {\n    return undefined;\n  }\n\n  const entries = Object.entries(additionalProps).sort(([left], [right]) =>\n    left.localeCompare(right),\n  );\n  if (entries.length === 0) {\n    return undefined;\n  }\n\n  const metadata = entries.map(([key, value]) => `${key}: ${JSON.stringify(value)}`).join(\" \");\n  return `<metadata ${metadata} />`;\n}\n"],"mappings":";AAEO,SAAS,mBAAmB,WAA4C;AAC7E,MAAI,UAAU,WAAW,GAAG;AAC1B,WAAO;AAAA,EACT;AAEA,SAAO,EAAE,MAAM,QAAQ,SAAS,UAAU,IAAI,cAAc,EAAE,KAAK,IAAI,EAAE;AAC3E;AAEO,SAAS,eAAe,UAA4B;AACzD,SAAO,aAAa,SAAS,EAAE;AAAA,EAAM,mBAAmB,QAAQ,CAAC;AAAA;AAAA;AACnE;AAEA,SAAS,mBAAmB,UAA4B;AACtD,QAAM,WAAW,eAAe,SAAS,eAAe;AACxD,SAAO,aAAa,SAAY,SAAS,OAAO,GAAG,QAAQ;AAAA,EAAK,SAAS,IAAI;AAC/E;AAEA,SAAS,eAAe,iBAAyE;AAC/F,MAAI,oBAAoB,QAAW;AACjC,WAAO;AAAA,EACT;AAEA,QAAM,UAAU,OAAO,QAAQ,eAAe,EAAE;AAAA,IAAK,CAAC,CAAC,IAAI,GAAG,CAAC,KAAK,MAClE,KAAK,cAAc,KAAK;AAAA,EAC1B;AACA,MAAI,QAAQ,WAAW,GAAG;AACxB,WAAO;AAAA,EACT;AAEA,QAAM,WAAW,QAAQ,IAAI,CAAC,CAAC,KAAK,KAAK,MAAM,GAAG,GAAG,KAAK,KAAK,UAAU,KAAK,CAAC,EAAE,EAAE,KAAK,GAAG;AAC3F,SAAO,aAAa,QAAQ;AAC9B;","names":[]}

package/dist/chunk-EFLT7XZD.js

@@ -0,0 +1,51 @@
+import {
+  assertJsonObject
+} from "./chunk-7JLAIN6E.js";
+import {
+  resolveRetryOptions,
+  runWithRetries,
+  throwIfAborted
+} from "./chunk-3RWESPUG.js";
+
+// src/speech-generation/generate-speech.ts
+async function generateSpeech(options) {
+  assertNonEmptyString(options.text, "Speech text");
+  assertNonEmptyString(options.voice, "Speech voice");
+  throwIfAborted(options.abortSignal);
+  const speed = options.speed ?? 1;
+  if (!Number.isFinite(speed) || speed <= 0) {
+    throw new RangeError("Speech speed must be a positive finite number.");
+  }
+  const request = { text: options.text, voice: options.voice, speed };
+  if (options.providerOptions !== void 0) {
+    assertJsonObject(options.providerOptions, "providerOptions");
+    request.providerOptions = options.providerOptions;
+  }
+  return runWithRetries(
+    () => {
+      throwIfAborted(options.abortSignal);
+      return options.model.speechGeneration(
+        request,
+        modelCallOptions(options.abortSignal)
+      );
+    },
+    resolveRetries(options.retries),
+    { streaming: false, abortSignal: options.abortSignal }
+  );
+}
+function resolveRetries(setting) {
+  return setting === void 0 || setting === false ? void 0 : resolveRetryOptions(setting);
+}
+function modelCallOptions(abortSignal) {
+  return abortSignal === void 0 ? void 0 : { abortSignal };
+}
+function assertNonEmptyString(value, name) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new TypeError(`${name} must be a non-empty string.`);
+  }
+}
+
+export {
+  generateSpeech
+};
+//# sourceMappingURL=chunk-EFLT7XZD.js.map

package/dist/chunk-EFLT7XZD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/speech-generation/generate-speech.ts"],"sourcesContent":["import type { JsonObject } from \"../completion/types\";\nimport { throwIfAborted } from \"../internal/abort\";\nimport { assertJsonObject } from \"../internal/json-object\";\nimport type { ModelCallOptions } from \"../model-call-options\";\nimport {\n  type ResolvedRetryOptions,\n  type RetrySetting,\n  resolveRetryOptions,\n  runWithRetries,\n} from \"../retry\";\nimport type {\n  SpeechGenerationModel,\n  SpeechGenerationRequest,\n  SpeechGenerationResult,\n} from \"./types\";\n\nexport type GenerateSpeechOptions<Model extends SpeechGenerationModel = SpeechGenerationModel> = {\n  model: Model;\n  text: string;\n  voice: string;\n  speed?: number | undefined;\n  providerOptions?: JsonObject | undefined;\n  retries?: RetrySetting | undefined;\n  abortSignal?: AbortSignal | undefined;\n};\n\ntype RawResponseOf<Model> =\n  Model extends SpeechGenerationModel<infer RawResponse> ? RawResponse : unknown;\n\nexport async function generateSpeech<Model extends SpeechGenerationModel>(\n  options: GenerateSpeechOptions<Model>,\n): Promise<SpeechGenerationResult<RawResponseOf<Model>>> {\n  assertNonEmptyString(options.text, \"Speech text\");\n  assertNonEmptyString(options.voice, \"Speech voice\");\n  throwIfAborted(options.abortSignal);\n  const speed = options.speed ?? 1;\n  if (!Number.isFinite(speed) || speed <= 0) {\n    throw new RangeError(\"Speech speed must be a positive finite number.\");\n  }\n\n  const request: SpeechGenerationRequest = { text: options.text, voice: options.voice, speed };\n  if (options.providerOptions !== undefined) {\n    assertJsonObject(options.providerOptions, \"providerOptions\");\n    request.providerOptions = options.providerOptions;\n  }\n  return runWithRetries(\n    () => {\n      throwIfAborted(options.abortSignal);\n      return options.model.speechGeneration(\n        request,\n        modelCallOptions(options.abortSignal),\n      ) as Promise<SpeechGenerationResult<RawResponseOf<Model>>>;\n    },\n    resolveRetries(options.retries),\n    { streaming: false, abortSignal: options.abortSignal },\n  );\n}\n\nfunction resolveRetries(setting: RetrySetting | undefined): ResolvedRetryOptions | undefined {\n  return setting === undefined || setting === false ? undefined : resolveRetryOptions(setting);\n}\n\nfunction modelCallOptions(abortSignal: AbortSignal | undefined): ModelCallOptions | undefined {\n  return abortSignal === undefined ? undefined : { abortSignal };\n}\n\nfunction assertNonEmptyString(value: string, name: string): void {\n  if (typeof value !== \"string\" || value.trim().length === 0) {\n    throw new TypeError(`${name} must be a non-empty string.`);\n  }\n}\n"],"mappings":";;;;;;;;;;AA6BA,eAAsB,eACpB,SACuD;AACvD,uBAAqB,QAAQ,MAAM,aAAa;AAChD,uBAAqB,QAAQ,OAAO,cAAc;AAClD,iBAAe,QAAQ,WAAW;AAClC,QAAM,QAAQ,QAAQ,SAAS;AAC/B,MAAI,CAAC,OAAO,SAAS,KAAK,KAAK,SAAS,GAAG;AACzC,UAAM,IAAI,WAAW,gDAAgD;AAAA,EACvE;AAEA,QAAM,UAAmC,EAAE,MAAM,QAAQ,MAAM,OAAO,QAAQ,OAAO,MAAM;AAC3F,MAAI,QAAQ,oBAAoB,QAAW;AACzC,qBAAiB,QAAQ,iBAAiB,iBAAiB;AAC3D,YAAQ,kBAAkB,QAAQ;AAAA,EACpC;AACA,SAAO;AAAA,IACL,MAAM;AACJ,qBAAe,QAAQ,WAAW;AAClC,aAAO,QAAQ,MAAM;AAAA,QACnB;AAAA,QACA,iBAAiB,QAAQ,WAAW;AAAA,MACtC;AAAA,IACF;AAAA,IACA,eAAe,QAAQ,OAAO;AAAA,IAC9B,EAAE,WAAW,OAAO,aAAa,QAAQ,YAAY;AAAA,EACvD;AACF;AAEA,SAAS,eAAe,SAAqE;AAC3F,SAAO,YAAY,UAAa,YAAY,QAAQ,SAAY,oBAAoB,OAAO;AAC7F;AAEA,SAAS,iBAAiB,aAAoE;AAC5F,SAAO,gBAAgB,SAAY,SAAY,EAAE,YAAY;AAC/D;AAEA,SAAS,qBAAqB,OAAe,MAAoB;AAC/D,MAAI,OAAO,UAAU,YAAY,MAAM,KAAK,EAAE,WAAW,GAAG;AAC1D,UAAM,IAAI,UAAU,GAAG,IAAI,8BAA8B;AAAA,EAC3D;AACF;","names":[]}

package/dist/{chunk-R2LJSQUW.js → chunk-EMZKPRE6.js}

@@ -1,18 +1,38 @@
 import {
   cosineSimilarity,
+  embedSparseQuery,
   embedText
-} from "./chunk-DZ3CKYTH.js";
+} from "./chunk-ZA564323.js";
 import {
+  parseMessage,
   toProviderJsonSchema
-} from "./chunk-RFDVKCIE.js";
+} from "./chunk-QGX73TSQ.js";
 import {
-  isToolResultContentArray,
-  serializeToolResultOutput
-} from "./chunk-ADH7NNCS.js";
+  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;
@@ -62,22 +82,63 @@ var ToolJsonError = class extends Error {
 };
 
 // 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 content;
+    return { [richToolOutput]: true, content };
   }
 };
 function normalizeToolResultOutput(output) {
-  return isToolResultContentArray(output) ? output : serializeToolResultOutput(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 : `[image:${item.mediaType ?? "image/png"}]`).join("\n");
+  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 {};
+  const value = JSON.parse(args);
+  if (!isJsonValue(value)) {
+    throw new TypeError("Tool arguments must be a JSON value.");
   }
-  return JSON.parse(args);
+  return value;
 }
 
 // src/internal/agent-runtime/prepared-tool-call.ts
@@ -119,6 +180,9 @@ function prepareToolCall(tool, args) {
   } catch (error) {
     throw asToolCallError(tool.name, error);
   }
+  return prepareToolCallFromInput(tool, input);
+}
+function prepareToolCallFromInput(tool, input) {
   return {
     input,
     async call(context) {
@@ -299,6 +363,75 @@ function seededRandom(seed) {
   };
 }
 
+// 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();
@@ -307,22 +440,25 @@ var InMemoryVectorStore = class _InMemoryVectorStore {
   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(documents, options = {}) {
+  static fromDocuments(options) {
     const store = new _InMemoryVectorStore(options);
-    store.addDocuments(documents);
+    store.replaceDocuments(options.documents);
     return store;
   }
-  addDocuments(documents) {
-    this.validateDocumentDimensions(documents);
-    for (const document of documents) {
-      this.documents.set(document.id, document);
-    }
-    this.rebuildLshIndex();
-    return this;
+  async ensure() {
+  }
+  async validate() {
   }
-  get(id) {
-    return this.documents.get(id);
+  async upsert(options) {
+    this.replaceDocuments(options.documents);
+  }
+  get(options) {
+    return this.documents.get(options.id);
   }
   values() {
     return [...this.documents.values()];
@@ -333,18 +469,75 @@ var InMemoryVectorStore = class _InMemoryVectorStore {
   isEmpty() {
     return this.documents.size === 0;
   }
-  index(model) {
-    return new InMemoryVectorIndex(model, this);
+  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();
-    }
+    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();
-    }
+    if (candidateIds.size === 0) return this.values();
     return [...candidateIds].flatMap((id) => {
       const document = this.documents.get(id);
       return document === void 0 ? [] : [document];
@@ -362,9 +555,7 @@ var InMemoryVectorStore = class _InMemoryVectorStore {
     }
     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);
-      }
+      for (const embedding of document.embeddings) index.insert(document.id, embedding.vector);
     }
     this.lshIndex = index;
   }
@@ -378,77 +569,26 @@ var InMemoryVectorStore = class _InMemoryVectorStore {
     this.embeddingDimension = dimension;
   }
   validateQueryDimension(queryEmbedding) {
-    if (this.embeddingDimension === void 0) {
-      return;
+    if (this.embeddingDimension !== void 0) {
+      validateEmbeddingDimension(this.embeddingDimension, queryEmbedding, "query");
     }
-    validateEmbeddingDimension(this.embeddingDimension, queryEmbedding, "query");
   }
 };
-var InMemoryVectorIndex = class {
-  constructor(model, store) {
-    this.model = model;
-    this.store = store;
-  }
-  model;
-  store;
-  async search(request) {
-    const queryEmbedding = await embedText(this.model, request.query);
-    return this.store.candidates(queryEmbedding).filter((document) => matchesVectorFilter(document.metadata, request.filter)).flatMap((document) => {
-      const score = bestScore(queryEmbedding, document.embeddings);
-      if (score === void 0) {
-        return [];
-      }
-      if (request.threshold !== void 0 && score < request.threshold) {
-        return [];
-      }
-      const result = {
-        score,
-        id: document.id,
-        document: document.document
-      };
-      if (document.metadata !== void 0) {
-        result.metadata = document.metadata;
-      }
-      return [result];
-    }).sort((left, right) => right.score - left.score).slice(0, Math.max(0, Math.trunc(request.topK)));
+function throwIfAborted2(signal) {
+  if (signal?.aborted) {
+    const error = new Error("The operation was aborted.");
+    error.name = "AbortError";
+    throw error;
   }
-  async searchIds(request) {
-    return (await this.search(request)).map(({ score, id }) => ({ score, id }));
-  }
-  async inspect(request) {
-    const limit = Math.max(0, Math.trunc(request.limit));
-    const start = Math.max(0, Math.trunc(Number(request.cursor ?? "0")));
-    const documents = this.store.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) => {
-        const item = {
-          id: document.id,
-          document: document.document
-        };
-        if (document.metadata !== void 0) {
-          item.metadata = document.metadata;
-        }
-        return item;
-      })
-    };
-    if (nextOffset < documents.length) {
-      result.nextCursor = String(nextOffset);
-    }
-    result.totalCount = documents.length;
-    return result;
-  }
-  asTool(options) {
-    return createVectorSearchTool(this, options);
-  }
-};
-function createVectorSearchTool(index, options) {
+}
+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().describe("The query string to search for relevant documents."),
+      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(
@@ -459,12 +599,22 @@ function createVectorSearchTool(index, options) {
         metadata: z.record(z.string(), z.union([z.string(), z.number(), z.boolean(), z.null()])).optional()
       })
     ),
-    execute: ({ query, topK }) => index.search({
-      query,
-      topK: topK ?? options.topK ?? 5,
-      threshold: options.threshold,
-      filter: options.filter
-    })
+    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) {
@@ -476,9 +626,8 @@ function bestScore(queryEmbedding, embeddings) {
   return best;
 }
 function validateEmbeddingDimension(expectedDimension, embedding, id) {
-  if (expectedDimension === void 0) {
-    return embedding.vector.length;
-  }
+  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}`
@@ -486,6 +635,12 @@ function validateEmbeddingDimension(expectedDimension, embedding, 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,
@@ -493,15 +648,20 @@ export {
   ToolCallError,
   ToolNotFoundError,
   ToolJsonError,
+  ToolResultSerializationError,
   ToolOutput,
   normalizeToolResultOutput,
   toolResultContentToText,
   parseToolArgs,
   prepareToolCall,
+  prepareToolCallFromInput,
   createTool,
+  assertPositiveSearchLimit,
+  assertFiniteMinScore,
   vectorFilter,
+  matchesVectorFilter,
+  retrieveDocuments,
   InMemoryVectorStore,
-  InMemoryVectorIndex,
   createVectorSearchTool
 };
-//# sourceMappingURL=chunk-R2LJSQUW.js.map
+//# sourceMappingURL=chunk-EMZKPRE6.js.map