@alexkroman1/aai 0.12.3 → 1.0.3

package/sdk/types.ts

@@ -0,0 +1,226 @@
+// Copyright 2025 the AAI authors. MIT license.
+/**
+ * Core type definitions for the AAI agent SDK.
+ */
+
+import { z } from "zod";
+import type { Kv } from "./kv.ts";
+
+/**
+ * Identifier for a built-in server-side tool.
+ *
+ * Built-in tools run on the host process (not inside the sandboxed worker)
+ * and provide capabilities like web search, code execution, and API access.
+ *
+ * - `"web_search"` — Search the web for current information, facts, or news.
+ * - `"visit_webpage"` — Fetch a URL and return its content as clean text.
+ * - `"fetch_json"` — Call a REST API endpoint and return the JSON response.
+ * - `"run_code"` — Execute JavaScript in a sandbox for calculations and data processing.
+ *
+ * @public
+ */
+export type BuiltinTool = "web_search" | "visit_webpage" | "fetch_json" | "run_code";
+
+/**
+ * How the LLM should select tools during a turn.
+ *
+ * - `"auto"` — The model decides whether to call a tool (default).
+ * - `"required"` — The model must call at least one tool each step.
+ *
+ * @public
+ */
+export type ToolChoice = "auto" | "required";
+
+/**
+ * A single message in the conversation history.
+ *
+ * Messages are passed to tool `execute` functions via
+ * {@link ToolContext.messages} to provide conversation context.
+ *
+ * @public
+ */
+export type Message = {
+  /** The role of the message sender. */
+  role: "user" | "assistant" | "tool";
+  /** The text content of the message. */
+  content: string;
+};
+
+/**
+ * Context passed to tool `execute` functions.
+ *
+ * Provides access to the session environment, state, KV store, and
+ * conversation history from within a tool's execute handler.
+ *
+ * @typeParam S - The shape of per-session state created by the agent's
+ *   `state` factory. Defaults to `Record<string, unknown>`.
+ *
+ * @example
+ * ```ts
+ * import { type ToolDef } from "@alexkroman1/aai";
+ * import { z } from "zod";
+ *
+ * const myTool: ToolDef = {
+ *   description: "Look up a value from the KV store",
+ *   parameters: z.object({ key: z.string() }),
+ *   execute: async ({ key }, ctx) => {
+ *     const value = await ctx.kv.get(key);
+ *     return { key, value };
+ *   },
+ * };
+ * ```
+ *
+ * @public
+ */
+export type ToolContext<S = Record<string, unknown>> = {
+  /** Environment variables declared in the agent config. */
+  env: Readonly<Record<string, string>>;
+  /** Mutable per-session state created by the agent's `state` factory. */
+  state: S;
+  /** Key-value store scoped to this agent deployment. */
+  kv: Kv;
+  /** Read-only snapshot of conversation messages so far. */
+  messages: readonly Message[];
+  /** Unique identifier for the current session. Useful for correlating logs across concurrent sessions. */
+  sessionId: string;
+};
+
+/**
+ * Definition of a custom tool that the agent can invoke.
+ *
+ * Tools are the primary way to extend agent capabilities. Each tool has a
+ * description (shown to the LLM), optional Zod parameters schema, and an
+ * `execute` function that runs inside the sandboxed worker.
+ *
+ * @typeParam P - A Zod object schema describing the tool's parameters.
+ *   Defaults to `ZodObject<ZodRawShape>` so tools without parameters don't need an explicit
+ *   type argument.
+ *
+ * @example
+ * ```ts
+ * import { type ToolDef } from "@alexkroman1/aai";
+ * import { z } from "zod";
+ *
+ * const weatherTool: ToolDef<typeof params> = {
+ *   description: "Get current weather for a city",
+ *   parameters: z.object({
+ *     city: z.string().describe("City name"),
+ *   }),
+ *   execute: async ({ city }) => {
+ *     const res = await fetch(`https://wttr.in/${city}?format=j1`);
+ *     return await res.json();
+ *   },
+ * };
+ *
+ * const params = z.object({ city: z.string() });
+ * ```
+ *
+ * @public
+ */
+export type ToolDef<
+  P extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>,
+  S = Record<string, unknown>,
+> = {
+  /** Human-readable description shown to the LLM. */
+  description: string;
+  /** Zod schema for the tool's parameters. */
+  parameters?: P;
+  /** Function that executes the tool and returns a result. */
+  execute(args: z.infer<P>, ctx: ToolContext<S>): Promise<unknown> | unknown;
+};
+
+/**
+ * A mapping of tool names to their result types.
+ *
+ * Define this in a shared file (e.g. `shared.ts`) that both `agent.ts` and
+ * `client.tsx` can import, so tool result types stay in sync without
+ * duplication.
+ *
+ * @example
+ * ```ts
+ * // shared.ts
+ * import type { ToolResultMap } from "@alexkroman1/aai-cli/types";
+ *
+ * export interface Pizza {
+ *   id: number;
+ *   size: "small" | "medium" | "large";
+ *   toppings: string[];
+ * }
+ *
+ * export type MyToolResults = ToolResultMap<{
+ *   add_pizza: { added: Pizza; orderTotal: string };
+ *   place_order: { orderNumber: number; total: string };
+ * }>;
+ * ```
+ *
+ * Then use with {@link aai-ui#useToolResult | useToolResult}:
+ *
+ * ```tsx
+ * // client.tsx
+ * import type { MyToolResults } from "./shared.ts";
+ *
+ * useToolResult<MyToolResults["add_pizza"]>("add_pizza", (result) => {
+ *   console.log(result.added); // fully typed
+ * });
+ * ```
+ *
+ * @public
+ */
+export type ToolResultMap<T extends Record<string, unknown> = Record<string, unknown>> = T;
+
+/**
+ * Default system prompt used when `systemPrompt` is not provided.
+ *
+ * Optimized for voice-first interactions: short sentences, no visual
+ * formatting, confident tone, and concise answers.
+ */
+export const DEFAULT_SYSTEM_PROMPT: string = `\
+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. */
+export const DEFAULT_GREETING: string =
+  "Hey there. I'm a voice assistant. What can I help you with?";
+
+/**
+ * Fully resolved agent definition.
+ *
+ * Core fields (`name`, `systemPrompt`, `greeting`, `maxSteps`, `tools`)
+ * are resolved to their final values with defaults applied. Optional
+ * behavioral fields (hooks, `sttPrompt`, etc.) remain optional —
+ * `undefined` means "not configured."
+ *
+ * @public
+ */
+export type AgentDef<S = Record<string, unknown>> = {
+  name: string;
+  systemPrompt: string;
+  greeting: string;
+  sttPrompt?: string;
+  maxSteps: number;
+  toolChoice?: ToolChoice;
+  builtinTools?: readonly BuiltinTool[];
+  tools: Readonly<Record<string, ToolDef<z.ZodObject<z.ZodRawShape>, S>>>;
+  state?: () => S;
+  idleTimeoutMs?: number;
+};
+
+// ─── Zod schemas ────────────────────────────────────────────────────────────
+
+/** @internal Zod schema for {@link BuiltinTool}. Exported for reuse in internal schemas. */
+export const BuiltinToolSchema = z.enum(["web_search", "visit_webpage", "fetch_json", "run_code"]);
+
+/** @internal Zod schema for {@link ToolChoice}. Exported for reuse in internal schemas. */
+export const ToolChoiceSchema = z.enum(["auto", "required"]);

package/sdk/utils.test.ts

@@ -0,0 +1,52 @@
+// Copyright 2025 the AAI authors. MIT license.
+import { describe, expect, test } from "vitest";
+import { errorDetail, errorMessage } from "./utils.ts";
+
+describe("errorMessage", () => {
+  test("extracts message from Error instance", () => {
+    expect(errorMessage(new Error("something broke"))).toBe("something broke");
+  });
+
+  test("converts string to string", () => {
+    expect(errorMessage("plain string")).toBe("plain string");
+  });
+
+  test("converts number to string", () => {
+    expect(errorMessage(42)).toBe("42");
+  });
+
+  test("converts null to string", () => {
+    expect(errorMessage(null)).toBe("null");
+  });
+
+  test("converts undefined to string", () => {
+    expect(errorMessage(undefined)).toBe("undefined");
+  });
+});
+
+describe("errorDetail", () => {
+  test("returns stack trace when available", () => {
+    const err = new Error("something broke");
+    const result = errorDetail(err);
+    expect(result).toBe(err.stack);
+    expect(result).toContain("something broke");
+  });
+
+  test("returns message when stack is undefined", () => {
+    const err = new Error("no stack");
+    Object.defineProperty(err, "stack", { value: undefined });
+    expect(errorDetail(err)).toBe("no stack");
+  });
+
+  test("converts string to string", () => {
+    expect(errorDetail("plain string")).toBe("plain string");
+  });
+
+  test("converts null to string", () => {
+    expect(errorDetail(null)).toBe("null");
+  });
+
+  test("converts undefined to string", () => {
+    expect(errorDetail(undefined)).toBe("undefined");
+  });
+});

package/sdk/utils.ts

@@ -0,0 +1,20 @@
+// Copyright 2025 the AAI authors. MIT license.
+/** Shared utility functions. */
+
+/** Extract an error message from an unknown thrown value. */
+export function errorMessage(err: unknown): string {
+  return err instanceof Error ? err.message : String(err);
+}
+
+/** Extract a detailed error string (message + stack) for diagnostic logging. */
+export function errorDetail(err: unknown): string {
+  if (err instanceof Error) {
+    return err.stack ?? err.message;
+  }
+  return String(err);
+}
+
+/** Return a JSON error string for the LLM: `'{"error":"<message>"}'`. */
+export function toolError(message: string): string {
+  return JSON.stringify({ error: message });
+}

package/sdk/ws-upgrade.test.ts

@@ -0,0 +1,48 @@
+// Copyright 2025 the AAI authors. MIT license.
+
+import { describe, expect, it } from "vitest";
+import { parseWsUpgradeParams } from "./ws-upgrade.ts";
+
+describe("parseWsUpgradeParams", () => {
+  it("returns defaults for URL with no query params", () => {
+    const result = parseWsUpgradeParams("/websocket");
+    expect(result).toEqual({ resumeFrom: undefined, skipGreeting: false });
+  });
+
+  it("extracts sessionId and sets skipGreeting", () => {
+    const result = parseWsUpgradeParams("/ws?sessionId=abc-123");
+    expect(result.resumeFrom).toBe("abc-123");
+    expect(result.skipGreeting).toBe(true);
+  });
+
+  it("sets skipGreeting when resume param is present", () => {
+    const result = parseWsUpgradeParams("/ws?resume=1");
+    expect(result.resumeFrom).toBeUndefined();
+    expect(result.skipGreeting).toBe(true);
+  });
+
+  it("sessionId takes precedence for resumeFrom", () => {
+    const result = parseWsUpgradeParams("/ws?resume=1&sessionId=sess-42");
+    expect(result.resumeFrom).toBe("sess-42");
+    expect(result.skipGreeting).toBe(true);
+  });
+
+  it("handles URL with no query string", () => {
+    const result = parseWsUpgradeParams("/websocket");
+    expect(result.resumeFrom).toBeUndefined();
+    expect(result.skipGreeting).toBe(false);
+  });
+
+  it("handles full URL with query params", () => {
+    const result = parseWsUpgradeParams("ws://localhost:3000/websocket?sessionId=s1");
+    expect(result.resumeFrom).toBe("s1");
+    expect(result.skipGreeting).toBe(true);
+  });
+
+  it("handles empty sessionId", () => {
+    const result = parseWsUpgradeParams("/ws?sessionId=");
+    // Empty string from URLSearchParams.get is truthy for ?? check
+    expect(result.resumeFrom).toBe("");
+    expect(result.skipGreeting).toBe(true);
+  });
+});

package/sdk/ws-upgrade.ts

@@ -0,0 +1,13 @@
+// Copyright 2025 the AAI authors. MIT license.
+
+/** Parse WebSocket upgrade query params into session start options. */
+export function parseWsUpgradeParams(rawUrl: string): {
+  resumeFrom?: string;
+  skipGreeting: boolean;
+} {
+  const search = rawUrl.includes("?") ? (rawUrl.split("?")[1] ?? "") : "";
+  const params = new URLSearchParams(search);
+  const resumeFrom = params.get("sessionId") ?? undefined;
+  const skipGreeting = params.has("resume") || resumeFrom !== undefined;
+  return resumeFrom !== undefined ? { resumeFrom, skipGreeting } : { skipGreeting };
+}

package/tsconfig.build.json

@@ -0,0 +1,14 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": ".",
+    "noEmit": false,
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "incremental": false,
+    "allowImportingTsExtensions": false,
+    "rewriteRelativeImportExtensions": true
+  },
+  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/_test-utils.ts", "vitest*.config.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "incremental": true,
+    "tsBuildInfoFile": "../../.tsbuildinfo/aai.tsbuildinfo",
+    "types": ["node"]
+  },
+  "include": ["./**/*.ts"],
+  "exclude": ["node_modules", "dist", "**/__snapshots__"]
+}

package/tsdown.config.ts

@@ -0,0 +1,26 @@
+import { readFileSync } from "node:fs";
+import { defineConfig } from "tsdown";
+
+// Derive build entries from package.json exports so they can never drift.
+const pkg = JSON.parse(readFileSync("package.json", "utf-8"));
+const entry = [
+  ...new Set(
+    Object.values(pkg.exports as Record<string, Record<string, string>>)
+      .filter(
+        (v): v is { "@dev/source": string } =>
+          typeof v === "object" && typeof v["@dev/source"] === "string",
+      )
+      .map((v) => v["@dev/source"].replace(/^\.\//, "")),
+  ),
+];
+
+export default defineConfig({
+  entry,
+  format: "esm",
+  platform: "node",
+  target: "node22",
+  outDir: "dist",
+  dts: false,
+  outExtensions: () => ({ js: ".js" }),
+  deps: { neverBundle: [/^[^./]/] },
+});

package/vitest.config.ts

@@ -0,0 +1,17 @@
+import { defineConfig } from "vitest/config";
+import { sharedConfig } from "../../vitest.shared.ts";
+
+export default defineConfig({
+  ...sharedConfig,
+  test: {
+    restoreMocks: true,
+    include: ["**/*.test.ts"],
+    exclude: [
+      "**/pentest.test.ts",
+      "**/run-code-sandbox.test.ts",
+      "**/integration.test.ts",
+      "node_modules",
+      "dist",
+    ],
+  },
+});

package/dist/host/_test-utils.d.ts

@@ -1,73 +0,0 @@
-import type { AgentConfig } from "../isolate/_internal-types.ts";
-import type { ClientSink } from "../isolate/protocol.ts";
-import type { AgentDef, ToolContext, ToolDef } from "../isolate/types.ts";
-import type { S2sEvents, S2sHandle } from "./s2s.ts";
-import type { Session } from "./session.ts";
-import { type S2sSessionOptions } from "./session.ts";
-/** Yield to the microtask queue so pending promises settle. */
-export declare function flush(): Promise<void>;
-export declare function createMockToolContext(overrides?: Partial<ToolContext>): ToolContext;
-export declare function makeTool(overrides?: Partial<ToolDef>): ToolDef;
-export declare function makeAgent(overrides?: Partial<AgentDef>): AgentDef;
-export declare function makeConfig(overrides?: Partial<AgentConfig>): AgentConfig;
-/** Create a stub Session with all methods as vi.fn() spies. */
-export declare function makeStubSession(overrides?: Partial<Session>): Session;
-export type MockS2sHandle = S2sHandle & {
-    _fire: <K extends keyof S2sEvents>(type: K, ...args: Parameters<S2sEvents[K]>) => void;
-};
-/** Create a mock S2sHandle backed by nanoevents. */
-export declare function makeMockHandle(): MockS2sHandle;
-/** Minimal client that tracks events and audio. All methods are vi.fn() spies. */
-export declare function makeClient(): ClientSink & {
-    events: unknown[];
-    audioChunks: Uint8Array[];
-    audioDoneCount: number;
-};
-export declare const silentLogger: {
-    info: (...args: unknown[]) => void;
-    warn: (...args: unknown[]) => void;
-    error: (...args: unknown[]) => void;
-    debug: (...args: unknown[]) => void;
-};
-export declare function makeSessionOpts(overrides?: Partial<S2sSessionOptions>): S2sSessionOptions;
-/** Load a JSON fixture from fixtures/. */
-export declare function loadFixture<T = Record<string, unknown>[]>(name: string): T;
-/**
- * Replay recorded S2S API messages through a MockS2sHandle.
- *
- * Converts raw wire-format JSON (from fixtures/) into typed `_fire()` calls.
- * This is the inverse of `dispatchS2sMessage` in s2s.ts — it translates
- * snake_case API fields to camelCase event payloads.
- *
- * Messages that don't map to an event (audio, `reply.content_part.*`) are skipped.
- */
-export declare function replayFixtureMessages(handle: MockS2sHandle, messages: Record<string, unknown>[]): void;
-/**
- * Create a real Runtime-backed session for fixture replay testing.
- *
- * Uses a real `Runtime` (real tool execution, real hooks) but replaces the
- * S2S WebSocket with a mock handle so fixture messages can be replayed
- * through the full orchestration layer.
- *
- * Exercises: defineAgent → toAgentConfig → tool schemas → Zod arg validation
- * → executeToolCall → session orchestration (reply guards, tool buffering,
- * turnPromise chaining).
- *
- * Call `cleanup()` when done to restore the connectS2s spy.
- */
-export declare function createFixtureSession(agent: AgentDef<any>, opts?: {
-    env?: Record<string, string>;
-}): {
-    session: Session;
-    client: ClientSink & {
-        events: unknown[];
-        audioChunks: Uint8Array[];
-        audioDoneCount: number;
-    };
-    mockHandle: MockS2sHandle;
-    executor: import("./direct-executor.ts").Runtime;
-    /** Replay a fixture file through the session's S2S handle. */
-    replay(fixtureName: string): void;
-    /** Restore the connectS2s spy. Call in afterEach. */
-    cleanup(): void;
-};

package/dist/host/direct-executor.d.ts

@@ -1,130 +0,0 @@
-/**
- * Agent runtime — the execution engine for voice agents.
- *
- * {@link createRuntime} builds the single execution engine used by both
- * self-hosted servers and the platform sandbox. It wires up tool execution,
- * lifecycle hooks, and session management.
- */
-import { type ExecuteTool, type ToolSchema } from "../isolate/_internal-types.ts";
-import { type AgentHooks } from "../isolate/hooks.ts";
-import type { Kv } from "../isolate/kv.ts";
-import type { ClientSink } from "../isolate/protocol.ts";
-import { type ReadyConfig } from "../isolate/protocol.ts";
-import type { AgentDef, Message, ToolDef } from "../isolate/types.ts";
-import type { Logger, S2SConfig } from "./runtime.ts";
-import type { CreateS2sWebSocket } from "./s2s.ts";
-import { type Session } from "./session.ts";
-import { type SessionWebSocket } from "./ws-handler.ts";
-export type { ExecuteTool } from "../isolate/_internal-types.ts";
-export type ExecuteToolCallOptions = {
-    tool: ToolDef;
-    env: Readonly<Record<string, string>>;
-    state?: Record<string, unknown>;
-    sessionId?: string | undefined;
-    kv?: Kv | undefined;
-    messages?: readonly Message[] | undefined;
-    logger?: Logger | undefined;
-    fetch?: typeof globalThis.fetch | undefined;
-};
-export declare function executeToolCall(name: string, args: Readonly<Record<string, unknown>>, options: ExecuteToolCallOptions): Promise<string>;
-/** Per-session options passed to {@link AgentRuntime.startSession}. */
-export type SessionStartOptions = {
-    skipGreeting?: boolean;
-    resumeFrom?: string;
-    logContext?: Record<string, string>;
-    onOpen?: () => void;
-    onClose?: () => void;
-};
-/**
- * Common interface for agent runtimes.
- *
- * Implemented by {@link createRuntime} and the platform sandbox.
- */
-export type AgentRuntime = {
-    startSession(ws: SessionWebSocket, opts?: SessionStartOptions): void;
-    shutdown(): Promise<void>;
-    readonly readyConfig: ReadyConfig;
-};
-/**
- * Configuration for {@link createRuntime}.
- *
- * Configures the agent, environment, KV store, logging, and S2S connection.
- *
- * @public
- */
-export type RuntimeOptions = {
-    agent: AgentDef<any>;
-    env: Record<string, string>;
-    kv?: Kv | undefined;
-    /** Custom WebSocket factory for the S2S connection (useful for testing). */
-    createWebSocket?: CreateS2sWebSocket | undefined;
-    logger?: Logger | undefined;
-    s2sConfig?: S2SConfig | undefined;
-    /**
-     * Timeout in ms for `session.start()` (S2S connection setup).
-     * Defaults to 10 000 (10 s).
-     */
-    sessionStartTimeoutMs?: number | undefined;
-    /**
-     * Maximum time in milliseconds to wait for sessions to stop during
-     * {@link AgentRuntime.shutdown | shutdown()}. Defaults to `30_000` (30 s).
-     */
-    shutdownTimeoutMs?: number | undefined;
-    /**
-     * Override tool execution. When provided, `createRuntime` skips building
-     * in-process tool definitions and uses this function instead. Used by the
-     * platform sandbox to RPC tool calls to the isolate.
-     */
-    executeTool?: ExecuteTool | undefined;
-    /**
-     * Override lifecycle hooks. When provided, `createRuntime` skips building
-     * in-process hooks and uses these instead. Used by the platform sandbox
-     * to RPC hook calls to the isolate.
-     */
-    hooks?: AgentHooks | undefined;
-    /**
-     * Override tool schemas sent to the S2S API. Required when `executeTool`
-     * is provided (the host doesn't have the tool definitions to derive schemas).
-     */
-    toolSchemas?: ToolSchema[] | undefined;
-    /** System prompt guidance for builtin tools. Passed through in sandbox mode. */
-    toolGuidance?: string[] | undefined;
-};
-/**
- * The agent runtime returned by {@link createRuntime}.
- *
- * Satisfies {@link AgentRuntime} for use by transport code, and also exposes
- * lower-level helpers (`executeTool`, `hooks`, `toolSchemas`,
- * `createSession`) for testing and advanced usage.
- *
- * @public
- */
-export type Runtime = AgentRuntime & {
-    /** Execute a named tool with the given args, returning a JSON result string. */
-    executeTool: ExecuteTool;
-    /** Hookable instance wired to the agent's lifecycle hooks. */
-    hooks: AgentHooks;
-    /** Tool schemas registered with the S2S API (custom + built-in). */
-    toolSchemas: ToolSchema[];
-    /** Create a new voice session for a connected client (lower-level than startSession). */
-    createSession(opts: {
-        id: string;
-        agent: string;
-        client: ClientSink;
-        skipGreeting?: boolean;
-        resumeFrom?: string;
-    }): Session;
-};
-/**
- * Create an agent runtime — the execution engine for a voice agent.
- *
- * Merges built-in and custom tool definitions, builds tool schemas for the
- * S2S API, and wires up lifecycle hooks.
- *
- * @param opts - Runtime configuration. See {@link RuntimeOptions}.
- * @returns A {@link Runtime} with tool execution, hook invocation,
- *   schemas, and session management.
- *
- * @public
- */
-export declare function createRuntime(opts: RuntimeOptions): Runtime;

package/dist/host/index.d.ts

@@ -1,19 +0,0 @@
-/**
- * Host barrel — re-exports all SDK internals for use by the platform
- * server (`aai-server`) and CLI. **Not a public API.**
- *
- * Includes the full isolate-safe kernel plus host-only modules that
- * depend on Node.js APIs (server, executor, S2S, etc.).
- *
- * Consumer packages should import from the top-level `@alexkroman1/aai`
- * entry, `./server`, `./types`, `./kv`, `./protocol`, or `./testing`.
- */
-export * from "../isolate/index.ts";
-export * from "./_runtime-conformance.ts";
-export * from "./builtin-tools.ts";
-export * from "./direct-executor.ts";
-export * from "./runtime.ts";
-export * from "./s2s.ts";
-export * from "./session.ts";
-export * from "./unstorage-kv.ts";
-export * from "./ws-handler.ts";