@alexkroman1/aai 0.10.3 → 0.10.4

package/dist/vector.d.ts

@@ -1,86 +0,0 @@
-/**
- * Vector store interface.
- */
-/**
- * Validate a vector filter expression to prevent injection attacks.
- *
- * Rejects filters containing SQL keywords (SELECT, DROP, etc.),
- * statement terminators, comments, and null bytes. Enforces a
- * maximum length of 1000 characters.
- *
- * @param filter - The raw filter string from user input.
- * @returns The validated filter string (trimmed).
- * @throws Error if the filter contains dangerous patterns.
- *
- * @public
- */
-export declare function validateVectorFilter(filter: string): string;
-/**
- * A single vector search result entry.
- *
- * @public
- */
-export type VectorEntry = {
-    /** The unique identifier for this entry. */
-    id: string;
-    /** Similarity score (higher = more similar). */
-    score: number;
-    /** The original text data stored with this entry. */
-    data?: string | undefined;
-    /** Arbitrary metadata stored with this entry. */
-    metadata?: Record<string, unknown> | undefined;
-};
-/**
- * Async vector store interface used by agents.
- *
- * Agents access the vector store via `ToolContext.vector` or
- * `HookContext.vector`. Backed by unstorage with local embeddings
- * via `all-MiniLM-L6-v2` by default. Pluggable storage driver and
- * embedding function.
- *
- * @example
- * ```ts
- * // Inside a tool execute function:
- * const myTool = {
- *   description: "Search knowledge base",
- *   execute: async (_args: unknown, ctx: { vector: VectorStore }) => {
- *     await ctx.vector.upsert("doc-1", "The capital of France is Paris.");
- *     const results = await ctx.vector.query("What is the capital of France?");
- *     return results;
- *   },
- * };
- * ```
- *
- * @public
- */
-export type VectorStore = {
-    /**
-     * Upsert a text entry into the vector store.
-     *
-     * The text is automatically embedded by the server's vector database.
-     *
-     * @param id - Unique identifier for this entry.
-     * @param data - The text content to store and embed.
-     * @param metadata - Optional metadata to store alongside the vector.
-     */
-    upsert(id: string, data: string, metadata?: Record<string, unknown>): Promise<void>;
-    /**
-     * Query the vector store with a text string.
-     *
-     * Returns the most similar entries ranked by score.
-     *
-     * @param text - The query text to search for.
-     * @param options - Optional query parameters. `topK` sets the maximum number of results (default: 10). `filter` is a metadata filter expression.
-     * @returns An array of matching {@link VectorEntry} objects.
-     */
-    query(text: string, options?: {
-        topK?: number;
-        filter?: string;
-    }): Promise<VectorEntry[]>;
-    /**
-     * Delete entries by ID.
-     *
-     * @param ids - A single ID or array of IDs to delete.
-     */
-    delete(ids: string | string[]): Promise<void>;
-};

package/dist/vector.js

@@ -1,49 +0,0 @@
-//#region vector.ts
-/**
-* Vector store interface.
-*/
-/**
-* Maximum allowed length for a vector filter expression.
-* @internal
-*/
-const MAX_FILTER_LENGTH = 1e3;
-/**
-* SQL/query keywords that must not appear in filter expressions.
-* Checked case-insensitively as whole words (word-boundary match).
-* @internal
-*/
-const DANGEROUS_KEYWORDS = /\b(SELECT|INSERT|UPDATE|DELETE|DROP|ALTER|CREATE|EXEC|EXECUTE|UNION|INTO|TRUNCATE|GRANT|REVOKE|CALL)\b/i;
-/**
-* Patterns that indicate injection attempts in filter strings.
-* @internal
-*/
-const DANGEROUS_PATTERNS = [
-	/;/,
-	/--/,
-	/\/\*/,
-	/\*\//,
-	/\0/
-];
-/**
-* Validate a vector filter expression to prevent injection attacks.
-*
-* Rejects filters containing SQL keywords (SELECT, DROP, etc.),
-* statement terminators, comments, and null bytes. Enforces a
-* maximum length of 1000 characters.
-*
-* @param filter - The raw filter string from user input.
-* @returns The validated filter string (trimmed).
-* @throws Error if the filter contains dangerous patterns.
-*
-* @public
-*/
-function validateVectorFilter(filter) {
-	const trimmed = filter.trim();
-	if (trimmed.length === 0) throw new Error("Vector filter must not be empty");
-	if (trimmed.length > MAX_FILTER_LENGTH) throw new Error(`Vector filter exceeds maximum length of ${MAX_FILTER_LENGTH} characters`);
-	if (DANGEROUS_KEYWORDS.test(trimmed)) throw new Error("Vector filter contains disallowed SQL keyword");
-	for (const pattern of DANGEROUS_PATTERNS) if (pattern.test(trimmed)) throw new Error("Vector filter contains disallowed characters");
-	return trimmed;
-}
-//#endregion
-export { validateVectorFilter };

package/dist/worker-entry-2jaiqIj0.js

@@ -1,70 +0,0 @@
-import { n as EMPTY_PARAMS } from "./_internal-types-IfPcaJd5.js";
-import { n as errorDetail, r as errorMessage, s as toolError } from "./_utils-DgzpOMSV.js";
-import { f as TOOL_EXECUTION_TIMEOUT_MS } from "./protocol-B-H2Q4ox.js";
-//#region worker-entry.ts
-/** Yield to the event loop so pending I/O (e.g. WebSocket frames) can be processed. */
-const yieldTick = () => new Promise((r) => setTimeout(r, 0));
-function buildToolContext(opts) {
-	const { env, state, kv, vector, messages, onUpdate, fetch: fetchFn, sessionId } = opts;
-	return {
-		env: { ...env },
-		state: state ?? {},
-		get kv() {
-			if (!kv) throw new Error("KV not available");
-			return kv;
-		},
-		get vector() {
-			if (!vector) throw new Error("Vector store not available");
-			return vector;
-		},
-		messages: messages ?? [],
-		sendUpdate(data) {
-			onUpdate?.(data);
-		},
-		fetch: fetchFn ?? globalThis.fetch,
-		sessionId: sessionId ?? ""
-	};
-}
-/**
-* Execute a tool call with argument validation and error handling.
-*
-* Validates the provided arguments against the tool's Zod parameter schema,
-* constructs a {@link ToolContext}, invokes the tool's `execute` function,
-* and serializes the result to a string. Errors (validation failures,
-* execution throws, timeouts) are caught and returned as JSON strings
-* via {@link toolError} (`'{"error":"<message>"}'`) rather than thrown.
-*
-* @param name - The name of the tool being invoked.
-* @param args - Raw arguments from the LLM to validate and pass to the tool.
-* @param options - Tool definition, environment, and optional context.
-* @returns The tool's result serialized as a string, or an error message.
-*/
-async function executeToolCall(name, args, options) {
-	const { tool } = options;
-	const parsed = (tool.parameters ?? EMPTY_PARAMS).safeParse(args);
-	if (!parsed.success) return toolError(`Invalid arguments for tool "${name}": ${(parsed.error?.issues ?? []).map((i) => `${i.path.map(String).join(".")}: ${i.message}`).join(", ")}`);
-	let timer;
-	try {
-		const ctx = buildToolContext(options);
-		await yieldTick();
-		const timeout = new Promise((_, reject) => {
-			timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`Tool "${name}" timed out after ${TOOL_EXECUTION_TIMEOUT_MS}ms`)), TOOL_EXECUTION_TIMEOUT_MS);
-		});
-		const result = await Promise.race([Promise.resolve(tool.execute(parsed.data, ctx)), timeout]);
-		await yieldTick();
-		if (result == null) return "null";
-		return typeof result === "string" ? result : JSON.stringify(result);
-	} catch (err) {
-		const log = options.logger;
-		if (log) log.warn("Tool execution failed", {
-			tool: name,
-			error: errorDetail(err)
-		});
-		else console.warn(`[tool-executor] Tool execution failed: ${name}`, err);
-		return toolError(errorMessage(err));
-	} finally {
-		clearTimeout(timer);
-	}
-}
-//#endregion
-export { executeToolCall as t };

package/dist/worker-entry.d.ts

@@ -1,47 +0,0 @@
-/**
- * Worker entry point — shared tool execution logic.
- */
-import type { Kv } from "./kv.ts";
-import type { Logger } from "./runtime.ts";
-import type { Message, ToolDef } from "./types.ts";
-import type { VectorStore } from "./vector.ts";
-/**
- * Function signature for executing a tool by name.
- *
- * @param name - The tool name to execute.
- * @param args - Key-value arguments to pass to the tool handler.
- * @param sessionId - Optional session identifier for stateful tools.
- * @param messages - Optional conversation history for context-aware tools.
- * @returns The tool's string result, or an error message string.
- */
-export type ExecuteTool = (name: string, args: Readonly<Record<string, unknown>>, sessionId?: string, messages?: readonly Message[], onUpdate?: (data: unknown) => void) => Promise<string>;
-/** Options for {@link executeToolCall}. */
-export type ExecuteToolCallOptions = {
-    tool: ToolDef;
-    env: Readonly<Record<string, string>>;
-    state?: Record<string, unknown>;
-    sessionId?: string | undefined;
-    kv?: Kv | undefined;
-    vector?: VectorStore | undefined;
-    messages?: readonly Message[] | undefined;
-    logger?: Logger | undefined;
-    /** Callback for intermediate UI updates from `ctx.sendUpdate()`. */
-    onUpdate?: ((data: unknown) => void) | undefined;
-    /** Override fetch implementation for the tool context. */
-    fetch?: typeof globalThis.fetch | undefined;
-};
-/**
- * Execute a tool call with argument validation and error handling.
- *
- * Validates the provided arguments against the tool's Zod parameter schema,
- * constructs a {@link ToolContext}, invokes the tool's `execute` function,
- * and serializes the result to a string. Errors (validation failures,
- * execution throws, timeouts) are caught and returned as JSON strings
- * via {@link toolError} (`'{"error":"<message>"}'`) rather than thrown.
- *
- * @param name - The name of the tool being invoked.
- * @param args - Raw arguments from the LLM to validate and pass to the tool.
- * @param options - Tool definition, environment, and optional context.
- * @returns The tool's result serialized as a string, or an error message.
- */
-export declare function executeToolCall(name: string, args: Readonly<Record<string, unknown>>, options: ExecuteToolCallOptions): Promise<string>;

package/dist/worker-entry.js

@@ -1,2 +0,0 @@
-import { t as executeToolCall } from "./worker-entry-2jaiqIj0.js";
-export { executeToolCall };

package/dist/ws-handler-C0Q6eSay.js

@@ -1,207 +0,0 @@
-import { n as errorDetail, r as errorMessage } from "./_utils-DgzpOMSV.js";
-import { r as ClientMessageSchema } from "./protocol-B-H2Q4ox.js";
-import { n as consoleLogger } from "./runtime-CxcwaK68.js";
-import { h as tracer, y as wsSendDroppedCounter } from "./telemetry-CJlaDFNc.js";
-//#region ws-handler.ts
-/**
-* WebSocket session lifecycle handler.
-*
-* Audio validation is handled at the host transport layer (see server.ts).
-*/
-/** Default timeout for session.start() in milliseconds. */
-const DEFAULT_SESSION_START_TIMEOUT_MS = 1e4;
-/**
-* Creates a {@link ClientSink} backed by a plain WebSocket.
-*
-* Text events are sent as JSON text frames; audio chunks are sent as
-* binary frames (zero-copy).
-*/
-function createClientSink(ws, log) {
-	/** Send data over ws, silently dropping if the socket is not open. */
-	function safeSend(data) {
-		try {
-			if (ws.readyState !== 1) return;
-			ws.send(data);
-		} catch (err) {
-			log.debug?.("safeSend: socket closed between readyState check and send", { error: err instanceof Error ? err.message : String(err) });
-			wsSendDroppedCounter.add(1);
-		}
-	}
-	return {
-		get open() {
-			return ws.readyState === 1;
-		},
-		event(e) {
-			safeSend(JSON.stringify(e));
-		},
-		playAudioChunk(chunk) {
-			safeSend(chunk);
-		},
-		playAudioDone() {
-			safeSend(JSON.stringify({ type: "audio_done" }));
-		}
-	};
-}
-function handleBinaryAudio(data, session) {
-	if (data instanceof Uint8Array) {
-		session.onAudio(data);
-		return true;
-	}
-	if (data instanceof ArrayBuffer) {
-		session.onAudio(new Uint8Array(data));
-		return true;
-	}
-	return false;
-}
-function handleTextMessage(data, session, log, ctx, sid) {
-	if (typeof data !== "string") return;
-	let json;
-	try {
-		json = JSON.parse(data);
-	} catch {
-		log.warn("Invalid JSON from client", {
-			...ctx,
-			sid
-		});
-		return;
-	}
-	const parsed = ClientMessageSchema.safeParse(json);
-	if (!parsed.success) {
-		log.warn("Invalid client message", {
-			...ctx,
-			sid,
-			error: parsed.error.message
-		});
-		return;
-	}
-	const msg = parsed.data;
-	switch (msg.type) {
-		case "audio_ready":
-			session.onAudioReady();
-			break;
-		case "cancel":
-			session.onCancel();
-			break;
-		case "reset":
-			session.onReset();
-			break;
-		case "history":
-			session.onHistory(msg.messages);
-			break;
-		default: break;
-	}
-}
-/**
-* Attaches session lifecycle handlers to a native WebSocket using
-* plain JSON text frames and binary audio frames.
-*
-* Connection flow:
-* 1. WebSocket opens → server sends `{ type: "config", ...ReadyConfig }`
-* 2. Client sets up audio → sends `{ type: "audio_ready" }`
-* 3. If reconnecting → client sends `{ type: "history", messages: [...] }`
-*/
-function wireSessionSocket(ws, opts) {
-	const { sessions, logger: log = consoleLogger } = opts;
-	const sessionId = opts.resumeFrom ?? crypto.randomUUID();
-	const sid = sessionId.slice(0, 8);
-	const ctx = opts.logContext ?? {};
-	let session = null;
-	/** Set to true once session.start() resolves. Messages arriving before
-	*  this flag is set are buffered and replayed once the session is ready,
-	*  preventing audio/text from being dispatched to a half-initialized session. */
-	let sessionReady = false;
-	let messageBuffer = [];
-	const sessionSpan = tracer.startSpan("ws.session", { attributes: { "aai.session.id": sessionId } });
-	function drainBuffer() {
-		if (!(session && messageBuffer)) return;
-		const buf = messageBuffer;
-		messageBuffer = null;
-		for (const event of buf) {
-			const { data } = event;
-			if (handleBinaryAudio(data, session)) continue;
-			handleTextMessage(data, session, log, ctx, sid);
-		}
-	}
-	function onOpen() {
-		opts.onOpen?.();
-		log.info("Session connected", {
-			...ctx,
-			sid
-		});
-		sessionSpan.addEvent("ws.open");
-		const client = createClientSink(ws, log);
-		session = opts.createSession(sessionId, client);
-		sessions.set(sessionId, session);
-		ws.send(JSON.stringify({
-			type: "config",
-			...opts.readyConfig,
-			sessionId
-		}));
-		const timeoutMs = opts.sessionStartTimeoutMs ?? DEFAULT_SESSION_START_TIMEOUT_MS;
-		Promise.race([session.start(), new Promise((_resolve, reject) => {
-			setTimeout(() => reject(/* @__PURE__ */ new Error(`session.start() timed out after ${timeoutMs}ms`)), timeoutMs);
-		})]).then(() => {
-			log.info("Session ready", {
-				...ctx,
-				sid
-			});
-			sessionSpan.addEvent("session.ready");
-			sessionReady = true;
-			drainBuffer();
-		}).catch((err) => {
-			log.error("Session start failed", {
-				...ctx,
-				sid,
-				error: errorDetail(err)
-			});
-			sessionSpan.setStatus({
-				code: 2,
-				message: errorMessage(err)
-			});
-			sessions.delete(sessionId);
-			session = null;
-			messageBuffer = null;
-		});
-	}
-	if (ws.readyState === 1) onOpen();
-	else ws.addEventListener("open", onOpen);
-	ws.addEventListener("message", (event) => {
-		if (!session) return;
-		if (!sessionReady) {
-			messageBuffer?.push(event);
-			return;
-		}
-		const { data } = event;
-		if (handleBinaryAudio(data, session)) return;
-		handleTextMessage(data, session, log, ctx, sid);
-	});
-	ws.addEventListener("close", () => {
-		log.info("Session disconnected", {
-			...ctx,
-			sid
-		});
-		sessionSpan.addEvent("ws.close");
-		sessionSpan.end();
-		if (session) session.stop().catch((err) => {
-			log.error("Session stop failed", {
-				...ctx,
-				sid,
-				error: errorDetail(err)
-			});
-		}).finally(() => {
-			sessions.delete(sessionId);
-		});
-		opts.onClose?.();
-	});
-	ws.addEventListener("error", (ev) => {
-		const msg = typeof ev.message === "string" ? ev.message : "WebSocket error";
-		log.error("WebSocket error", {
-			...ctx,
-			sid,
-			error: msg
-		});
-		sessionSpan.recordException(new Error(msg));
-	});
-}
-//#endregion
-export { wireSessionSocket as t };

package/dist/ws-handler.js

@@ -1,2 +0,0 @@
-import { t as wireSessionSocket } from "./ws-handler-C0Q6eSay.js";
-export { wireSessionSocket };