@alexkroman1/aai 0.9.3 → 0.10.1

package/dist/builtin-tools.js

@@ -1,270 +0,0 @@
-import { tool } from "./types.js";
-import { EMPTY_PARAMS } from "./_internal-types.js";
-import { errorMessage } from "./_utils.js";
-import { z } from "zod";
-import { convert } from "html-to-text";
-//#region builtin-tools.ts
-/**
-* Built-in tool definitions for the AAI agent SDK.
-*
-* These tools run inside the sandboxed worker alongside custom tools.
-* Network requests go through the host's fetch proxy (with SSRF protection).
-*/
-/** Per-fetch timeout for network tools — tighter than the overall tool timeout. */
-const FETCH_TIMEOUT_MS = 15e3;
-/** Timeout for sandboxed code execution. */
-const RUN_CODE_TIMEOUT = 5e3;
-/** Create a fetch timeout signal. */
-function fetchSignal() {
-	return AbortSignal.timeout(FETCH_TIMEOUT_MS);
-}
-function htmlToText(html) {
-	return convert(html, { wordwrap: false });
-}
-const webSearchParams = z.object({
-	query: z.string().describe("The search query"),
-	max_results: z.number().describe("Maximum number of results to return (default 5)").optional()
-});
-const BRAVE_SEARCH_URL = "https://api.search.brave.com/res/v1/web/search";
-const BraveSearchResponseSchema = z.object({ web: z.object({ results: z.array(z.object({
-	title: z.string(),
-	url: z.string(),
-	description: z.string()
-})) }).optional() });
-function createWebSearch(fetchFn = globalThis.fetch) {
-	return {
-		description: "Search the web for current information, facts, news, or answers to questions. Returns a list of results with title, URL, and description. Use this when the user asks about something you don't know, need up-to-date information, or want to verify facts.",
-		parameters: webSearchParams,
-		async execute(args, ctx) {
-			const { query, max_results: maxResults = 5 } = args;
-			const apiKey = ctx.env.BRAVE_API_KEY ?? "";
-			if (!apiKey) return { error: "BRAVE_API_KEY is not set — web search unavailable" };
-			const resp = await fetchFn(`${BRAVE_SEARCH_URL}?${new URLSearchParams({
-				q: query,
-				count: String(maxResults),
-				text_decorations: "false"
-			})}`, {
-				headers: { "X-Subscription-Token": apiKey },
-				signal: fetchSignal()
-			});
-			if (!resp.ok) return [];
-			const raw = await resp.json();
-			const data = BraveSearchResponseSchema.safeParse(raw);
-			if (!data.success) return [];
-			return (data.data.web?.results ?? []).slice(0, maxResults).map((r) => ({
-				title: r.title,
-				url: r.url,
-				description: r.description
-			}));
-		}
-	};
-}
-const MAX_PAGE_CHARS = 1e4;
-const MAX_HTML_BYTES = 2e5;
-const visitWebpageParams = z.object({ url: z.string().describe("The full URL to fetch (e.g., 'https://example.com/page')") });
-function createVisitWebpage(fetchFn = globalThis.fetch) {
-	return {
-		description: "Fetch a webpage and return its content as clean text. Use this to read the full content of a URL found via web_search, or any link the user shares. Good for reading articles, documentation, blog posts, or product pages.",
-		parameters: visitWebpageParams,
-		async execute(args, _ctx) {
-			const { url } = args;
-			const resp = await fetchFn(url, {
-				headers: {
-					"User-Agent": "Mozilla/5.0 (compatible; VoiceAgent/1.0; +https://github.com/AssemblyAI/aai)",
-					Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
-				},
-				redirect: "follow",
-				signal: fetchSignal()
-			});
-			if (!resp.ok) return {
-				error: `Failed to fetch: ${resp.status} ${resp.statusText}`,
-				url
-			};
-			const htmlContent = await resp.text();
-			const text = htmlToText(htmlContent.length > MAX_HTML_BYTES ? htmlContent.slice(0, MAX_HTML_BYTES) : htmlContent);
-			const truncated = text.length > MAX_PAGE_CHARS;
-			return {
-				url,
-				content: truncated ? text.slice(0, MAX_PAGE_CHARS) : text,
-				...truncated ? {
-					truncated: true,
-					totalChars: text.length
-				} : {}
-			};
-		}
-	};
-}
-const fetchJsonParams = z.object({
-	url: z.string().describe("The URL to fetch JSON from"),
-	headers: z.record(z.string(), z.string()).describe("Optional HTTP headers to include in the request").optional()
-});
-function createFetchJson(fetchFn = globalThis.fetch) {
-	return {
-		description: "Call a REST API endpoint via HTTP GET and return the JSON response. Use this to fetch structured data from APIs — for example, weather data, stock prices, exchange rates, or any public JSON API. Supports custom headers for authenticated APIs.",
-		parameters: fetchJsonParams,
-		async execute(args, _ctx) {
-			const { url, headers } = args;
-			const resp = await fetchFn(url, {
-				...headers && { headers },
-				signal: fetchSignal()
-			});
-			if (!resp.ok) return {
-				error: `HTTP ${resp.status} ${resp.statusText}`,
-				url
-			};
-			try {
-				return await resp.json();
-			} catch {
-				return {
-					error: "Response was not valid JSON",
-					url
-				};
-			}
-		}
-	};
-}
-const runCodeParams = z.object({ code: z.string().describe("JavaScript code to execute. Use console.log() for output.") });
-function createRunCode() {
-	return {
-		description: "Execute JavaScript code in a secure sandbox and return the output. Use this for calculations, data transformations, string manipulation, or any task that benefits from running code. Output is captured from console.log(). No network or filesystem access.",
-		parameters: runCodeParams,
-		async execute(args) {
-			const { code } = args;
-			const output = [];
-			function capture(...captureArgs) {
-				output.push(captureArgs.map(String).join(" "));
-			}
-			const fakeConsole = {
-				log: capture,
-				info: capture,
-				warn: capture,
-				error: capture,
-				debug: capture
-			};
-			const AsyncFunction = Object.getPrototypeOf(async () => {}).constructor;
-			try {
-				const fn = new AsyncFunction("console", code);
-				await Promise.race([fn(fakeConsole), new Promise((_, reject) => setTimeout(() => reject(/* @__PURE__ */ new Error("Code execution timed out")), RUN_CODE_TIMEOUT))]);
-				return output.join("\n").trim() || "Code ran successfully (no output)";
-			} catch (err) {
-				return { error: errorMessage(err) };
-			}
-		}
-	};
-}
-const vectorSearchParams = z.object({
-	query: z.string().describe("Short keyword query to search the knowledge base. Use specific topic terms, not full sentences. Do NOT include the company or product name since all documents are from the same source. For example, if the user asks \"how much does Acme cost\", search for \"pricing plans rates\"."),
-	topK: z.number().describe("Maximum results to return (default: 5)").optional()
-});
-function createVectorSearch(vectorSearchFn) {
-	return {
-		description: "Search the agent's knowledge base for relevant information. Use this when the user asks a question that might be answered by previously ingested documents or data. Returns the most relevant matches ranked by similarity.",
-		parameters: vectorSearchParams,
-		async execute(args) {
-			const { query, topK = 5 } = args;
-			return vectorSearchFn(query, topK);
-		}
-	};
-}
-/** Single-tool creators and multi-tool expanders in one registry. */
-const TOOL_REGISTRY = {
-	web_search: { create: (opts) => createWebSearch(opts?.fetch) },
-	visit_webpage: { create: (opts) => createVisitWebpage(opts?.fetch) },
-	fetch_json: { create: (opts) => createFetchJson(opts?.fetch) },
-	run_code: { create: createRunCode },
-	vector_search: { create: (opts) => createVectorSearch(opts?.vectorSearch ?? (async () => "")) },
-	memory: { multi: memoryTools }
-};
-/** Resolve a builtin name to an array of [toolName, ToolDef] pairs. */
-function resolveBuiltin(name, opts) {
-	const entry = TOOL_REGISTRY[name];
-	if (!entry) return [];
-	if ("multi" in entry) return Object.entries(entry.multi());
-	if (name === "vector_search" && !opts?.vectorSearch) return [];
-	return [[name, entry.create(opts)]];
-}
-/**
-* Create built-in tool definitions for the given tool names.
-* For runtime use — vector_search requires opts.vectorSearch to be included.
-*/
-function getBuiltinToolDefs(names, opts) {
-	const defs = {};
-	for (const name of names) for (const [k, v] of resolveBuiltin(name, opts)) defs[k] = v;
-	return defs;
-}
-/** Returns JSON tool schemas for the specified builtin tools. */
-function getBuiltinToolSchemas(names) {
-	return names.flatMap((name) => resolveBuiltin(name, { vectorSearch: async () => "" }).map(([toolName, def]) => ({
-		name: toolName,
-		description: def.description,
-		parameters: z.toJSONSchema(def.parameters ?? EMPTY_PARAMS)
-	})));
-}
-/**
-* Returns a standard set of KV-backed memory tools: `save_memory`,
-* `recall_memory`, `list_memories`, and `forget_memory`.
-*
-* Spread the result into your agent's `tools` record.
-*
-* @example
-* ```ts
-* import { defineAgent, memoryTools } from "aai";
-*
-* export default defineAgent({
-*   name: "My Agent",
-*   tools: { ...memoryTools() },
-* });
-* ```
-*/
-function memoryTools() {
-	return {
-		save_memory: tool({
-			description: "Save a piece of information to persistent memory. Use a descriptive key like 'user:name' or 'project:status'.",
-			parameters: z.object({
-				key: z.string().describe("A descriptive key for this memory (e.g. 'user:name', 'preference:color')"),
-				value: z.string().describe("The information to remember")
-			}),
-			execute: async ({ key, value }, ctx) => {
-				await ctx.kv.set(key, value);
-				return { saved: key };
-			}
-		}),
-		recall_memory: tool({
-			description: "Retrieve a previously saved memory by its key.",
-			parameters: z.object({ key: z.string().describe("The key to look up") }),
-			execute: async ({ key }, ctx) => {
-				const value = await ctx.kv.get(key);
-				if (value === null) return {
-					found: false,
-					key
-				};
-				return {
-					found: true,
-					key,
-					value
-				};
-			}
-		}),
-		list_memories: tool({
-			description: "List all saved memory keys, optionally filtered by a prefix (e.g. 'user:').",
-			parameters: z.object({ prefix: z.string().describe("Prefix to filter keys (e.g. 'user:'). Use empty string for all.").optional() }),
-			execute: async ({ prefix }, ctx) => {
-				const entries = await ctx.kv.list(prefix ?? "");
-				return {
-					count: entries.length,
-					keys: entries.map((e) => e.key)
-				};
-			}
-		}),
-		forget_memory: tool({
-			description: "Delete a previously saved memory by its key.",
-			parameters: z.object({ key: z.string().describe("The key to delete") }),
-			execute: async ({ key }, ctx) => {
-				await ctx.kv.delete(key);
-				return { deleted: key };
-			}
-		})
-	};
-}
-//#endregion
-export { getBuiltinToolDefs, getBuiltinToolSchemas, memoryTools };

package/dist/direct-executor.js

@@ -1,125 +0,0 @@
-import { createMemoryKv } from "./kv.js";
-import { createMemoryVectorStore } from "./vector.js";
-import { agentToolsToSchemas } from "./_internal-types.js";
-import { getBuiltinToolDefs, getBuiltinToolSchemas } from "./builtin-tools.js";
-import { DEFAULT_S2S_CONFIG, consoleLogger } from "./runtime.js";
-import { createS2sSession } from "./session.js";
-import { executeToolCall } from "./worker-entry.js";
-//#region direct-executor.ts
-/**
-* Direct tool execution for self-hosted mode.
-*
-* In self-hosted mode, agent code is trusted (you're running your own code).
-* Tools execute directly in-process — no sandbox, no RPC.
-*/
-/** Build a serializable AgentConfig from an AgentDef. */
-function buildAgentConfig(agent) {
-	const config = {
-		name: agent.name,
-		instructions: agent.instructions,
-		greeting: agent.greeting
-	};
-	if (agent.sttPrompt !== void 0) config.sttPrompt = agent.sttPrompt;
-	if (typeof agent.maxSteps !== "function") config.maxSteps = agent.maxSteps;
-	if (agent.toolChoice !== void 0) config.toolChoice = agent.toolChoice;
-	if (agent.builtinTools) config.builtinTools = [...agent.builtinTools];
-	if (agent.activeTools) config.activeTools = [...agent.activeTools];
-	return config;
-}
-/** Create a direct (in-process) tool executor and hook invoker for an agent. */
-function createDirectExecutor(opts) {
-	const { agent, env, kv = createMemoryKv(), vector = createMemoryVectorStore(), vectorSearch, createWebSocket, logger = consoleLogger, s2sConfig = DEFAULT_S2S_CONFIG } = opts;
-	const agentConfig = buildAgentConfig(agent);
-	const allTools = {
-		...getBuiltinToolDefs(agent.builtinTools ?? [], vectorSearch ? { vectorSearch } : void 0),
-		...agent.tools
-	};
-	const customSchemas = agentToolsToSchemas(agent.tools ?? {});
-	const builtinSchemas = getBuiltinToolSchemas(agent.builtinTools ?? []);
-	const toolSchemas = [...customSchemas, ...builtinSchemas];
-	const sessionState = /* @__PURE__ */ new Map();
-	const frozenEnv = Object.freeze({ ...env });
-	function getState(sessionId) {
-		if (!sessionState.has(sessionId) && agent.state) sessionState.set(sessionId, agent.state());
-		return sessionState.get(sessionId) ?? {};
-	}
-	function makeHookContext(sessionId) {
-		return {
-			env: frozenEnv,
-			state: getState(sessionId),
-			get kv() {
-				return kv;
-			},
-			get vector() {
-				return vector;
-			}
-		};
-	}
-	const executeTool = async (name, args, sessionId, messages) => {
-		const tool = allTools[name];
-		if (!tool) return JSON.stringify({ error: `Unknown tool: ${name}` });
-		return executeToolCall(name, args, {
-			tool,
-			env: frozenEnv,
-			state: getState(sessionId ?? ""),
-			kv,
-			vector,
-			messages
-		});
-	};
-	const hookInvoker = {
-		async onConnect(sessionId) {
-			await agent.onConnect?.(makeHookContext(sessionId));
-		},
-		async onDisconnect(sessionId) {
-			await agent.onDisconnect?.(makeHookContext(sessionId));
-			sessionState.delete(sessionId);
-		},
-		async onTurn(sessionId, text) {
-			await agent.onTurn?.(text, makeHookContext(sessionId));
-		},
-		async onError(sessionId, error) {
-			await agent.onError?.(new Error(error.message), makeHookContext(sessionId));
-		},
-		async onStep(sessionId, step) {
-			await agent.onStep?.(step, makeHookContext(sessionId));
-		},
-		async resolveTurnConfig(sessionId) {
-			const ctx = makeHookContext(sessionId);
-			let maxSteps;
-			let activeTools;
-			if (typeof agent.maxSteps === "function") maxSteps = await agent.maxSteps(ctx) ?? void 0;
-			if (agent.onBeforeStep) activeTools = (await agent.onBeforeStep(0, ctx))?.activeTools;
-			if (maxSteps === void 0 && activeTools === void 0) return null;
-			const config = {};
-			if (maxSteps !== void 0) config.maxSteps = maxSteps;
-			if (activeTools !== void 0) config.activeTools = activeTools;
-			return config;
-		}
-	};
-	function createSession(sessionOpts) {
-		const apiKey = frozenEnv.ASSEMBLYAI_API_KEY ?? "";
-		return createS2sSession({
-			id: sessionOpts.id,
-			agent: sessionOpts.agent,
-			client: sessionOpts.client,
-			agentConfig,
-			toolSchemas,
-			apiKey,
-			s2sConfig,
-			executeTool,
-			...createWebSocket ? { createWebSocket } : {},
-			hookInvoker,
-			skipGreeting: sessionOpts.skipGreeting ?? false,
-			logger
-		});
-	}
-	return {
-		executeTool,
-		hookInvoker,
-		toolSchemas,
-		createSession
-	};
-}
-//#endregion
-export { buildAgentConfig, createDirectExecutor };