@alexkroman1/aai 1.3.2 → 1.4.0

package/dist/host/runtime-barrel.js

@@ -1,15 +1,22 @@
-import { _ as TOOL_EXECUTION_TIMEOUT_MS, a as DEFAULT_SHUTDOWN_TIMEOUT_MS, c as FETCH_TIMEOUT_MS, d as MAX_PAGE_CHARS, f as MAX_TOOL_RESULT_CHARS, g as RUN_CODE_TIMEOUT_MS, h as PIPELINE_FLUSH_TIMEOUT_MS, l as MAX_HTML_BYTES, m as MAX_WS_PAYLOAD_BYTES, o as DEFAULT_STT_SAMPLE_RATE, p as MAX_VALUE_SIZE, s as DEFAULT_TTS_SAMPLE_RATE, t as AGENT_CSP } from "../constants-BL3nvg4I.js";
-import { r as DEFAULT_SYSTEM_PROMPT } from "../types-Cfx_4QDK.js";
+import { r as DEFAULT_SYSTEM_PROMPT } from "../types-KUgezM6u.js";
+import { _ as TOOL_EXECUTION_TIMEOUT_MS, a as DEFAULT_SHUTDOWN_TIMEOUT_MS, c as FETCH_TIMEOUT_MS, d as MAX_PAGE_CHARS, f as MAX_TOOL_RESULT_CHARS, g as RUN_CODE_TIMEOUT_MS, h as PIPELINE_FLUSH_TIMEOUT_MS, l as MAX_HTML_BYTES, m as MAX_WS_PAYLOAD_BYTES, o as DEFAULT_STT_SAMPLE_RATE, p as MAX_VALUE_SIZE, s as DEFAULT_TTS_SAMPLE_RATE, t as AGENT_CSP } from "../constants-C2nirZUI.js";
 import { i as toolError, n as errorDetail, r as errorMessage, t as parseWsUpgradeParams } from "../ws-upgrade-BeOQ7fXL.js";
 import { ClientMessageSchema, buildReadyConfig, lenientParse } from "../sdk/protocol.js";
-import { a as toAgentConfig, i as agentToolsToSchemas, n as EMPTY_PARAMS } from "../_internal-types-CoDTiBd1.js";
+import { a as toAgentConfig, c as makeSttError, i as agentToolsToSchemas, l as makeTtsError, n as EMPTY_PARAMS, s as assertProviderTriple } from "../_internal-types-3p3OJZPb.js";
+import { t as ANTHROPIC_KIND } from "../anthropic-BrUCPKUc.js";
+import { t as ASSEMBLYAI_KIND } from "../assemblyai-Cxg9eobY.js";
+import { t as CARTESIA_KIND } from "../cartesia-DwDk2tEu.js";
 import { z } from "zod";
 import { convert } from "html-to-text";
 import vm from "node:vm";
 import pTimeout from "p-timeout";
 import { createStorage, prefixStorage } from "unstorage";
 import { jsonSchema, stepCountIs, streamText, tool } from "ai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { AssemblyAI } from "assemblyai";
 import { createNanoEvents } from "nanoevents";
+import { randomUUID } from "node:crypto";
+import { Cartesia } from "@cartesia/cartesia-js";
 import WsWebSocket, { WebSocketServer } from "ws";
 import fs from "node:fs";
 import http from "node:http";
@@ -916,6 +923,305 @@ function createPipelineSession(opts) {
 	};
 }
 //#endregion
+//#region host/providers/stt/assemblyai.ts
+/**
+* AssemblyAI Universal-Streaming STT opener (host-only).
+*
+* The user-facing descriptor factory (`assemblyAI(...)`) lives in
+* `sdk/providers/stt/assemblyai.ts`. This module is the host-side
+* counterpart: it takes the descriptor options + an API key and
+* returns an {@link SttOpener} that the pipeline session drives.
+*
+* Default model: `"u3pro-rt"` (Universal-3 Pro Real-Time). The adapter
+* maps that to the SDK's `"u3-rt-pro"` `speechModel` value; any other
+* string is forwarded verbatim.
+*/
+/** Translate the descriptor's model alias to the SDK's `speechModel` value. */
+function resolveSpeechModel(model) {
+	if (model === "u3pro-rt") return "u3-rt-pro";
+	return model;
+}
+/** Build an {@link SttOpener} from resolved AssemblyAI descriptor options. */
+function openAssemblyAI(opts = {}) {
+	return {
+		name: "assemblyai",
+		async open(openOpts) {
+			const apiKey = openOpts.apiKey || process.env.ASSEMBLYAI_API_KEY;
+			if (!apiKey) throw makeSttError("stt_auth_failed", "AssemblyAI STT: missing API key. Set ASSEMBLYAI_API_KEY in the agent env.");
+			const client = new AssemblyAI({ apiKey });
+			const speechModel = resolveSpeechModel(opts.model ?? "u3pro-rt");
+			const transcriber = client.streaming.transcriber({
+				sampleRate: openOpts.sampleRate,
+				speechModel,
+				...openOpts.sttPrompt ? { prompt: openOpts.sttPrompt } : {}
+			});
+			const emitter = createNanoEvents();
+			let closed = false;
+			transcriber.on("turn", (event) => {
+				if (closed) return;
+				const text = event.transcript ?? "";
+				if (event.end_of_turn) {
+					if (text.length > 0) emitter.emit("final", text);
+				} else if (text.length > 0) emitter.emit("partial", text);
+			});
+			transcriber.on("error", (err) => {
+				if (closed) return;
+				emitter.emit("error", makeSttError("stt_stream_error", err?.message ?? String(err)));
+			});
+			transcriber.on("close", (code) => {
+				if (closed) return;
+				if (code !== 1e3) emitter.emit("error", makeSttError("stt_stream_error", `socket closed ${code}`));
+			});
+			try {
+				await transcriber.connect();
+			} catch (cause) {
+				throw makeSttError("stt_connect_failed", `AssemblyAI STT: connect failed: ${cause instanceof Error ? cause.message : String(cause)}`);
+			}
+			const close = async () => {
+				if (closed) return;
+				closed = true;
+				try {
+					await transcriber.close();
+				} catch {}
+			};
+			if (openOpts.signal.aborted) close();
+			else openOpts.signal.addEventListener("abort", () => void close(), { once: true });
+			return {
+				sendAudio(pcm) {
+					if (closed) return;
+					const copy = new Uint8Array(pcm.byteLength);
+					copy.set(new Uint8Array(pcm.buffer, pcm.byteOffset, pcm.byteLength));
+					transcriber.sendAudio(copy.buffer);
+				},
+				on(event, fn) {
+					return emitter.on(event, fn);
+				},
+				close,
+				_transcriber: transcriber
+			};
+		}
+	};
+}
+//#endregion
+//#region host/providers/tts/cartesia.ts
+/**
+* Cartesia TTS opener (host-only).
+*
+* The user-facing descriptor factory (`cartesia(...)`) lives in
+* `sdk/providers/tts/cartesia.ts`. This module is the host-side
+* counterpart: it takes the descriptor options + an API key and
+* returns a {@link TtsOpener} that the pipeline session drives.
+*
+* Wraps `@cartesia/cartesia-js`'s `TTSWS` / `TTSWSContext` and normalizes it
+* onto the {@link TtsEvents} contract consumed by the pipeline orchestrator.
+*
+* **Per-turn context lifecycle.** Each `sendText(...)` within the same turn
+* appends to the same Cartesia context. On `flush()` or `cancel()`, a new
+* context is minted for the next turn — so concurrent `cancel({ contextId })`
+* only targets the in-flight turn, never the one that follows.
+*
+* **Audio format.** The adapter requests `raw` / `pcm_s16le` at the
+* negotiated `sampleRate` so it can forward chunks as `Int16Array` with no
+* conversion.
+*/
+/** PCM16 sample rates supported by Cartesia's `raw` output format. */
+const CARTESIA_PCM16_RATES = [
+	8e3,
+	16e3,
+	22050,
+	24e3,
+	44100,
+	48e3
+];
+function assertSupportedSampleRate(rate) {
+	if (CARTESIA_PCM16_RATES.includes(rate)) return rate;
+	throw makeTtsError("tts_connect_failed", `Cartesia TTS: unsupported sample rate ${rate}. Supported: ${CARTESIA_PCM16_RATES.join(", ")}.`);
+}
+/** Build a {@link TtsOpener} from resolved Cartesia descriptor options. */
+function openCartesia(opts) {
+	return {
+		name: "cartesia",
+		async open(openOpts) {
+			const apiKey = openOpts.apiKey || process.env.CARTESIA_API_KEY;
+			if (!apiKey) throw makeTtsError("tts_auth_failed", "Cartesia TTS: missing API key. Set CARTESIA_API_KEY in the agent env.");
+			const sampleRate = assertSupportedSampleRate(openOpts.sampleRate);
+			const model = opts.model ?? "sonic-2";
+			const language = opts.language ?? "en";
+			const client = new Cartesia({ apiKey });
+			let ws;
+			try {
+				ws = await client.tts.websocket();
+			} catch (cause) {
+				throw makeTtsError("tts_connect_failed", `Cartesia TTS: connect failed: ${cause instanceof Error ? cause.message : String(cause)}`);
+			}
+			const emitter = createNanoEvents();
+			let closed = false;
+			/** Mint a fresh context bound to the shared TTSWS connection. */
+			const mintContext = () => ws.context({
+				model_id: model,
+				voice: {
+					mode: "id",
+					id: opts.voice
+				},
+				output_format: {
+					container: "raw",
+					encoding: "pcm_s16le",
+					sample_rate: sampleRate
+				},
+				contextId: randomUUID()
+			});
+			let context = mintContext();
+			/**
+			* `doneEmitted` guards against emitting `done` more than once per turn.
+			* Reset whenever a fresh context is minted (i.e. at turn boundaries).
+			*/
+			let doneEmitted = false;
+			const rotateContext = () => {
+				context = mintContext();
+				doneEmitted = false;
+			};
+			const emitDoneOnce = () => {
+				if (doneEmitted || closed) return;
+				doneEmitted = true;
+				emitter.emit("done");
+			};
+			ws.on("chunk", (event) => {
+				if (closed) return;
+				if (event.context_id !== context.contextId) return;
+				const buf = event.audio;
+				if (!buf || buf.byteLength === 0) return;
+				const evenBytes = buf.byteLength - buf.byteLength % 2;
+				if (evenBytes === 0) return;
+				const pcm = new Int16Array(buf.buffer.slice(buf.byteOffset, buf.byteOffset + evenBytes));
+				emitter.emit("audio", pcm);
+			});
+			ws.on("done", (event) => {
+				if (closed) return;
+				if (event.context_id !== context.contextId) return;
+				emitDoneOnce();
+			});
+			ws.on("error", (err) => {
+				if (closed) return;
+				emitter.emit("error", makeTtsError("tts_stream_error", err?.message ?? String(err)));
+			});
+			const close = async () => {
+				if (closed) return;
+				closed = true;
+				try {
+					ws.close({
+						code: 1e3,
+						reason: "client close"
+					});
+				} catch {}
+			};
+			if (openOpts.signal.aborted) close();
+			else openOpts.signal.addEventListener("abort", () => void close(), { once: true });
+			const baseRequest = {
+				model_id: model,
+				voice: {
+					mode: "id",
+					id: opts.voice
+				},
+				output_format: {
+					container: "raw",
+					encoding: "pcm_s16le",
+					sample_rate: sampleRate
+				},
+				language
+			};
+			const ignoreRejection = (_err) => {};
+			return {
+				sendText(text) {
+					if (closed || text.length === 0) return;
+					context.send({
+						...baseRequest,
+						transcript: text,
+						continue: true
+					}).catch(ignoreRejection);
+				},
+				flush() {
+					if (closed) return;
+					context.send({
+						...baseRequest,
+						transcript: "",
+						continue: false
+					}).catch(ignoreRejection);
+					queueMicrotask(emitDoneOnce);
+					rotateContext();
+				},
+				cancel() {
+					if (closed) return;
+					context.cancel().catch(ignoreRejection);
+					emitDoneOnce();
+					rotateContext();
+				},
+				on(event, fn) {
+					return emitter.on(event, fn);
+				},
+				close,
+				_ws: ws,
+				_currentContextId: () => context.contextId
+			};
+		}
+	};
+}
+//#endregion
+//#region host/providers/resolve.ts
+/**
+* Descriptor → concrete-provider resolution (host-only).
+*
+* User code (and the server, after extracting config from a bundled agent)
+* holds `SttProvider` / `LlmProvider` / `TtsProvider` **descriptors** —
+* plain `{ kind, options }` data. At session start the runtime calls the
+* resolvers here to turn each descriptor into its openable / callable
+* host-side counterpart, importing the third-party SDK only at that point.
+*
+* The guest sandbox never imports these functions, which is how the agent
+* bundle stays free of `@ai-sdk/anthropic` / `assemblyai` /
+* `@cartesia/cartesia-js`.
+*/
+/**
+* Look up a provider API key: agent env first (set via `aai secret put` or
+* `.env`), then the host's `process.env` as a fallback for self-hosted mode.
+* Returns `""` if neither has it — the caller decides whether that's fatal.
+*/
+function resolveApiKey(envVar, env) {
+	return env[envVar] ?? process.env[envVar] ?? "";
+}
+/** Resolve an {@link SttProvider} descriptor into a host-side opener. */
+function resolveStt(descriptor) {
+	switch (descriptor.kind) {
+		case ASSEMBLYAI_KIND: return openAssemblyAI(descriptor.options);
+		default: throw new Error(`Unknown STT provider kind: "${descriptor.kind}". Supported: ${ASSEMBLYAI_KIND}.`);
+	}
+}
+/** Resolve a {@link TtsProvider} descriptor into a host-side opener. */
+function resolveTts(descriptor) {
+	switch (descriptor.kind) {
+		case CARTESIA_KIND: return openCartesia(descriptor.options);
+		default: throw new Error(`Unknown TTS provider kind: "${descriptor.kind}". Supported: ${CARTESIA_KIND}.`);
+	}
+}
+/**
+* Resolve an {@link LlmProvider} descriptor into a Vercel AI SDK
+* {@link LanguageModel}.
+*
+* The API key is pulled from the agent's env (e.g. `ANTHROPIC_API_KEY`).
+* Missing keys throw here — the pipeline session would fail on first
+* `streamText` call otherwise, and the error is clearer at construction.
+*/
+function resolveLlm(descriptor, env) {
+	switch (descriptor.kind) {
+		case ANTHROPIC_KIND: {
+			const options = descriptor.options;
+			const apiKey = resolveApiKey("ANTHROPIC_API_KEY", env);
+			if (!apiKey) throw new Error("Anthropic LLM: missing API key. Set ANTHROPIC_API_KEY in the agent env.");
+			return createAnthropic({ apiKey })(options.model);
+		}
+		default: throw new Error(`Unknown LLM provider kind: "${descriptor.kind}". Supported: ${ANTHROPIC_KIND}.`);
+	}
+}
+//#endregion
 //#region host/s2s.ts
 const uint8ToBase64 = (bytes) => Buffer.from(bytes).toString("base64");
 const base64ToUint8 = (base64) => new Uint8Array(Buffer.from(base64, "base64"));
@@ -1727,28 +2033,27 @@ function wireSessionSocket(ws, opts) {
 //#endregion
 //#region host/runtime.ts
 /**
-* 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.
+* Distinguish a descriptor (`{ kind, options }`) from an already-resolved
+* opener / `LanguageModel`. The production path always passes descriptors;
+* openers are a test escape hatch (fakes in `_pipeline-test-fakes.ts`).
+* STT/TTS openers are identified by the `open` method, `LanguageModel` by
+* its `specificationVersion` field — both absent on descriptors.
 */
+function resolveSttIfDescriptor(value) {
+	return "open" in value ? value : resolveStt(value);
+}
+function resolveTtsIfDescriptor(value) {
+	return "open" in value ? value : resolveTts(value);
+}
+function resolveLlmIfDescriptor(value, env) {
+	if (typeof value === "string") return value;
+	return "specificationVersion" in value ? value : resolveLlm(value, env);
+}
 /** Create an in-memory KV store (default for self-hosted). */
 function createLocalKv() {
 	return createUnstorageKv({ storage: createStorage() });
 }
 /**
-* Resolve an API key host-side for pipeline providers.
-*
-* Checks the agent's declared env first, then the host process env as a
-* fallback. Returns `""` when absent — pipeline providers surface a clear
-* `MissingCredentialsError` via their `open()` that the orchestrator
-* converts to a `session.error` wire event.
-*/
-function resolveApiKey(envVar, env) {
-	return env[envVar] ?? process.env[envVar] ?? "";
-}
-/**
 * Create an agent runtime — the execution engine for a voice agent.
 *
 * Merges built-in and custom tool definitions, builds tool schemas for the
@@ -1762,9 +2067,7 @@ function resolveApiKey(envVar, env) {
 */
 function createRuntime(opts) {
 	const { agent, env, kv = createLocalKv(), createWebSocket, logger = consoleLogger, s2sConfig = DEFAULT_S2S_CONFIG, sessionStartTimeoutMs, shutdownTimeoutMs = DEFAULT_SHUTDOWN_TIMEOUT_MS } = opts;
-	const providerCount = (opts.stt != null ? 1 : 0) + (opts.llm != null ? 1 : 0) + (opts.tts != null ? 1 : 0);
-	if (providerCount !== 0 && providerCount !== 3) throw new Error("stt, llm, and tts must be set together");
-	const mode = providerCount === 3 ? "pipeline" : "s2s";
+	const mode = assertProviderTriple(opts.stt, opts.llm, opts.tts);
 	const agentConfig = toAgentConfig(agent);
 	const sessions = /* @__PURE__ */ new Map();
 	const sinkMap = /* @__PURE__ */ new Map();
@@ -1827,28 +2130,28 @@ function createRuntime(opts) {
 			});
 		};
 	}
+	const pipelineProviders = mode === "pipeline" ? {
+		stt: resolveSttIfDescriptor(opts.stt),
+		llm: resolveLlmIfDescriptor(opts.llm, env),
+		tts: resolveTtsIfDescriptor(opts.tts)
+	} : null;
 	function createSession(sessionOpts) {
 		sinkMap.set(sessionOpts.id, sessionOpts.client);
-		if (mode === "pipeline") {
-			const stt = opts.stt;
-			const llm = opts.llm;
-			const tts = opts.tts;
-			return createPipelineSession({
-				id: sessionOpts.id,
-				agent: sessionOpts.agent,
-				client: sessionOpts.client,
-				agentConfig,
-				toolSchemas,
-				toolGuidance,
-				executeTool,
-				stt,
-				llm,
-				tts,
-				sttApiKey: resolveApiKey("ASSEMBLYAI_API_KEY", env),
-				ttsApiKey: resolveApiKey("CARTESIA_API_KEY", env),
-				logger
-			});
-		}
+		if (pipelineProviders) return createPipelineSession({
+			id: sessionOpts.id,
+			agent: sessionOpts.agent,
+			client: sessionOpts.client,
+			agentConfig,
+			toolSchemas,
+			toolGuidance,
+			executeTool,
+			stt: pipelineProviders.stt,
+			llm: pipelineProviders.llm,
+			tts: pipelineProviders.tts,
+			sttApiKey: resolveApiKey("ASSEMBLYAI_API_KEY", env),
+			ttsApiKey: resolveApiKey("CARTESIA_API_KEY", env),
+			logger
+		});
 		const apiKey = env.ASSEMBLYAI_API_KEY ?? "";
 		return createS2sSession({
 			id: sessionOpts.id,

package/dist/host/runtime.d.ts

@@ -5,11 +5,12 @@
  * self-hosted servers and the platform sandbox. It wires up tool execution,
  * lifecycle hooks, and session management.
  */
+import type { LanguageModel } from "ai";
 import { type ToolSchema } from "../sdk/_internal-types.ts";
 import type { Kv } from "../sdk/kv.ts";
 import type { ClientSink } from "../sdk/protocol.ts";
 import { type ReadyConfig } from "../sdk/protocol.ts";
-import type { LlmProvider, SttProvider, TtsProvider } from "../sdk/providers.ts";
+import { type LlmProvider, type SttOpener, type SttProvider, type TtsOpener, type TtsProvider } from "../sdk/providers.ts";
 import type { AgentDef } from "../sdk/types.ts";
 import type { Logger, S2SConfig } from "./runtime-config.ts";
 import type { CreateS2sWebSocket } from "./s2s.ts";
@@ -91,21 +92,24 @@ export type RuntimeOptions = {
      */
     fetch?: typeof globalThis.fetch | undefined;
     /**
-     * Pluggable STT provider. Must be set together with `llm` and `tts` to
+     * STT provider. Accepts either a descriptor ({@link SttProvider},
+     * the normal production path) or a pre-resolved {@link SttOpener}
+     * (test escape hatch). Must be set together with `llm` and `tts` to
      * route sessions through the pipeline path; leave all three unset for
      * the default AssemblyAI Streaming Speech-to-Speech (S2S) path.
      */
-    stt?: SttProvider | undefined;
+    stt?: SttProvider | SttOpener | undefined;
     /**
-     * Pluggable LLM provider (Vercel AI SDK `LanguageModel`). Must be set
-     * together with `stt` and `tts` to route sessions through the pipeline path.
+     * LLM provider. Accepts either a descriptor ({@link LlmProvider},
+     * produced by factories like `anthropic(...)`) or a concrete Vercel AI
+     * SDK `LanguageModel` (self-hosted / test escape hatch).
      */
-    llm?: LlmProvider | undefined;
+    llm?: LlmProvider | LanguageModel | undefined;
     /**
-     * Pluggable TTS provider. Must be set together with `stt` and `llm` to
-     * route sessions through the pipeline path.
+     * TTS provider. Accepts either a descriptor ({@link TtsProvider})
+     * or a pre-resolved {@link TtsOpener}.
      */
-    tts?: TtsProvider | undefined;
+    tts?: TtsProvider | TtsOpener | undefined;
 };
 /**
  * The agent runtime returned by {@link createRuntime}.

package/dist/index.js

@@ -1,95 +1,6 @@
-import { _ as TOOL_EXECUTION_TIMEOUT_MS, a as DEFAULT_SHUTDOWN_TIMEOUT_MS, c as FETCH_TIMEOUT_MS, d as MAX_PAGE_CHARS, f as MAX_TOOL_RESULT_CHARS, g as RUN_CODE_TIMEOUT_MS, h as PIPELINE_FLUSH_TIMEOUT_MS, i as DEFAULT_SESSION_START_TIMEOUT_MS, l as MAX_HTML_BYTES, m as MAX_WS_PAYLOAD_BYTES, n as DEFAULT_IDLE_TIMEOUT_MS, o as DEFAULT_STT_SAMPLE_RATE, p as MAX_VALUE_SIZE, r as DEFAULT_MAX_HISTORY, s as DEFAULT_TTS_SAMPLE_RATE, t as AGENT_CSP, u as MAX_MESSAGE_BUFFER_SIZE, v as WS_OPEN } from "./constants-BL3nvg4I.js";
-import { i as ToolChoiceSchema, n as DEFAULT_GREETING, r as DEFAULT_SYSTEM_PROMPT, t as BuiltinToolSchema } from "./types-Cfx_4QDK.js";
+import { a as matchesAllowedHost, i as ToolChoiceSchema, n as DEFAULT_GREETING, o as validateAllowedHostPattern, r as DEFAULT_SYSTEM_PROMPT, t as BuiltinToolSchema } from "./types-KUgezM6u.js";
+import { _ as TOOL_EXECUTION_TIMEOUT_MS, a as DEFAULT_SHUTDOWN_TIMEOUT_MS, c as FETCH_TIMEOUT_MS, d as MAX_PAGE_CHARS, f as MAX_TOOL_RESULT_CHARS, g as RUN_CODE_TIMEOUT_MS, h as PIPELINE_FLUSH_TIMEOUT_MS, i as DEFAULT_SESSION_START_TIMEOUT_MS, l as MAX_HTML_BYTES, m as MAX_WS_PAYLOAD_BYTES, n as DEFAULT_IDLE_TIMEOUT_MS, o as DEFAULT_STT_SAMPLE_RATE, p as MAX_VALUE_SIZE, r as DEFAULT_MAX_HISTORY, s as DEFAULT_TTS_SAMPLE_RATE, t as AGENT_CSP, u as MAX_MESSAGE_BUFFER_SIZE, v as WS_OPEN } from "./constants-C2nirZUI.js";
 import { i as toolError, n as errorDetail, r as errorMessage, t as parseWsUpgradeParams } from "./ws-upgrade-BeOQ7fXL.js";
-//#region sdk/allowed-hosts.ts
-/**
-* Allowlist matching for outbound host validation.
-*
-* Used at deploy time (manifest validation) and at runtime (SSRF enforcement)
-* to restrict which external hosts an agent is permitted to contact.
-*
-* Lives in sdk/ because it has zero Node.js dependencies and can run in any
-* environment (browser, Deno, Node.js sandboxes).
-*/
-/** Private/special-use TLDs that must never appear in allowedHosts patterns. */
-const BLOCKED_TLDS = [
-	"local",
-	"internal",
-	"localhost"
-];
-/**
-* Regex that matches an IPv4 address (four decimal octets separated by dots).
-* Anchored so partial matches like "192.168.1.1.example.com" don't trigger it.
-*/
-const IPV4_RE = /^(\d{1,3}\.){3}\d{1,3}$/;
-function fail(reason) {
-	return {
-		valid: false,
-		reason
-	};
-}
-function checkStructural(pattern) {
-	if (pattern === "") return fail("Pattern must not be empty.");
-	if (pattern.includes("://")) return fail("Pattern must not include a protocol (e.g. remove 'https://').");
-	if (pattern.includes("/")) return fail("Pattern must not include a path component (remove '/').");
-	if (pattern.includes("?")) return fail("Pattern must not include a query string (remove '?').");
-	if (pattern.startsWith("[") || pattern.includes("::")) return fail("IP address literals are not allowed in allowedHosts patterns.");
-	if (pattern.includes(":")) return fail("Pattern must not include a port number (e.g. remove ':8080').");
-	return null;
-}
-function checkWildcard(pattern) {
-	if (!pattern.includes("*")) return null;
-	if (pattern === "*" || pattern === "**") return fail("Bare wildcard '*' is not allowed. Use '*.example.com' to allow all subdomains.");
-	if (pattern.indexOf("*") !== 0 || pattern[1] !== ".") return fail("Wildcard '*' may only appear as the leading segment (e.g. '*.example.com').");
-	if (pattern.lastIndexOf("*") !== 0) return fail("Only a single leading wildcard segment is supported.");
-	return null;
-}
-function checkHostPart(hostPart) {
-	if (IPV4_RE.test(hostPart)) return fail("IP address literals are not allowed in allowedHosts patterns.");
-	const tld = hostPart.split(".").at(-1)?.toLowerCase() ?? "";
-	if (BLOCKED_TLDS.includes(tld)) return fail(`Patterns ending in '.${tld}' are not allowed (private/special-use TLD).`);
-	return null;
-}
-/**
-* Validate a single `allowedHosts` pattern at deploy time.
-*
-* Returns `{ valid: true }` for acceptable patterns or
-* `{ valid: false; reason: string }` with a human-readable rejection reason.
-*/
-function validateAllowedHostPattern(pattern) {
-	const structural = checkStructural(pattern);
-	if (structural !== null) return structural;
-	const wildcard = checkWildcard(pattern);
-	if (wildcard !== null) return wildcard;
-	const hostCheck = checkHostPart(pattern.startsWith("*.") ? pattern.slice(2) : pattern);
-	if (hostCheck !== null) return hostCheck;
-	return { valid: true };
-}
-/**
-* Test whether `hostname` matches any pattern in `patterns`.
-*
-* - Exact match is case-insensitive; trailing dots on the hostname are stripped.
-* - Wildcard pattern `*.example.com` matches any hostname ending with
-*   `.example.com` (one or more labels), but does NOT match `example.com` itself.
-* - A port suffix on `hostname` (e.g. `api.example.com:8080`) is stripped before
-*   matching.
-* - Returns `false` when `patterns` is empty.
-*/
-function matchesAllowedHost(hostname, patterns) {
-	if (patterns.length === 0) return false;
-	const portIndex = hostname.lastIndexOf(":");
-	let host = portIndex !== -1 && !hostname.includes("[") ? hostname.slice(0, portIndex) : hostname;
-	host = host.toLowerCase().replace(/\.$/, "");
-	for (const pattern of patterns) {
-		const p = pattern.toLowerCase();
-		if (p.startsWith("*.")) {
-			const suffix = p.slice(1);
-			if (host.endsWith(suffix) && host.length > suffix.length) return true;
-		} else if (host === p) return true;
-	}
-	return false;
-}
-//#endregion
 //#region sdk/define.ts
 /**
 * Define a tool with typed parameters and execute function.

package/dist/sdk/_internal-types.d.ts

@@ -5,6 +5,7 @@
  */
 import type { JSONSchema7 } from "json-schema";
 import { z } from "zod";
+import { type LlmProvider, type SttProvider, type TtsProvider } from "./providers.ts";
 import type { Message } from "./types.ts";
 import { type ToolDef } from "./types.ts";
 /**
@@ -51,6 +52,22 @@ export declare const AgentConfigSchema: z.ZodObject<{
         run_code: "run_code";
     }>>>>;
     idleTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    stt: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodString;
+        options: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>;
+    llm: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodString;
+        options: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>;
+    tts: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodString;
+        options: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        s2s: "s2s";
+        pipeline: "pipeline";
+    }>>;
 }, z.core.$strip>;
 /** Serializable agent configuration — derived from {@link AgentConfigSchema}. */
 export type AgentConfig = z.infer<typeof AgentConfigSchema>;
@@ -68,8 +85,17 @@ export interface AgentConfigSource {
     toolChoice?: AgentConfig["toolChoice"] | undefined;
     builtinTools?: Readonly<AgentConfig["builtinTools"]> | undefined;
     idleTimeoutMs?: number | undefined;
+    stt?: SttProvider | undefined;
+    llm?: LlmProvider | undefined;
+    tts?: TtsProvider | undefined;
 }
-/** Extract the serializable {@link AgentConfig} subset from a source object. */
+/**
+ * Extract the serializable {@link AgentConfig} subset from a source object.
+ *
+ * When `stt`, `llm`, and `tts` descriptors are present they are all three
+ * required (or none) — enforced here so the server can trust the config.
+ * `mode` is derived from their presence.
+ */
 export declare function toAgentConfig(src: AgentConfigSource): AgentConfig;
 /**
  * Zod schema for serialized tool definitions sent over the wire.

package/dist/sdk/manifest-barrel.d.ts

@@ -4,3 +4,5 @@
  * Used by aai-cli (bundler) and aai-server (rpc-schemas).
  */
 export { type AgentConfig, AgentConfigSchema, type AgentConfigSource, agentToolsToSchemas, EMPTY_PARAMS, type ExecuteTool, type ToolSchema, ToolSchemaSchema, toAgentConfig, } from "./_internal-types.ts";
+export { ProviderDescriptorSchema } from "./manifest.ts";
+export { assertProviderTriple, type SessionMode } from "./providers.ts";

package/dist/sdk/manifest-barrel.js

@@ -1,2 +1,2 @@
-import { a as toAgentConfig, i as agentToolsToSchemas, n as EMPTY_PARAMS, r as ToolSchemaSchema, t as AgentConfigSchema } from "../_internal-types-CoDTiBd1.js";
-export { AgentConfigSchema, EMPTY_PARAMS, ToolSchemaSchema, agentToolsToSchemas, toAgentConfig };
+import { a as toAgentConfig, i as agentToolsToSchemas, n as EMPTY_PARAMS, o as ProviderDescriptorSchema, r as ToolSchemaSchema, s as assertProviderTriple, t as AgentConfigSchema } from "../_internal-types-3p3OJZPb.js";
+export { AgentConfigSchema, EMPTY_PARAMS, ProviderDescriptorSchema, ToolSchemaSchema, agentToolsToSchemas, assertProviderTriple, toAgentConfig };

package/dist/sdk/manifest.d.ts

@@ -4,7 +4,8 @@
  * Flows from build → host → sdk. Validated via Zod at the boundary,
  * then used as a plain typed object throughout the runtime.
  */
-import type { LlmProvider, SttProvider, TtsProvider } from "./providers.ts";
+import { z } from "zod";
+import { type LlmProvider, type SessionMode, type SttProvider, type TtsProvider } from "./providers.ts";
 /**
  * Tool definition as it appears in the serialized manifest JSON.
  *
@@ -60,8 +61,18 @@ export type Manifest = {
      * - `"s2s"` (default): AssemblyAI Streaming Speech-to-Speech path (no stt/llm/tts set).
      * - `"pipeline"`: pluggable STT → LLM → TTS path (stt + llm + tts all set).
      */
-    mode: "s2s" | "pipeline";
+    mode: SessionMode;
 };
+/**
+ * Provider descriptor — a `{ kind, options }` pair produced by factories
+ * like `assemblyAI(...)` / `anthropic(...)` / `cartesia(...)`. Kept
+ * deliberately generic at the schema layer: kind-specific validation lives
+ * in the host-side resolver, which knows what each adapter expects.
+ */
+export declare const ProviderDescriptorSchema: z.ZodObject<{
+    kind: z.ZodString;
+    options: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
 /**
  * Parse and normalize a raw agent manifest, applying defaults for all
  * optional fields. Input is typically the JSON from a bundled agent.ts.