@alexkroman1/aai 0.10.2 → 0.10.4

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,70 +0,0 @@
-import { EMPTY_PARAMS } from "./_internal-types.js";
-import { errorDetail, errorMessage, toolError } from "./_utils.js";
-import { TOOL_EXECUTION_TIMEOUT_MS } from "./protocol.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 };

package/dist/ws-handler.js

@@ -1,207 +0,0 @@
-import { errorDetail, errorMessage } from "./_utils.js";
-import { ClientMessageSchema } from "./protocol.js";
-import { consoleLogger } from "./runtime.js";
-import { tracer, wsSendDroppedCounter } from "./telemetry.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 };