@alexkroman1/aai 0.10.3 → 0.11.0

package/dist/telemetry-CJlaDFNc.js

@@ -1,95 +0,0 @@
-import { createRequire } from "node:module";
-import { SpanStatusCode, SpanStatusCode as SpanStatusCode$1, context, metrics, metrics as metrics$1, trace, trace as trace$1 } from "@opentelemetry/api";
-//#region telemetry.ts
-/**
-* OpenTelemetry instrumentation helpers for the AAI SDK.
-*
-* Uses `@opentelemetry/api` only — consumers bring their own SDK and
-* exporters.  When no SDK is configured the API returns no-op instances,
-* so the overhead in uninstrumented environments is negligible.
-*
-* Provides:
-* - `tracer`  — a pre-scoped `Tracer` for creating spans
-* - `meter`   — a pre-scoped `Meter` for recording metrics
-* - Pre-built counters, histograms, and up/down counters covering the
-*   STT → LLM → TTS pipeline
-*/
-const SCOPE = "aai";
-const _require = createRequire(import.meta.url);
-let VERSION = "0.0.0";
-try {
-	VERSION = _require("./package.json").version;
-} catch {
-	VERSION = _require("../package.json").version;
-}
-/** Tracer scoped to the AAI SDK. */
-const tracer = trace.getTracer(SCOPE, VERSION);
-/** Meter scoped to the AAI SDK. */
-const meter = metrics.getMeter(SCOPE, VERSION);
-/** Total sessions opened. */
-const sessionCounter = meter.createCounter("aai.session.count", { description: "Total voice sessions opened" });
-/** Currently active sessions. */
-const activeSessionsUpDown = meter.createUpDownCounter("aai.session.active", { description: "Currently active voice sessions" });
-/** Total user turns (speech → transcript). */
-const turnCounter = meter.createCounter("aai.turn.count", { description: "Total user turns" });
-/** Total tool calls executed. */
-const toolCallCounter = meter.createCounter("aai.tool.call.count", { description: "Total tool calls executed" });
-/** Tool call execution duration in seconds. */
-const toolCallDuration = meter.createHistogram("aai.tool.call.duration", {
-	description: "Tool call execution duration in seconds",
-	unit: "s"
-});
-/** Total tool call errors. */
-const toolCallErrorCounter = meter.createCounter("aai.tool.call.error.count", { description: "Total tool call errors" });
-/** S2S WebSocket connection duration in seconds. */
-const s2sConnectionDuration = meter.createHistogram("aai.s2s.connection.duration", {
-	description: "S2S WebSocket connection duration in seconds",
-	unit: "s"
-});
-/** Total S2S errors. */
-const s2sErrorCounter = meter.createCounter("aai.s2s.error.count", { description: "Total S2S errors" });
-/** Number of agentic loop steps (tool calls) per completed turn. */
-const turnStepsHistogram = meter.createHistogram("aai.turn.steps", { description: "Number of agentic loop steps per completed turn" });
-/** Total barge-in (reply interrupted) events. */
-const bargeInCounter = meter.createCounter("aai.turn.bargein.count", { description: "Total barge-in (reply interrupted) events" });
-/** Messages silently dropped because the WebSocket was closed. */
-const wsSendDroppedCounter = meter.createCounter("aai.ws.send_dropped", { description: "Messages silently dropped because the WebSocket was closed" });
-/** Sessions closed due to S2S idle timeout. */
-const idleTimeoutCounter = meter.createCounter("aai.session.idle.timeout.count", { description: "Sessions closed due to S2S idle timeout" });
-/**
-* Run `fn` inside a new span. The span is automatically ended and its
-* status set based on whether `fn` throws.
-*/
-function withSpan(name, fn) {
-	return tracer.startActiveSpan(name, (span) => {
-		try {
-			const result = fn(span);
-			if (result instanceof Promise) return result.then((v) => {
-				span.setStatus({ code: SpanStatusCode.OK });
-				span.end();
-				return v;
-			}).catch((err) => {
-				span.setStatus({
-					code: SpanStatusCode.ERROR,
-					message: err instanceof Error ? err.message : String(err)
-				});
-				span.recordException(err instanceof Error ? err : new Error(String(err)));
-				span.end();
-				throw err;
-			});
-			span.setStatus({ code: SpanStatusCode.OK });
-			span.end();
-			return result;
-		} catch (err) {
-			span.setStatus({
-				code: SpanStatusCode.ERROR,
-				message: err instanceof Error ? err.message : String(err)
-			});
-			span.recordException(err instanceof Error ? err : new Error(String(err)));
-			span.end();
-			throw err;
-		}
-	});
-}
-//#endregion
-export { turnStepsHistogram as _, idleTimeoutCounter as a, s2sConnectionDuration as c, toolCallCounter as d, toolCallDuration as f, turnCounter as g, tracer as h, context as i, s2sErrorCounter as l, trace$1 as m, activeSessionsUpDown as n, meter as o, toolCallErrorCounter as p, bargeInCounter as r, metrics$1 as s, SpanStatusCode$1 as t, sessionCounter as u, withSpan as v, wsSendDroppedCounter as y };

package/dist/telemetry.d.ts

@@ -1,49 +0,0 @@
-/**
- * OpenTelemetry instrumentation helpers for the AAI SDK.
- *
- * Uses `@opentelemetry/api` only — consumers bring their own SDK and
- * exporters.  When no SDK is configured the API returns no-op instances,
- * so the overhead in uninstrumented environments is negligible.
- *
- * Provides:
- * - `tracer`  — a pre-scoped `Tracer` for creating spans
- * - `meter`   — a pre-scoped `Meter` for recording metrics
- * - Pre-built counters, histograms, and up/down counters covering the
- *   STT → LLM → TTS pipeline
- */
-import { type Meter, type Span, type Tracer } from "@opentelemetry/api";
-/** Tracer scoped to the AAI SDK. */
-export declare const tracer: Tracer;
-/** Meter scoped to the AAI SDK. */
-export declare const meter: Meter;
-/** Total sessions opened. */
-export declare const sessionCounter: import("@opentelemetry/api").Counter<import("@opentelemetry/api").Attributes>;
-/** Currently active sessions. */
-export declare const activeSessionsUpDown: import("@opentelemetry/api").UpDownCounter<import("@opentelemetry/api").Attributes>;
-/** Total user turns (speech → transcript). */
-export declare const turnCounter: import("@opentelemetry/api").Counter<import("@opentelemetry/api").Attributes>;
-/** Total tool calls executed. */
-export declare const toolCallCounter: import("@opentelemetry/api").Counter<import("@opentelemetry/api").Attributes>;
-/** Tool call execution duration in seconds. */
-export declare const toolCallDuration: import("@opentelemetry/api").Histogram<import("@opentelemetry/api").Attributes>;
-/** Total tool call errors. */
-export declare const toolCallErrorCounter: import("@opentelemetry/api").Counter<import("@opentelemetry/api").Attributes>;
-/** S2S WebSocket connection duration in seconds. */
-export declare const s2sConnectionDuration: import("@opentelemetry/api").Histogram<import("@opentelemetry/api").Attributes>;
-/** Total S2S errors. */
-export declare const s2sErrorCounter: import("@opentelemetry/api").Counter<import("@opentelemetry/api").Attributes>;
-/** Number of agentic loop steps (tool calls) per completed turn. */
-export declare const turnStepsHistogram: import("@opentelemetry/api").Histogram<import("@opentelemetry/api").Attributes>;
-/** Total barge-in (reply interrupted) events. */
-export declare const bargeInCounter: import("@opentelemetry/api").Counter<import("@opentelemetry/api").Attributes>;
-/** Messages silently dropped because the WebSocket was closed. */
-export declare const wsSendDroppedCounter: import("@opentelemetry/api").Counter<import("@opentelemetry/api").Attributes>;
-/** Sessions closed due to S2S idle timeout. */
-export declare const idleTimeoutCounter: import("@opentelemetry/api").Counter<import("@opentelemetry/api").Attributes>;
-/**
- * Run `fn` inside a new span. The span is automatically ended and its
- * status set based on whether `fn` throws.
- */
-export declare function withSpan<T>(name: string, fn: (span: Span) => T): T;
-export type { Meter, Span, Tracer } from "@opentelemetry/api";
-export { context, metrics, SpanStatusCode, trace } from "@opentelemetry/api";

package/dist/telemetry.js

@@ -1,2 +0,0 @@
-import { _ as turnStepsHistogram, a as idleTimeoutCounter, c as s2sConnectionDuration, d as toolCallCounter, f as toolCallDuration, g as turnCounter, h as tracer, i as context, l as s2sErrorCounter, m as trace, n as activeSessionsUpDown, o as meter, p as toolCallErrorCounter, r as bargeInCounter, s as metrics, t as SpanStatusCode, u as sessionCounter, v as withSpan, y as wsSendDroppedCounter } from "./telemetry-CJlaDFNc.js";
-export { SpanStatusCode, activeSessionsUpDown, bargeInCounter, context, idleTimeoutCounter, meter, metrics, s2sConnectionDuration, s2sErrorCounter, sessionCounter, toolCallCounter, toolCallDuration, toolCallErrorCounter, trace, tracer, turnCounter, turnStepsHistogram, withSpan, wsSendDroppedCounter };

package/dist/types-D8ZBxTL_.js

@@ -1,192 +0,0 @@
-import { z } from "zod";
-//#region types.ts
-/**
-* Core type definitions for the AAI agent SDK.
-*/
-/**
-* Identity helper that preserves the Zod schema generic for type inference.
-*
-* When tools are defined inline in `defineAgent({ tools: { ... } })`, the
-* generic `P` gets widened to the base `ZodObject` type, so `args` in
-* `execute` loses its specific shape. Wrapping a tool definition in
-* `defineTool()` lets TypeScript infer `P` from `parameters` and type
-* `args` correctly.
-*
-* @example
-* ```ts
-* import { defineAgent, defineTool } from "aai";
-* import { z } from "zod";
-*
-* export default defineAgent({
-*   name: "my-agent",
-*   tools: {
-*     greet: defineTool({
-*       description: "Greet the user",
-*       parameters: z.object({ name: z.string() }),
-*       execute: ({ name }) => `Hello, ${name}!`, // name is string
-*     }),
-*   },
-* });
-* ```
-*
-* @public
-*/
-function defineTool(def) {
-	return def;
-}
-/**
-* Create a typed `defineTool` helper with the session state type baked in.
-*
-* When tools need access to typed session state, you'd normally have to write
-* verbose generics on every `defineTool` call. `createToolFactory` eliminates
-* that boilerplate by returning a `defineTool` variant that already knows `S`.
-*
-* @example
-* ```ts
-* import { createToolFactory, defineAgent } from "aai";
-* import { z } from "zod";
-*
-* interface PortfolioState { holdings: Map<string, number> }
-*
-* const tool = createToolFactory<PortfolioState>();
-*
-* export default defineAgent<PortfolioState>({
-*   name: "portfolio",
-*   state: () => ({ holdings: new Map() }),
-*   tools: {
-*     buy: tool({
-*       description: "Buy shares",
-*       parameters: z.object({ symbol: z.string(), qty: z.number() }),
-*       execute: (args, ctx) => {
-*         // args.symbol is string, ctx.state is PortfolioState
-*         ctx.state.holdings.set(args.symbol, args.qty);
-*       },
-*     }),
-*   },
-* });
-* ```
-*
-* @public
-*/
-function createToolFactory() {
-	return (def) => def;
-}
-/**
-* Default system prompt used when `instructions` is not provided.
-*
-* Optimized for voice-first interactions: short sentences, no visual
-* formatting, confident tone, and concise answers.
-*/
-const DEFAULT_INSTRUCTIONS = `\
-You are AAI, a helpful AI assistant.
-
-Voice-First Rules:
-- Optimize for natural speech. Avoid jargon unless central to the answer. \
-Use short, punchy sentences.
-- Never mention "search results," "sources," or "the provided text." \
-Speak as if the knowledge is your own.
-- No visual formatting. Do not say "bullet point," "bold," or "bracketed one." \
-If you need to list items, say "First," "Next," and "Finally."
-- Start with the most important information. No introductory filler.
-- Be concise. Keep answers to 1-3 sentences. For complex topics, provide a high-level summary.
-- Be confident. Avoid hedging phrases like "It seems that" or "I believe."
-- If you don't have enough information, say so directly rather than guessing.
-- Never use exclamation points. Keep your tone calm and conversational.`;
-/** Default greeting spoken when a session starts. */
-const DEFAULT_GREETING = "Hey there. I'm a voice assistant. What can I help you with?";
-/** @internal Zod schema for {@link BuiltinTool}. Exported for reuse in internal schemas. */
-const BuiltinToolSchema = z.enum([
-	"web_search",
-	"visit_webpage",
-	"fetch_json",
-	"run_code",
-	"vector_search",
-	"memory"
-]);
-/** @internal Zod schema for {@link ToolChoice}. Exported for reuse in internal schemas. */
-const ToolChoiceSchema = z.union([z.enum([
-	"auto",
-	"required",
-	"none"
-]), z.object({
-	type: z.literal("tool"),
-	toolName: z.string().min(1)
-})]);
-const ToolDefSchema = z.object({
-	description: z.string().min(1, "Tool description must be non-empty"),
-	parameters: z.custom((val) => val === void 0 || val instanceof z.ZodType, "Expected a Zod schema").optional(),
-	execute: z.function()
-});
-/** Default TTL for persisted session data: 1 hour. */
-const DEFAULT_PERSIST_TTL = 36e5;
-const AgentOptionsSchema = z.object({
-	name: z.string().min(1, "Agent name must be non-empty"),
-	instructions: z.string().optional(),
-	greeting: z.string().optional(),
-	sttPrompt: z.string().optional(),
-	maxSteps: z.union([z.number().int().positive(), z.function()]).optional(),
-	toolChoice: ToolChoiceSchema.optional(),
-	builtinTools: z.array(BuiltinToolSchema).optional(),
-	tools: z.record(z.string(), ToolDefSchema).optional(),
-	state: z.function().optional(),
-	persistence: z.union([z.literal(true), z.object({ ttl: z.number().int().positive().optional() })]).optional(),
-	onConnect: z.function().optional(),
-	onDisconnect: z.function().optional(),
-	onError: z.function().optional(),
-	onTurn: z.function().optional(),
-	onStep: z.function().optional(),
-	middleware: z.array(z.object({
-		name: z.string().min(1, "Middleware name must be non-empty"),
-		beforeInput: z.function().optional(),
-		beforeTurn: z.function().optional(),
-		afterTurn: z.function().optional(),
-		beforeToolCall: z.function().optional(),
-		afterToolCall: z.function().optional(),
-		beforeOutput: z.function().optional()
-	})).optional(),
-	idleTimeoutMs: z.number().nonnegative().optional()
-});
-/**
-* Create an agent definition from the given options, applying sensible defaults.
-*
-* This is the main entry point for defining a voice agent. The returned
-* `AgentDef` is consumed by the AAI server at deploy time.
-*
-* @param options - Configuration for the agent including name, instructions,
-*   tools, hooks, and other settings.
-* @returns A fully resolved agent definition with all defaults applied.
-*
-* @public
-*
-* @example Basic agent with a custom tool
-* ```ts
-* import { defineAgent } from "aai";
-* import { z } from "zod";
-*
-* export default defineAgent({
-*   name: "greeter",
-*   instructions: "You greet people warmly.",
-*   tools: {
-*     greet: {
-*       description: "Greet a user by name",
-*       parameters: z.object({ name: z.string() }),
-*       execute: ({ name }) => `Hello, ${name}!`,
-*     },
-*   },
-* });
-* ```
-*/
-function defineAgent(options) {
-	AgentOptionsSchema.parse(options);
-	const persistence = options.persistence ? { ttl: typeof options.persistence === "object" ? options.persistence.ttl ?? DEFAULT_PERSIST_TTL : DEFAULT_PERSIST_TTL } : void 0;
-	return {
-		...options,
-		instructions: options.instructions ?? DEFAULT_INSTRUCTIONS,
-		greeting: options.greeting ?? "Hey there. I'm a voice assistant. What can I help you with?",
-		maxSteps: options.maxSteps ?? 5,
-		tools: options.tools ?? {},
-		persistence
-	};
-}
-//#endregion
-export { createToolFactory as a, ToolChoiceSchema as i, DEFAULT_GREETING as n, defineAgent as o, DEFAULT_INSTRUCTIONS as r, defineTool as s, BuiltinToolSchema as t };

package/dist/unstorage-kv-CDgP-frt.js

@@ -1,64 +0,0 @@
-import { n as matchGlob, r as sortAndPaginate, t as MAX_VALUE_SIZE } from "./kv-iXtikQmR.js";
-import { prefixStorage } from "unstorage";
-//#region unstorage-kv.ts
-/**
-* Key-value store backed by unstorage.
-*
-* Works with any unstorage driver (memory, fs, S3/R2, etc.).
-*/
-/**
-* Create a KV store backed by any unstorage driver.
-*
-* @param options - See {@link UnstorageKvOptions}.
-* @returns A {@link Kv} instance.
-*
-* @example
-* ```ts
-* import { createStorage } from "unstorage";
-* import { createUnstorageKv } from "@alexkroman1/aai/unstorage-kv";
-*
-* const kv = createUnstorageKv({ storage: createStorage() });
-* await kv.set("greeting", "hello");
-* const value = await kv.get<string>("greeting"); // "hello"
-* ```
-*/
-function createUnstorageKv(options) {
-	const store = options.prefix ? prefixStorage(options.storage, options.prefix) : options.storage;
-	return {
-		async get(key) {
-			return await store.getItem(key) ?? null;
-		},
-		async set(key, value, setOptions) {
-			if (JSON.stringify(value).length > 65536) throw new Error(`Value exceeds max size of ${MAX_VALUE_SIZE} bytes`);
-			const storable = value;
-			if (setOptions?.expireIn && setOptions.expireIn > 0) await store.setItem(key, storable, { ttl: Math.ceil(setOptions.expireIn / 1e3) });
-			else await store.setItem(key, storable);
-		},
-		async delete(keys) {
-			const keyArray = Array.isArray(keys) ? keys : [keys];
-			await Promise.all(keyArray.map((k) => store.removeItem(k)));
-		},
-		async list(listPrefix, listOptions) {
-			const allKeys = await store.getKeys(listPrefix);
-			const entries = [];
-			for (const key of allKeys) {
-				const value = await store.getItem(key);
-				if (value != null) entries.push({
-					key,
-					value
-				});
-			}
-			return sortAndPaginate(entries, listOptions);
-		},
-		async keys(pattern) {
-			const allKeys = await store.getKeys();
-			if (!pattern) return allKeys.sort((a, b) => a.localeCompare(b));
-			return allKeys.filter((key) => matchGlob(key, pattern)).sort((a, b) => a.localeCompare(b));
-		},
-		close() {
-			store.dispose();
-		}
-	};
-}
-//#endregion
-export { createUnstorageKv as t };

package/dist/unstorage-kv.js

@@ -1,2 +0,0 @@
-import { t as createUnstorageKv } from "./unstorage-kv-CDgP-frt.js";
-export { createUnstorageKv };

package/dist/unstorage-vector-Cj5llNhg.js

@@ -1,172 +0,0 @@
-const DEFAULT_MODEL = "Xenova/all-MiniLM-L6-v2";
-/**
-* Create a local embedding function using `all-MiniLM-L6-v2`.
-*
-* The model is downloaded on first use (~86 MB) and cached locally.
-* Subsequent calls load from cache in ~90ms. Each embedding takes <2ms.
-*/
-function createLocalEmbedFn(cacheDir) {
-	let pipelinePromise = null;
-	async function getPipeline() {
-		if (!pipelinePromise) pipelinePromise = (async () => {
-			const { pipeline, env } = await import("@huggingface/transformers");
-			env.cacheDir = cacheDir;
-			return pipeline("feature-extraction", DEFAULT_MODEL);
-		})();
-		return pipelinePromise;
-	}
-	return async (text) => {
-		const output = await (await getPipeline())(text, {
-			pooling: "mean",
-			normalize: true
-		});
-		return Array.from(output.data);
-	};
-}
-/**
-* Create a deterministic hash-based embedding function for testing.
-*
-* Produces repeatable vectors where similar text yields similar embeddings.
-* Not suitable for production — use the default local model instead.
-*
-* @param dimensions - Vector dimensions (default: 384).
-*/
-function createTestEmbedFn(dimensions = 384) {
-	return async (text) => {
-		const vec = new Float32Array(dimensions);
-		const words = text.toLowerCase().split(/\s+/).filter(Boolean);
-		for (const word of words) {
-			let hash = 0;
-			for (let i = 0; i < word.length; i++) hash = (hash << 5) - hash + word.charCodeAt(i) | 0;
-			for (let i = 0; i < 8; i++) {
-				const idx = Math.abs((hash + i * 31337) % dimensions);
-				vec[idx] = (vec[idx] ?? 0) + 1;
-			}
-		}
-		let norm = 0;
-		for (let i = 0; i < dimensions; i++) norm += (vec[i] ?? 0) * (vec[i] ?? 0);
-		norm = Math.sqrt(norm) || 1;
-		return Array.from(vec, (v) => v / norm);
-	};
-}
-/** Cosine similarity between two Float32Array vectors. */
-function cosineSimilarity(a, b) {
-	let dot = 0;
-	let normA = 0;
-	let normB = 0;
-	for (let i = 0; i < a.length; i++) {
-		const ai = a[i] ?? 0;
-		const bi = b[i] ?? 0;
-		dot += ai * bi;
-		normA += ai * ai;
-		normB += bi * bi;
-	}
-	const denom = Math.sqrt(normA) * Math.sqrt(normB);
-	return denom === 0 ? 0 : dot / denom;
-}
-/** Encode an embedding as a base64 string. */
-function encodeEmbedding(vec) {
-	const f32 = vec instanceof Float32Array ? vec : new Float32Array(vec);
-	return Buffer.from(f32.buffer, f32.byteOffset, f32.byteLength).toString("base64");
-}
-/** Decode a base64 string back to a Float32Array embedding. */
-function decodeEmbedding(b64) {
-	const buf = Buffer.from(b64, "base64");
-	return new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / 4);
-}
-//#endregion
-//#region unstorage-vector.ts
-/**
-* Create a vector store backed by any unstorage driver.
-*
-* All vectors for the scope are stored in a single blob. The blob is loaded
-* lazily on first operation and cached in memory. Mutations are written
-* through immediately.
-*
-* @param options - See {@link UnstorageVectorOptions}.
-* @returns A {@link VectorStore} instance.
-*
-* @example
-* ```ts
-* import { createStorage } from "unstorage";
-* import { createUnstorageVectorStore } from "@alexkroman1/aai/unstorage-vector";
-*
-* const vector = createUnstorageVectorStore({ storage: createStorage() });
-* await vector.upsert("doc-1", "The capital of France is Paris.");
-* const results = await vector.query("France capital");
-* ```
-*/
-function createUnstorageVectorStore(options) {
-	const { storage, blobKey = "vectors.json", dimensions = 384, modelCacheDir = ".aai/models" } = options;
-	const embedFn = options.embedFn ?? createLocalEmbedFn(modelCacheDir);
-	let cache = null;
-	async function loadCache() {
-		if (cache) return cache;
-		cache = /* @__PURE__ */ new Map();
-		const raw = await storage.getItem(blobKey);
-		if (raw != null) {
-			const blob = raw;
-			for (const [id, entry] of Object.entries(blob.entries)) {
-				const cached = {
-					data: entry.data,
-					embedding: decodeEmbedding(entry.emb)
-				};
-				if (entry.meta) cached.metadata = entry.meta;
-				cache.set(id, cached);
-			}
-		}
-		return cache;
-	}
-	async function flushCache() {
-		if (!cache) return;
-		const entries = {};
-		for (const [id, entry] of cache) entries[id] = {
-			data: entry.data,
-			...entry.metadata ? { meta: entry.metadata } : {},
-			emb: encodeEmbedding(entry.embedding)
-		};
-		const blob = {
-			v: 1,
-			d: dimensions,
-			entries
-		};
-		await storage.setItem(blobKey, blob);
-	}
-	return {
-		async upsert(id, data, metadata) {
-			const c = await loadCache();
-			const vector = await embedFn(data);
-			const entry = {
-				data,
-				embedding: new Float32Array(vector)
-			};
-			if (metadata) entry.metadata = metadata;
-			c.set(id, entry);
-			await flushCache();
-		},
-		async query(text, queryOptions) {
-			const topK = queryOptions?.topK ?? 10;
-			if (queryOptions?.filter) throw new Error("Metadata filter is not supported by the unstorage vector store");
-			if (!text.trim()) return [];
-			const c = await loadCache();
-			const queryVec = new Float32Array(await embedFn(text));
-			const scored = [];
-			for (const [id, entry] of c) scored.push({
-				id,
-				score: cosineSimilarity(queryVec, entry.embedding),
-				data: entry.data,
-				metadata: entry.metadata
-			});
-			scored.sort((a, b) => b.score - a.score);
-			return scored.slice(0, topK);
-		},
-		async delete(ids) {
-			const c = await loadCache();
-			const idArray = Array.isArray(ids) ? ids : [ids];
-			for (const id of idArray) c.delete(id);
-			await flushCache();
-		}
-	};
-}
-//#endregion
-export { createTestEmbedFn as n, createUnstorageVectorStore as t };

package/dist/unstorage-vector.d.ts

@@ -1,47 +0,0 @@
-/**
- * Vector store backed by unstorage.
- *
- * Stores all vectors for a scope in a single blob (JSON with base64-encoded
- * embeddings). Works with any unstorage driver. Brute-force cosine similarity
- * — fast for <10k vectors.
- */
-import type { Storage } from "unstorage";
-import { type EmbedFn } from "./_embeddings.ts";
-import type { VectorStore } from "./vector.ts";
-export { createTestEmbedFn, type EmbedFn } from "./_embeddings.ts";
-/**
- * Options for creating an unstorage-backed vector store.
- */
-export type UnstorageVectorOptions = {
-    /** Configured unstorage Storage instance. */
-    storage: Storage;
-    /** Key for the vector blob in storage. Defaults to `"vectors.json"`. */
-    blobKey?: string;
-    /** Custom embedding function. Defaults to local `all-MiniLM-L6-v2` model. */
-    embedFn?: EmbedFn;
-    /** Embedding dimensions. Must match the embedFn output. Defaults to 384. */
-    dimensions?: number;
-    /** Directory for caching downloaded models. Defaults to `.aai/models`. */
-    modelCacheDir?: string;
-};
-/**
- * Create a vector store backed by any unstorage driver.
- *
- * All vectors for the scope are stored in a single blob. The blob is loaded
- * lazily on first operation and cached in memory. Mutations are written
- * through immediately.
- *
- * @param options - See {@link UnstorageVectorOptions}.
- * @returns A {@link VectorStore} instance.
- *
- * @example
- * ```ts
- * import { createStorage } from "unstorage";
- * import { createUnstorageVectorStore } from "@alexkroman1/aai/unstorage-vector";
- *
- * const vector = createUnstorageVectorStore({ storage: createStorage() });
- * await vector.upsert("doc-1", "The capital of France is Paris.");
- * const results = await vector.query("France capital");
- * ```
- */
-export declare function createUnstorageVectorStore(options: UnstorageVectorOptions): VectorStore;

package/dist/unstorage-vector.js

@@ -1,2 +0,0 @@
-import { n as createTestEmbedFn, t as createUnstorageVectorStore } from "./unstorage-vector-Cj5llNhg.js";
-export { createTestEmbedFn, createUnstorageVectorStore };