@alexkroman1/aai 0.10.2 → 0.10.3

package/dist/types.js

@@ -1,192 +1,2 @@
-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
+import { a as createToolFactory, i as ToolChoiceSchema, n as DEFAULT_GREETING, o as defineAgent, r as DEFAULT_INSTRUCTIONS, s as defineTool, t as BuiltinToolSchema } from "./types-D8ZBxTL_.js";
 export { BuiltinToolSchema, DEFAULT_GREETING, DEFAULT_INSTRUCTIONS, ToolChoiceSchema, createToolFactory, defineAgent, defineTool, defineTool as tool };

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

@@ -0,0 +1,64 @@
+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.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Key-value store backed by unstorage.
+ *
+ * Works with any unstorage driver (memory, fs, S3/R2, etc.).
+ */
+import { type Storage } from "unstorage";
+import type { Kv } from "./kv.ts";
+/**
+ * Options for creating an unstorage-backed KV store.
+ */
+export type UnstorageKvOptions = {
+    /** Configured unstorage Storage instance. */
+    storage: Storage;
+    /** Key prefix prepended to all operations (e.g. `"agents/my-agent/kv"`). */
+    prefix?: string;
+};
+/**
+ * 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"
+ * ```
+ */
+export declare function createUnstorageKv(options: UnstorageKvOptions): Kv;

package/dist/unstorage-kv.js

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

package/dist/unstorage-vector-Cj5llNhg.js

@@ -0,0 +1,172 @@
+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

@@ -0,0 +1,47 @@
+/**
+ * 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

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

package/dist/vector.d.ts

@@ -34,8 +34,9 @@ export type VectorEntry = {
  * Async vector store interface used by agents.
  *
  * Agents access the vector store via `ToolContext.vector` or
- * `HookContext.vector`. Backed by Upstash Vector with built-in
- * embeddings — raw text is sent and vectorized server-side.
+ * `HookContext.vector`. Backed by unstorage with local embeddings
+ * via `all-MiniLM-L6-v2` by default. Pluggable storage driver and
+ * embedding function.
  *
  * @example
  * ```ts

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

@@ -0,0 +1,70 @@
+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.js

@@ -1,70 +1,2 @@
-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
+import { t as executeToolCall } from "./worker-entry-2jaiqIj0.js";
 export { executeToolCall };