@alexkroman1/aai 1.3.2 → 1.4.0

package/sdk/_internal-types.ts

@@ -7,6 +7,13 @@
 
 import type { JSONSchema7 } from "json-schema";
 import { z } from "zod";
+import { ProviderDescriptorSchema } from "./manifest.ts";
+import {
+  assertProviderTriple,
+  type LlmProvider,
+  type SttProvider,
+  type TtsProvider,
+} from "./providers.ts";
 import type { Message } from "./types.ts";
 import { BuiltinToolSchema, ToolChoiceSchema, type ToolDef } from "./types.ts";
 
@@ -56,6 +63,10 @@ export const AgentConfigSchema = z.object({
   toolChoice: ToolChoiceSchema.optional(),
   builtinTools: z.array(BuiltinToolSchema).readonly().optional(),
   idleTimeoutMs: z.number().nonnegative().optional(),
+  stt: ProviderDescriptorSchema.optional(),
+  llm: ProviderDescriptorSchema.optional(),
+  tts: ProviderDescriptorSchema.optional(),
+  mode: z.enum(["s2s", "pipeline"]).optional(),
 });
 
 /** Serializable agent configuration — derived from {@link AgentConfigSchema}. */
@@ -75,9 +86,18 @@ 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 function toAgentConfig(src: AgentConfigSource): AgentConfig {
   const config: AgentConfig = {
     name: src.name,
@@ -89,6 +109,13 @@ export function toAgentConfig(src: AgentConfigSource): AgentConfig {
   if (src.toolChoice !== undefined) config.toolChoice = src.toolChoice;
   if (src.builtinTools) config.builtinTools = [...src.builtinTools];
   if (src.idleTimeoutMs !== undefined) config.idleTimeoutMs = src.idleTimeoutMs;
+
+  config.mode = assertProviderTriple(src.stt, src.llm, src.tts);
+  if (config.mode === "pipeline") {
+    config.stt = src.stt;
+    config.llm = src.llm;
+    config.tts = src.tts;
+  }
   return config;
 }
 

package/sdk/define.test.ts

@@ -3,7 +3,9 @@ import { describe, expect, test } from "vitest";
 import { z } from "zod";
 import { agent, tool } from "./define.ts";
 import { parseManifest } from "./manifest.ts";
-import type { LlmProvider, SttProvider, TtsProvider } from "./providers.ts";
+import { anthropic } from "./providers/llm/anthropic.ts";
+import { assemblyAI } from "./providers/stt/assemblyai.ts";
+import { cartesia } from "./providers/tts/cartesia.ts";
 
 describe("tool()", () => {
   test("returns the definition unchanged", () => {
@@ -58,9 +60,9 @@ describe("agent()", () => {
   });
 
   test("preserves stt/llm/tts providers on the returned def", () => {
-    const stt = { name: "fake-stt", open: async () => ({}) } as unknown as SttProvider;
-    const tts = { name: "fake-tts", open: async () => ({}) } as unknown as TtsProvider;
-    const llm = {} as LlmProvider;
+    const stt = assemblyAI({ model: "u3pro-rt" });
+    const tts = cartesia({ voice: "v" });
+    const llm = anthropic({ model: "claude-haiku-4-5" });
     const def = agent({ name: "t", systemPrompt: "p", stt, llm, tts });
     expect(def.stt).toBe(stt);
     expect(def.llm).toBe(llm);
@@ -68,15 +70,15 @@ describe("agent()", () => {
   });
 
   test("stt/llm/tts flow through parseManifest to mode 'pipeline'", () => {
-    const stt = { name: "fake-stt", open: async () => ({}) } as unknown as SttProvider;
-    const tts = { name: "fake-tts", open: async () => ({}) } as unknown as TtsProvider;
-    const llm = {} as LlmProvider;
+    const stt = assemblyAI({ model: "u3pro-rt" });
+    const tts = cartesia({ voice: "v" });
+    const llm = anthropic({ model: "claude-haiku-4-5" });
     const def = agent({ name: "t", systemPrompt: "p", stt, llm, tts });
     const parsed = parseManifest(def);
     expect(parsed.mode).toBe("pipeline");
-    expect(parsed.stt).toBe(stt);
-    expect(parsed.llm).toBe(llm);
-    expect(parsed.tts).toBe(tts);
+    expect(parsed.stt).toStrictEqual(stt);
+    expect(parsed.llm).toStrictEqual(llm);
+    expect(parsed.tts).toStrictEqual(tts);
   });
 
   test("agent without providers resolves to mode 's2s'", () => {

package/sdk/manifest-barrel.ts

@@ -16,3 +16,5 @@ export {
   ToolSchemaSchema,
   toAgentConfig,
 } from "./_internal-types.ts";
+export { ProviderDescriptorSchema } from "./manifest.ts";
+export { assertProviderTriple, type SessionMode } from "./providers.ts";

package/sdk/manifest.test.ts

@@ -4,6 +4,9 @@ import { describe, expect, expectTypeOf, test } from "vitest";
 import { type Manifest, parseManifest } from "./manifest.ts";
 import type { AgentConfig, ToolSchema } from "./manifest-barrel.ts";
 import { agentToolsToSchemas, toAgentConfig } from "./manifest-barrel.ts";
+import { anthropic } from "./providers/llm/anthropic.ts";
+import { assemblyAI } from "./providers/stt/assemblyai.ts";
+import { cartesia } from "./providers/tts/cartesia.ts";
 
 describe("parseManifest", () => {
   test("minimal manifest requires only name", () => {
@@ -164,9 +167,9 @@ describe("manifest type contracts", () => {
 });
 
 describe("parseManifest — mode classification", () => {
-  const stubStt = { name: "stub-stt", open: async () => ({}) };
-  const stubTts = { name: "stub-tts", open: async () => ({}) };
-  const stubLlm = { modelId: "stub-llm" };
+  const stubStt = assemblyAI({ model: "u3pro-rt" });
+  const stubTts = cartesia({ voice: "v" });
+  const stubLlm = anthropic({ model: "claude-haiku-4-5" });
 
   test("no stt/llm/tts ⇒ mode: 's2s'", () => {
     const parsed = parseManifest({

package/sdk/manifest.ts

@@ -8,7 +8,13 @@
 
 import { z } from "zod";
 import { validateAllowedHostPattern } from "./allowed-hosts.ts";
-import type { LlmProvider, SttProvider, TtsProvider } from "./providers.ts";
+import {
+  assertProviderTriple,
+  type LlmProvider,
+  type SessionMode,
+  type SttProvider,
+  type TtsProvider,
+} from "./providers.ts";
 import { BuiltinToolSchema, DEFAULT_GREETING, DEFAULT_SYSTEM_PROMPT } from "./types.ts";
 
 /**
@@ -67,7 +73,7 @@ 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;
 };
 
 const ToolManifestSchema = z.object({
@@ -75,6 +81,17 @@ const ToolManifestSchema = z.object({
   parameters: z.record(z.string(), z.unknown()).optional(),
 });
 
+/**
+ * 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 const ProviderDescriptorSchema = z.object({
+  kind: z.string().min(1),
+  options: z.record(z.string(), z.unknown()),
+});
+
 const ManifestSchema = z.object({
   name: z.string().min(1),
   systemPrompt: z.string().optional(),
@@ -101,6 +118,9 @@ const ManifestSchema = z.object({
         }
       }
     }),
+  stt: ProviderDescriptorSchema.optional(),
+  llm: ProviderDescriptorSchema.optional(),
+  tts: ProviderDescriptorSchema.optional(),
 });
 
 /**
@@ -114,19 +134,7 @@ const ManifestSchema = z.object({
  */
 export function parseManifest(input: unknown): Manifest {
   const parsed = ManifestSchema.parse(input);
-  // stt/llm/tts are runtime objects (functions/classes) that can't be
-  // validated by the JSON-oriented Zod schema. Pull them straight from
-  // the raw input and enforce all-or-nothing presence here.
-  const raw = (input ?? {}) as {
-    stt?: SttProvider;
-    llm?: LlmProvider;
-    tts?: TtsProvider;
-  };
-  const providerCount = [raw.stt, raw.llm, raw.tts].filter((x) => x != null).length;
-  if (providerCount !== 0 && providerCount !== 3) {
-    throw new Error("stt, llm, and tts must be set together");
-  }
-  const mode: "s2s" | "pipeline" = providerCount === 3 ? "pipeline" : "s2s";
+  const mode = assertProviderTriple(parsed.stt, parsed.llm, parsed.tts);
   return {
     name: parsed.name,
     systemPrompt: parsed.systemPrompt ?? DEFAULT_SYSTEM_PROMPT,
@@ -139,9 +147,9 @@ export function parseManifest(input: unknown): Manifest {
     theme: parsed.theme,
     tools: parsed.tools ?? {},
     allowedHosts: parsed.allowedHosts ?? [],
-    stt: raw.stt,
-    llm: raw.llm,
-    tts: raw.tts,
+    stt: parsed.stt,
+    llm: parsed.llm,
+    tts: parsed.tts,
     mode,
   };
 }

package/sdk/providers/llm/anthropic.ts

@@ -0,0 +1,31 @@
+// Copyright 2025 the AAI authors. MIT license.
+/**
+ * Anthropic LLM factory — returns a pure descriptor.
+ *
+ * Users call this in place of importing from `@ai-sdk/anthropic` directly,
+ * so agent bundles don't drag the Anthropic SDK into the guest sandbox
+ * (which has no `--allow-env` permission and would crash on the SDK's
+ * eager `ANTHROPIC_BASE_URL` read).
+ *
+ * The host-side resolver in `host/providers/resolve.ts` builds a real
+ * Vercel AI SDK `LanguageModel` from this descriptor during
+ * `createRuntime`, using `ANTHROPIC_API_KEY` from the agent's env.
+ */
+
+import type { LlmProvider } from "../../providers.ts";
+
+export const ANTHROPIC_KIND = "anthropic" as const;
+
+export interface AnthropicOptions {
+  /** Anthropic model id, e.g. `"claude-haiku-4-5"`. */
+  model: string;
+}
+
+export type AnthropicProvider = LlmProvider & {
+  readonly kind: typeof ANTHROPIC_KIND;
+  readonly options: AnthropicOptions;
+};
+
+export function anthropic(opts: AnthropicOptions): AnthropicProvider {
+  return { kind: ANTHROPIC_KIND, options: { ...opts } };
+}

package/sdk/providers/llm-barrel.ts

@@ -0,0 +1,12 @@
+// Copyright 2025 the AAI authors. MIT license.
+/**
+ * `@alexkroman1/aai/llm` subpath barrel.
+ *
+ * Re-exports LLM provider factories. Users import from here instead of
+ * `@ai-sdk/anthropic` directly so the agent bundle stays free of eager
+ * env reads and other SDK side-effects.
+ */
+
+export type { LlmProvider } from "../providers.ts";
+// biome-ignore lint/performance/noReExportAll: subpath barrel
+export * from "./llm/anthropic.ts";

package/sdk/providers/stt/assemblyai.ts

@@ -0,0 +1,38 @@
+// Copyright 2025 the AAI authors. MIT license.
+/**
+ * AssemblyAI Universal-Streaming STT factory — returns a pure descriptor.
+ *
+ * The descriptor flows through the bundle → server → runtime pipeline
+ * without importing the `assemblyai` SDK. The host-side resolver in
+ * `host/providers/resolve.ts` turns it into an openable {@link SttOpener}
+ * during `createRuntime`.
+ */
+
+import type { SttProvider } from "../../providers.ts";
+
+/** Kind tag recognised by the host-side resolver. */
+export const ASSEMBLYAI_KIND = "assemblyai" as const;
+
+export interface AssemblyAIOptions {
+  /**
+   * Streaming speech model. Defaults to `"u3pro-rt"` (Universal-3 Pro
+   * Real-Time). Arbitrary strings are forwarded to the SDK unchanged.
+   */
+  model?: "u3pro-rt" | string;
+}
+
+export type AssemblyAIProvider = SttProvider & {
+  readonly kind: typeof ASSEMBLYAI_KIND;
+  readonly options: AssemblyAIOptions;
+};
+
+/**
+ * Build an AssemblyAI STT descriptor.
+ *
+ * The API key is resolved host-side from the agent's env
+ * (`ASSEMBLYAI_API_KEY`); there is no factory-time key parameter, so the
+ * descriptor stays free of secrets and safe to serialize.
+ */
+export function assemblyAI(opts: AssemblyAIOptions = {}): AssemblyAIProvider {
+  return { kind: ASSEMBLYAI_KIND, options: { ...opts } };
+}

package/sdk/providers/stt-barrel.ts

@@ -0,0 +1,12 @@
+// Copyright 2025 the AAI authors. MIT license.
+/**
+ * `@alexkroman1/aai/stt` subpath barrel.
+ *
+ * Re-exports the descriptor factory (`assemblyAI`) and the shared STT
+ * contract types. Importing this barrel does not pull in the `assemblyai`
+ * SDK — that happens only when the host resolver is invoked.
+ */
+
+export type { SttError, SttEvents, SttOpenOptions, SttProvider, SttSession } from "../providers.ts";
+// biome-ignore lint/performance/noReExportAll: subpath barrel
+export * from "./stt/assemblyai.ts";

package/sdk/providers/tts/cartesia.ts

@@ -0,0 +1,31 @@
+// Copyright 2025 the AAI authors. MIT license.
+/**
+ * Cartesia TTS factory — returns a pure descriptor.
+ *
+ * See `sdk/providers/stt/assemblyai.ts` for the descriptor/opener split;
+ * the host-side resolver in `host/providers/resolve.ts` turns this into an
+ * openable {@link TtsOpener} during `createRuntime` using the
+ * `CARTESIA_API_KEY` from the agent's env.
+ */
+
+import type { TtsProvider } from "../../providers.ts";
+
+export const CARTESIA_KIND = "cartesia" as const;
+
+export interface CartesiaOptions {
+  /** Cartesia voice ID. Required. */
+  voice: string;
+  /** Model ID. Defaults to `"sonic-2"`. */
+  model?: string;
+  /** Spoken language hint. Defaults to `"en"`. */
+  language?: string;
+}
+
+export type CartesiaProvider = TtsProvider & {
+  readonly kind: typeof CARTESIA_KIND;
+  readonly options: CartesiaOptions;
+};
+
+export function cartesia(opts: CartesiaOptions): CartesiaProvider {
+  return { kind: CARTESIA_KIND, options: { ...opts } };
+}

package/sdk/providers/tts-barrel.ts

@@ -0,0 +1,12 @@
+// Copyright 2025 the AAI authors. MIT license.
+/**
+ * `@alexkroman1/aai/tts` subpath barrel.
+ *
+ * Re-exports the descriptor factory (`cartesia`) and the shared TTS
+ * contract types. Does not pull in `@cartesia/cartesia-js` — the host
+ * resolver handles that at session start.
+ */
+
+export type { TtsError, TtsEvents, TtsOpenOptions, TtsProvider, TtsSession } from "../providers.ts";
+// biome-ignore lint/performance/noReExportAll: subpath barrel
+export * from "./tts/cartesia.ts";

package/sdk/providers.ts

@@ -1,25 +1,87 @@
 // Copyright 2025 the AAI authors. MIT license.
 /**
- * Pluggable provider interfaces — normalized seams over streaming STT / TTS
- * SDKs, plus the LLM provider type.
+ * Pluggable provider contracts.
  *
- * These are zero-runtime **type** declarations with no Node.js dependencies,
- * so they live in `sdk/` alongside the `Manifest` type that references them.
- * Concrete adapters (e.g. AssemblyAI STT, Cartesia TTS) live under
- * `host/providers/` because they depend on Node-only SDKs.
+ * **Two layers, strict boundary.**
+ *
+ * - The *descriptor* layer (`SttProvider` / `LlmProvider` / `TtsProvider`) is
+ *   pure data — `{ kind, options }` objects returned by the user-facing
+ *   factories (`assemblyAI(...)`, `anthropic(...)`, `cartesia(...)`). They
+ *   are JSON-serializable, contain no functions, and can cross the CLI →
+ *   server → guest boundary without evaluating any third-party SDK.
+ *   They live in `sdk/` alongside `Manifest` and have zero Node-only deps.
+ *
+ * - The *openable* layer (`SttOpener` / `TtsOpener` + `SttSession` /
+ *   `TtsSession`) is host-only. The host's internal
+ *   `host/providers/resolve.ts` registry turns descriptors into openers
+ *   during `createRuntime`, importing the concrete SDKs (`assemblyai`,
+ *   `@cartesia/cartesia-js`, `@ai-sdk/anthropic`) only at that point.
+ *   Only the openable layer talks to the network; descriptors never do.
+ *
+ * This split is load-bearing for the sandboxed deployment path: the guest
+ * Deno sandbox can import `@alexkroman1/aai/{stt,tts,llm}` without pulling
+ * in any AI-SDK code, which means no env reads (`ANTHROPIC_BASE_URL`, etc.)
+ * at bundle load — the exact failure mode that forced this refactor.
  */
 
-import type { LanguageModel } from "ai";
-
 /** Unsubscribe callback returned by `.on()` event subscriptions. */
 export type Unsubscribe = () => void;
 
-// -------- STT --------
+// -------- Descriptor shape (user-facing, serializable) ----------------------
+
+/**
+ * Base shape for a provider descriptor. A `kind` tag + opaque `options`
+ * payload lets the host registry pick the right resolver and pass the
+ * caller's options through verbatim.
+ */
+export interface ProviderDescriptor<Kind extends string, Options> {
+  readonly kind: Kind;
+  readonly options: Options;
+}
+
+/** Descriptor for an STT provider. Returned by factories like `assemblyAI(...)`. */
+export type SttProvider = ProviderDescriptor<string, Record<string, unknown>>;
+
+/** Descriptor for an LLM provider. Returned by factories like `anthropic(...)`. */
+export type LlmProvider = ProviderDescriptor<string, Record<string, unknown>>;
+
+/** Descriptor for a TTS provider. Returned by factories like `cartesia(...)`. */
+export type TtsProvider = ProviderDescriptor<string, Record<string, unknown>>;
+
+/**
+ * Session mode derived from which provider triple is set.
+ *
+ * `parseManifest`, `toAgentConfig`, `createRuntime`, and the server's
+ * `IsolateConfigSchema` all use {@link assertProviderTriple} so there's
+ * one source of truth for the validation.
+ */
+export type SessionMode = "s2s" | "pipeline";
+
+/**
+ * Enforce the all-or-nothing provider rule and return the derived mode.
+ *
+ * Pipeline mode requires STT, LLM, and TTS all set; S2S mode requires
+ * none of them. Anything in-between is a configuration error.
+ */
+export function assertProviderTriple(stt: unknown, llm: unknown, tts: unknown): SessionMode {
+  const count = (stt != null ? 1 : 0) + (llm != null ? 1 : 0) + (tts != null ? 1 : 0);
+  if (count !== 0 && count !== 3) {
+    throw new Error("stt, llm, and tts must be set together");
+  }
+  return count === 3 ? "pipeline" : "s2s";
+}
+
+// -------- STT openable (host-only) ------------------------------------------
 
 export interface SttError extends Error {
   readonly code: "stt_connect_failed" | "stt_auth_failed" | "stt_stream_error";
 }
 
+/** Build an {@link SttError} with a typed `code`. Zero-dep helper so both sdk/ and host/ can use it. */
+export function makeSttError(code: SttError["code"], message: string): SttError {
+  return Object.assign(new Error(message), { code }) as SttError;
+}
+
 export type SttEvents = {
   /** Interim transcript; drives barge-in detection. */
   partial: (text: string) => void;
@@ -42,17 +104,23 @@ export interface SttOpenOptions {
   signal: AbortSignal;
 }
 
-export interface SttProvider {
+/** Host-side openable STT provider — produced by `resolveStt(descriptor)`. */
+export interface SttOpener {
   readonly name: string;
   open(opts: SttOpenOptions): Promise<SttSession>;
 }
 
-// -------- TTS --------
+// -------- TTS openable (host-only) ------------------------------------------
 
 export interface TtsError extends Error {
   readonly code: "tts_connect_failed" | "tts_auth_failed" | "tts_stream_error";
 }
 
+/** Build a {@link TtsError} with a typed `code`. Mirror of {@link makeSttError}. */
+export function makeTtsError(code: TtsError["code"], message: string): TtsError {
+  return Object.assign(new Error(message), { code }) as TtsError;
+}
+
 export type TtsEvents = {
   /** One PCM16 audio chunk. Orchestrator forwards to the client. */
   audio: (pcm: Int16Array) => void;
@@ -79,12 +147,8 @@ export interface TtsOpenOptions {
   signal: AbortSignal;
 }
 
-export interface TtsProvider {
+/** Host-side openable TTS provider — produced by `resolveTts(descriptor)`. */
+export interface TtsOpener {
   readonly name: string;
   open(opts: TtsOpenOptions): Promise<TtsSession>;
 }
-
-// -------- LLM --------
-
-/** LLM provider — Vercel AI SDK's `LanguageModel`; no wrapping. */
-export type LlmProvider = LanguageModel;

package/dist/_internal-types-CoDTiBd1.js

@@ -1,61 +0,0 @@
-import { i as ToolChoiceSchema, t as BuiltinToolSchema } from "./types-Cfx_4QDK.js";
-import { z } from "zod";
-//#region sdk/_internal-types.ts
-/**
-* Zod schema for serializable agent configuration sent over the wire.
-*
-* This is the JSON-safe subset of the agent definition that can be
-* transmitted between the worker and the host process via structured clone.
-*/
-const AgentConfigSchema = z.object({
-	name: z.string().min(1),
-	systemPrompt: z.string(),
-	greeting: z.string(),
-	sttPrompt: z.string().optional(),
-	maxSteps: z.number().int().positive().optional(),
-	toolChoice: ToolChoiceSchema.optional(),
-	builtinTools: z.array(BuiltinToolSchema).readonly().optional(),
-	idleTimeoutMs: z.number().nonnegative().optional()
-});
-/** Extract the serializable {@link AgentConfig} subset from a source object. */
-function toAgentConfig(src) {
-	const config = {
-		name: src.name,
-		systemPrompt: src.systemPrompt,
-		greeting: src.greeting
-	};
-	if (src.sttPrompt !== void 0) config.sttPrompt = src.sttPrompt;
-	if (src.maxSteps !== void 0) config.maxSteps = src.maxSteps;
-	if (src.toolChoice !== void 0) config.toolChoice = src.toolChoice;
-	if (src.builtinTools) config.builtinTools = [...src.builtinTools];
-	if (src.idleTimeoutMs !== void 0) config.idleTimeoutMs = src.idleTimeoutMs;
-	return config;
-}
-/**
-* Zod schema for serialized tool definitions sent over the wire.
-*
-* `parameters` must be a valid JSON Schema object (with `type`, `properties`,
-* etc.) — the Vercel AI SDK wraps it via `jsonSchema()`.
-*/
-const ToolSchemaSchema = z.object({
-	name: z.string().min(1),
-	description: z.string().min(1),
-	parameters: z.record(z.string(), z.unknown())
-});
-/** Empty Zod object schema used as default when tools have no parameters. */
-const EMPTY_PARAMS = z.object({});
-/**
-* Convert agent tool definitions to JSON Schema format for wire transport.
-*
-* Transforms the Zod-based `parameters` of each tool into a plain JSON Schema
-* object suitable for structured clone / JSON serialization.
-*/
-function agentToolsToSchemas(tools) {
-	return Object.entries(tools).map(([name, def]) => ({
-		name,
-		description: def.description,
-		parameters: z.toJSONSchema(def.parameters ?? EMPTY_PARAMS)
-	}));
-}
-//#endregion
-export { toAgentConfig as a, agentToolsToSchemas as i, EMPTY_PARAMS as n, ToolSchemaSchema as r, AgentConfigSchema as t };

package/dist/host/providers/llm.d.ts

@@ -1,2 +0,0 @@
-/** LLM provider type — re-exported from sdk/ for host-side consumption. */
-export type * from "../../sdk/providers.ts";

package/dist/host/providers/stt-barrel.d.ts

@@ -1,8 +0,0 @@
-/**
- * `@alexkroman1/aai/stt` subpath barrel. Re-exports the STT provider
- * contract types (via `stt.ts` → `sdk/providers.ts`) alongside the
- * concrete AssemblyAI adapter factory. Task 9 owns wiring this file
- * into `package.json` exports.
- */
-export * from "./stt/assemblyai.ts";
-export type * from "./stt.ts";

package/dist/host/providers/stt-barrel.js

@@ -1,92 +0,0 @@
-import { createNanoEvents } from "nanoevents";
-import { AssemblyAI } from "assemblyai";
-//#region host/providers/stt/assemblyai.ts
-/**
-* AssemblyAI Universal-Streaming STT adapter.
-*
-* Wraps the `assemblyai` Node SDK's {@link StreamingTranscriber} and
-* normalizes its event surface onto the {@link SttProvider} /
-* {@link SttEvents} contract consumed by the pipeline orchestrator.
-*
-* 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 adapter's model alias to the SDK's `speechModel` value. */
-function resolveSpeechModel(model) {
-	if (model === "u3pro-rt") return "u3-rt-pro";
-	return model;
-}
-function makeError(message) {
-	const err = new Error(message);
-	err.code = "stt_stream_error";
-	return err;
-}
-function assemblyAI(opts = {}) {
-	return {
-		name: "assemblyai",
-		async open(openOpts) {
-			const apiKey = opts.apiKey ?? openOpts.apiKey ?? process.env.ASSEMBLYAI_API_KEY;
-			if (!apiKey) {
-				const err = /* @__PURE__ */ new Error("AssemblyAI STT adapter: missing API key. Provide via the factory option, SttOpenOptions, or the ASSEMBLYAI_API_KEY environment variable.");
-				err.code = "stt_auth_failed";
-				throw err;
-			}
-			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", makeError(err?.message ?? String(err)));
-			});
-			transcriber.on("close", (code) => {
-				if (closed) return;
-				if (code !== 1e3) emitter.emit("error", makeError(`socket closed ${code}`));
-			});
-			try {
-				await transcriber.connect();
-			} catch (cause) {
-				const err = /* @__PURE__ */ new Error(`AssemblyAI STT: connect failed: ${cause instanceof Error ? cause.message : String(cause)}`);
-				err.code = "stt_connect_failed";
-				throw err;
-			}
-			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
-export { assemblyAI };