@alexkroman1/aai 0.8.7 → 0.9.0

package/dist/direct-executor.js

@@ -0,0 +1,125 @@
+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 };

package/dist/{sdk/mod.d.ts → index.d.ts}

@@ -18,10 +18,6 @@
  *   },
  * });
  * ```
- *
- * @module
  */
-export { memoryTools } from "./builtin_tools.ts";
 export { type AgentOptions, type BeforeStepResult, type BuiltinTool, defineAgent, type HookContext, type Message, type StepInfo, type ToolContext, type ToolDef, tool, } from "./types.ts";
 export type { VectorEntry, VectorStore } from "./vector.ts";
-//# sourceMappingURL=mod.d.ts.map

package/dist/index.js

@@ -0,0 +1,2 @@
+import { defineAgent, tool } from "./types.js";
+export { defineAgent, tool };

package/dist/{sdk/kv.d.ts → kv.d.ts}

@@ -1,12 +1,10 @@
 /**
  * Key-value storage interface and in-memory implementation.
- *
- * @module
  */
 /**
- * A single key-value entry returned by {@linkcode Kv.list}.
+ * A single key-value entry returned by {@link Kv.list}.
  *
- * @typeParam T The type of the stored value. Defaults to `unknown`.
+ * @typeParam T - The type of the stored value. Defaults to `unknown`.
  */
 export type KvEntry<T = unknown> = {
     /** The key under which the value is stored. */
@@ -17,7 +15,7 @@ export type KvEntry<T = unknown> = {
 /**
  * Options for listing keys from the KV store.
  *
- * Used with {@linkcode Kv.list} to control result ordering and pagination.
+ * Used with {@link Kv.list} to control result ordering and pagination.
  */
 export type KvListOptions = {
     /** Maximum number of entries to return. */
@@ -28,8 +26,8 @@ export type KvListOptions = {
 /**
  * Async key-value store interface used by agents.
  *
- * Agents access the KV store via {@linkcode ToolContext.kv} or
- * {@linkcode HookContext.kv}. Values are JSON-serialized and stored as
+ * Agents access the KV store via {@link ToolContext.kv} or
+ * {@link HookContext.kv}. Values are JSON-serialized and stored as
  * strings with an optional TTL.
  *
  * @example
@@ -49,8 +47,8 @@ export type Kv = {
     /**
      * Get a value by key, or `null` if not found.
      *
-     * @typeParam T The expected type of the stored value.
-     * @param key The key to look up.
+     * @typeParam T - The expected type of the stored value.
+     * @param key - The key to look up.
      * @returns The deserialized value, or `null` if the key does not exist
      *   or has expired.
      */
@@ -58,10 +56,9 @@ export type Kv = {
     /**
      * Set a value, optionally with a TTL in milliseconds.
      *
-     * @param key The key to store the value under.
-     * @param value The value to store. Must be JSON-serializable.
-     * @param options Optional settings.
-     * @param options.expireIn Time-to-live in milliseconds. The entry is
+     * @param key - The key to store the value under.
+     * @param value - The value to store. Must be JSON-serializable.
+     * @param options - Optional settings. `expireIn` sets the time-to-live in milliseconds. The entry is
      *   automatically removed after this duration.
      * @throws {Error} If the serialized value exceeds 65,536 bytes.
      */
@@ -71,7 +68,7 @@ export type Kv = {
     /**
      * Delete a key.
      *
-     * @param key The key to remove. No-op if the key does not exist.
+     * @param key - The key to remove. No-op if the key does not exist.
      */
     delete(key: string): Promise<void>;
     /**
@@ -79,12 +76,19 @@ export type Kv = {
      *
      * Results are sorted by key in ascending lexicographic order by default.
      *
-     * @typeParam T The expected type of the stored values.
-     * @param prefix Key prefix to filter by. Use `""` to list all entries.
-     * @param options Optional pagination and ordering settings.
-     * @returns An array of matching {@linkcode KvEntry} objects.
+     * @typeParam T - The expected type of the stored values.
+     * @param prefix - Key prefix to filter by. Use `""` to list all entries.
+     * @param options - Optional pagination and ordering settings.
+     * @returns An array of matching {@link KvEntry} objects.
      */
     list<T = unknown>(prefix: string, options?: KvListOptions): Promise<KvEntry<T>[]>;
+    /**
+     * List all keys, optionally filtered by a glob-style pattern.
+     *
+     * @param pattern - Optional glob pattern (e.g. `"user:*"`). If omitted, all keys are returned.
+     * @returns An array of matching key strings.
+     */
+    keys(pattern?: string): Promise<string[]>;
 };
 export declare const MAX_VALUE_SIZE = 65536;
 /** Sort entries by key and apply reverse/limit options. Mutates the array. */
@@ -100,7 +104,7 @@ export declare function sortAndPaginate<T extends {
  * Data is stored in a plain `Map` and does not persist across restarts.
  * TTL expiration is checked lazily on reads and list operations.
  *
- * @returns A {@linkcode Kv} instance backed by in-memory storage.
+ * @returns A {@link Kv} instance backed by in-memory storage.
  *
  * @example
  * ```ts
@@ -120,4 +124,3 @@ export declare function sortAndPaginate<T extends {
  * ```
  */
 export declare function createMemoryKv(): Kv;
-//# sourceMappingURL=kv.d.ts.map

package/dist/kv.js

@@ -0,0 +1,99 @@
+//#region kv.ts
+const MAX_VALUE_SIZE = 65536;
+/** Sort entries by key and apply reverse/limit options. Mutates the array. */
+function sortAndPaginate(entries, options) {
+	entries.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+	if (options?.reverse) entries.reverse();
+	if (options?.limit && options.limit > 0) entries.length = Math.min(entries.length, options.limit);
+	return entries;
+}
+/** Simple glob matcher — supports `*` as a wildcard for any characters. */
+function matchGlob(key, pattern) {
+	const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+	return new RegExp(`^${escaped}$`).test(key);
+}
+/**
+* Create an in-memory KV store (useful for testing and local development).
+*
+* Data is stored in a plain `Map` and does not persist across restarts.
+* TTL expiration is checked lazily on reads and list operations.
+*
+* @returns A {@link Kv} instance backed by in-memory storage.
+*
+* @example
+* ```ts
+* import { createMemoryKv } from "./kv.ts";
+*
+* const kv = createMemoryKv();
+* await kv.set("greeting", "hello");
+* const value = await kv.get<string>("greeting"); // "hello"
+* ```
+*
+* @example With TTL
+* ```ts
+* import { createMemoryKv } from "./kv.ts";
+*
+* const kv = createMemoryKv();
+* await kv.set("temp", "expires soon", { expireIn: 5000 });
+* ```
+*/
+function createMemoryKv() {
+	const store = /* @__PURE__ */ new Map();
+	function isExpired(entry) {
+		return entry.expiresAt !== void 0 && entry.expiresAt <= Date.now();
+	}
+	return {
+		get(key) {
+			const entry = store.get(key);
+			if (!entry || isExpired(entry)) {
+				if (entry) store.delete(key);
+				return Promise.resolve(null);
+			}
+			return Promise.resolve(JSON.parse(entry.raw));
+		},
+		set(key, value, options) {
+			const raw = JSON.stringify(value);
+			if (raw.length > 65536) throw new Error(`Value exceeds max size of ${MAX_VALUE_SIZE} bytes`);
+			const expireIn = options?.expireIn;
+			const entry = { raw };
+			if (expireIn && expireIn > 0) entry.expiresAt = Date.now() + expireIn;
+			store.set(key, entry);
+			return Promise.resolve();
+		},
+		delete(key) {
+			store.delete(key);
+			return Promise.resolve();
+		},
+		async list(prefix, options) {
+			const now = Date.now();
+			const entries = [];
+			let i = 0;
+			for (const [key, entry] of store) {
+				if (++i % 500 === 0) await new Promise((r) => setTimeout(r, 0));
+				if (entry.expiresAt && entry.expiresAt <= now) {
+					store.delete(key);
+					continue;
+				}
+				if (key.startsWith(prefix)) entries.push({
+					key,
+					value: JSON.parse(entry.raw)
+				});
+			}
+			return sortAndPaginate(entries, options);
+		},
+		async keys(pattern) {
+			const now = Date.now();
+			const result = [];
+			for (const [key, entry] of store) {
+				if (entry.expiresAt && entry.expiresAt <= now) {
+					store.delete(key);
+					continue;
+				}
+				if (!pattern || matchGlob(key, pattern)) result.push(key);
+			}
+			return result.sort();
+		}
+	};
+}
+//#endregion
+export { MAX_VALUE_SIZE, createMemoryKv, sortAndPaginate };

package/dist/{sdk/protocol.d.ts → protocol.d.ts}

@@ -2,8 +2,6 @@
  * WebSocket wire-format types shared by server and client.
  *
  * Note: this module is for internal use only and should not be used directly.
- *
- * @module
  */
 import { z } from "zod";
 /**
@@ -55,23 +53,6 @@ export declare const KvRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
 }, z.core.$strip>], "op">;
 /** KV operation request — discriminated union on the `op` field. */
 export type KvRequest = z.infer<typeof KvRequestSchema>;
-/** Zod schema for vector operation requests. */
-export declare const VectorRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    op: z.ZodLiteral<"upsert">;
-    id: z.ZodString;
-    data: z.ZodString;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>, z.ZodObject<{
-    op: z.ZodLiteral<"query">;
-    text: z.ZodString;
-    topK: z.ZodOptional<z.ZodNumber>;
-    filter: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-    op: z.ZodLiteral<"remove">;
-    ids: z.ZodArray<z.ZodString>;
-}, z.core.$strip>], "op">;
-/** Vector operation request — discriminated union on the `op` field. */
-export type VectorRequest = z.infer<typeof VectorRequestSchema>;
 /** Default timeout for agent lifecycle hooks (onConnect, onTurn, etc). */
 export declare const HOOK_TIMEOUT_MS = 5000;
 /** Default timeout for tool execution in the worker. */
@@ -79,17 +60,21 @@ export declare const TOOL_EXECUTION_TIMEOUT_MS = 30000;
 /** Zod schema for session error codes. */
 export declare const SessionErrorCodeSchema: z.ZodEnum<{
     tool: "tool";
-    audio: "audio";
+    connection: "connection";
     stt: "stt";
     llm: "llm";
     tts: "tts";
     protocol: "protocol";
-    connection: "connection";
+    audio: "audio";
     internal: "internal";
 }>;
-/** Error codes for categorizing session errors on the wire. */
+/**
+ * Error codes for categorizing session errors on the wire.
+ *
+ * @public
+ */
 export type SessionErrorCode = z.infer<typeof SessionErrorCodeSchema>;
-/** Zod schema for {@linkcode ClientEvent}. */
+/** Zod schema for {@link ClientEvent}. */
 export declare const ClientEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"speech_started">;
 }, z.core.$strip>, z.ZodObject<{
@@ -128,12 +113,12 @@ export declare const ClientEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"error">;
     code: z.ZodEnum<{
         tool: "tool";
-        audio: "audio";
+        connection: "connection";
         stt: "stt";
         llm: "llm";
         tts: "tts";
         protocol: "protocol";
-        connection: "connection";
+        audio: "audio";
         internal: "internal";
     }>;
     message: z.ZodString;
@@ -163,12 +148,64 @@ export type ReadyConfig = {
     sampleRate: number;
     ttsSampleRate: number;
 };
+/** Zod schema for server→client text messages. */
+export declare const ServerMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"config">;
+    audioFormat: z.ZodString;
+    sampleRate: z.ZodNumber;
+    ttsSampleRate: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"audio_done">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"speech_started">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"speech_stopped">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"transcript">;
+    text: z.ZodString;
+    isFinal: z.ZodBoolean;
+    turnOrder: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"turn">;
+    text: z.ZodString;
+    turnOrder: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"chat">;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"chat_delta">;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"tool_call_start">;
+    toolCallId: z.ZodString;
+    toolName: z.ZodString;
+    args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"tool_call_done">;
+    toolCallId: z.ZodString;
+    result: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"tts_done">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"cancelled">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"reset">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    code: z.ZodEnum<{
+        tool: "tool";
+        connection: "connection";
+        stt: "stt";
+        llm: "llm";
+        tts: "tts";
+        protocol: "protocol";
+        audio: "audio";
+        internal: "internal";
+    }>;
+    message: z.ZodString;
+}, z.core.$strip>], "type">;
 /** Server→client text messages (binary frames carry raw PCM16 audio). */
-export type ServerMessage = ({
-    type: "config";
-} & ReadyConfig) | {
-    type: "audio_done";
-} | ClientEvent;
+export type ServerMessage = z.infer<typeof ServerMessageSchema>;
 /** Zod schema for client→server text messages. */
 export declare const ClientMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"audio_ready">;
@@ -193,4 +230,3 @@ export type TurnConfig = {
     maxSteps?: number;
     activeTools?: string[];
 };
-//# sourceMappingURL=protocol.d.ts.map

package/dist/protocol.js

@@ -0,0 +1,142 @@
+import { z } from "zod";
+//#region protocol.ts
+/**
+* WebSocket wire-format types shared by server and client.
+*
+* Note: this module is for internal use only and should not be used directly.
+*/
+/**
+* Default sample rate for speech-to-text audio in Hz.
+*
+* This is the sample rate expected by the STT provider (AssemblyAI).
+*/
+const DEFAULT_STT_SAMPLE_RATE = 16e3;
+/**
+* Default sample rate for text-to-speech audio in Hz.
+*
+* This is the sample rate produced by the TTS provider.
+*/
+const DEFAULT_TTS_SAMPLE_RATE = 24e3;
+/**
+* Audio codec identifier used in the wire protocol.
+*
+* All audio frames are 16-bit signed PCM, little-endian, mono.
+*/
+const AUDIO_FORMAT = "pcm16";
+/** Specification for binary audio frames exchanged over WebSocket. */
+const AudioFrameSpec = {
+	format: AUDIO_FORMAT,
+	bitsPerSample: 16,
+	endianness: "little",
+	channels: 1,
+	bytesPerSample: 2
+};
+/** Zod schema for KV operation requests from the worker to the host. */
+const KvRequestSchema = z.discriminatedUnion("op", [
+	z.object({
+		op: z.literal("get"),
+		key: z.string().min(1)
+	}),
+	z.object({
+		op: z.literal("set"),
+		key: z.string().min(1),
+		value: z.string(),
+		ttl: z.number().int().positive().optional()
+	}),
+	z.object({
+		op: z.literal("del"),
+		key: z.string().min(1)
+	}),
+	z.object({
+		op: z.literal("list"),
+		prefix: z.string(),
+		limit: z.number().int().positive().optional(),
+		reverse: z.boolean().optional()
+	}),
+	z.object({
+		op: z.literal("keys"),
+		pattern: z.string().optional()
+	})
+]);
+/** Default timeout for agent lifecycle hooks (onConnect, onTurn, etc). */
+const HOOK_TIMEOUT_MS = 5e3;
+/** Default timeout for tool execution in the worker. */
+const TOOL_EXECUTION_TIMEOUT_MS = 3e4;
+/** Zod schema for session error codes. */
+const SessionErrorCodeSchema = z.enum([
+	"stt",
+	"llm",
+	"tts",
+	"tool",
+	"protocol",
+	"connection",
+	"audio",
+	"internal"
+]);
+/** Helper: simple event with only a type field. */
+const ev = (t) => z.object({ type: z.literal(t) });
+/** Helper: event with type + text. */
+const textEv = (t) => z.object({
+	type: z.literal(t),
+	text: z.string()
+});
+const turnOrder = z.number().int().nonnegative().optional();
+/** Zod schema for {@link ClientEvent}. */
+const ClientEventSchema = z.discriminatedUnion("type", [
+	ev("speech_started"),
+	ev("speech_stopped"),
+	z.object({
+		type: z.literal("transcript"),
+		text: z.string(),
+		isFinal: z.boolean(),
+		turnOrder
+	}),
+	textEv("turn").extend({ turnOrder }),
+	textEv("chat"),
+	textEv("chat_delta"),
+	z.object({
+		type: z.literal("tool_call_start"),
+		toolCallId: z.string(),
+		toolName: z.string(),
+		args: z.record(z.string(), z.unknown())
+	}),
+	z.object({
+		type: z.literal("tool_call_done"),
+		toolCallId: z.string(),
+		result: z.string().max(4e3)
+	}),
+	ev("tts_done"),
+	ev("cancelled"),
+	ev("reset"),
+	z.object({
+		type: z.literal("error"),
+		code: SessionErrorCodeSchema,
+		message: z.string()
+	})
+]);
+/** Zod schema for server→client text messages. */
+const ServerMessageSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("config"),
+		audioFormat: z.string(),
+		sampleRate: z.number(),
+		ttsSampleRate: z.number()
+	}),
+	ev("audio_done"),
+	...ClientEventSchema.options
+]);
+/** Zod schema for client→server text messages. */
+const ClientMessageSchema = z.discriminatedUnion("type", [
+	ev("audio_ready"),
+	ev("cancel"),
+	ev("reset"),
+	z.object({
+		type: z.literal("history"),
+		messages: z.array(z.object({
+			role: z.enum(["user", "assistant"]),
+			text: z.string().max(1e5)
+		})).max(200)
+	})
+]);
+//#endregion
+export { AUDIO_FORMAT, AudioFrameSpec, ClientEventSchema, ClientMessageSchema, DEFAULT_STT_SAMPLE_RATE, DEFAULT_TTS_SAMPLE_RATE, HOOK_TIMEOUT_MS, KvRequestSchema, ServerMessageSchema, SessionErrorCodeSchema, TOOL_EXECUTION_TIMEOUT_MS };

package/dist/runtime.d.ts

@@ -0,0 +1,18 @@
+/** Structured context attached to log messages. */
+export type LogContext = Record<string, unknown>;
+/** Structured logger interface. Used by tests to suppress output. */
+export type Logger = {
+    info(msg: string, ctx?: LogContext): void;
+    warn(msg: string, ctx?: LogContext): void;
+    error(msg: string, ctx?: LogContext): void;
+    debug(msg: string, ctx?: LogContext): void;
+};
+export declare const consoleLogger: Logger;
+/** S2S endpoint configuration. */
+export type S2SConfig = {
+    wssUrl: string;
+    inputSampleRate: number;
+    outputSampleRate: number;
+};
+/** Default S2S endpoint configuration. */
+export declare const DEFAULT_S2S_CONFIG: S2SConfig;

package/dist/runtime.js

@@ -0,0 +1,16 @@
+import { DEFAULT_TTS_SAMPLE_RATE } from "./protocol.js";
+//#region runtime.ts
+const consoleLogger = {
+	info: (msg, ctx) => console.log(msg, ...ctx ? [ctx] : []),
+	warn: (msg, ctx) => console.warn(msg, ...ctx ? [ctx] : []),
+	error: (msg, ctx) => console.error(msg, ...ctx ? [ctx] : []),
+	debug: (msg, ctx) => console.debug(msg, ...ctx ? [ctx] : [])
+};
+/** Default S2S endpoint configuration. */
+const DEFAULT_S2S_CONFIG = {
+	wssUrl: "wss://speech-to-speech.us.assemblyai.com/v1/realtime",
+	inputSampleRate: DEFAULT_TTS_SAMPLE_RATE,
+	outputSampleRate: DEFAULT_TTS_SAMPLE_RATE
+};
+//#endregion
+export { DEFAULT_S2S_CONFIG, consoleLogger };