@alexkroman1/aai 1.4.5 → 1.5.1

package/host/ws-handler.ts

@@ -11,12 +11,11 @@ import {
   MAX_MESSAGE_BUFFER_SIZE,
   WS_OPEN,
 } from "../sdk/constants.ts";
-import type { ClientMessage, ClientSink, ReadyConfig } from "../sdk/protocol.ts";
-import { ClientMessageSchema, lenientParse } from "../sdk/protocol.ts";
-import { errorDetail, errorMessage } from "../sdk/utils.ts";
+import { ClientMessageSchema, type ClientSink, lenientParse } from "../sdk/protocol.ts";
+import { errorDetail } from "../sdk/utils.ts";
 import type { Logger } from "./runtime-config.ts";
 import { consoleLogger } from "./runtime-config.ts";
-import type { Session } from "./session.ts";
+import type { SessionCore } from "./session-core.ts";
 
 /**
  * Minimal WebSocket interface accepted by {@link wireSessionSocket}.
@@ -34,11 +33,11 @@ export type SessionWebSocket = {
 /** Options for wiring a WebSocket to a session. */
 export type WsSessionOptions = {
   /** Map of active sessions (session is added on open, removed on close). */
-  sessions: Map<string, Session>;
+  sessions: Map<string, SessionCore>;
   /** Factory function to create a session for a given ID and client sink. */
-  createSession: (sessionId: string, client: ClientSink) => Session;
+  createSession: (sessionId: string, client: ClientSink) => SessionCore;
   /** Protocol config sent to the client immediately on connect. */
-  readyConfig: ReadyConfig;
+  readyConfig: { audioFormat: "pcm16"; sampleRate: number; ttsSampleRate: number };
   /** Additional key-value pairs included in log messages. */
   logContext?: Record<string, string>;
   /** Callback invoked when the WebSocket connection opens. */
@@ -57,25 +56,27 @@ export type WsSessionOptions = {
   resumeFrom?: string;
 };
 
+const AUDIO_DONE_FRAME = JSON.stringify({
+  type: "audio_done",
+} satisfies { type: "audio_done" });
+
 /**
  * Creates a {@link ClientSink} backed by a plain WebSocket.
  *
- * Text events are sent as JSON text frames; audio chunks are sent as
- * binary frames (zero-copy).
+ * Session events are sent as JSON text frames; audio chunks are sent as raw
+ * PCM16 binary frames.
  */
 function createClientSink(ws: SessionWebSocket, log: Logger): ClientSink {
-  /** Send data over ws, silently dropping if the socket is not open. */
-  function safeSend(data: string | ArrayBuffer | Uint8Array): void {
+  function safeSend(data: string | Uint8Array): void {
     try {
       if (ws.readyState !== WS_OPEN) return;
       ws.send(data);
     } catch (err) {
       log.debug?.("safeSend: socket closed between readyState check and send", {
-        error: errorMessage(err),
+        error: err instanceof Error ? err.message : String(err),
       });
     }
   }
-
   return {
     get open() {
       return ws.readyState === WS_OPEN;
@@ -87,48 +88,40 @@ function createClientSink(ws: SessionWebSocket, log: Logger): ClientSink {
       safeSend(chunk);
     },
     playAudioDone() {
-      safeSend(JSON.stringify({ type: "audio_done" }));
+      safeSend(AUDIO_DONE_FRAME);
     },
   };
 }
 
-function handleBinaryAudio(data: unknown, session: Session): boolean {
-  // Buffer extends Uint8Array in Node, so this catches Buffer too.
+function handleBinaryAudio(data: unknown, session: SessionCore): boolean {
   if (data instanceof Uint8Array) {
     session.onAudio(data);
     return true;
   }
-  if (data instanceof ArrayBuffer) {
-    session.onAudio(new Uint8Array(data));
-    return true;
-  }
   return false;
 }
 
-function handleTextMessage(
-  data: unknown,
-  session: Session,
-  log: Logger,
-  ctx: Record<string, string>,
-  sid: string,
-): void {
-  if (typeof data !== "string") return;
-  let json: unknown;
+function handleTextMessage(data: unknown, session: SessionCore, log: Logger, sid: string): void {
+  if (typeof data !== "string") {
+    log.warn("ws: non-string, non-binary frame received; dropping", { sid });
+    return;
+  }
+  let parsed: unknown;
   try {
-    json = JSON.parse(data);
+    parsed = JSON.parse(data);
   } catch {
-    log.warn("Invalid JSON from client", { ...ctx, sid });
+    log.warn("ws: invalid JSON; dropping", { sid, data: data.slice(0, 200) });
     return;
   }
-
-  const parsed = lenientParse(ClientMessageSchema, json);
-  if (!parsed.ok) {
-    if (parsed.malformed) log.warn("Invalid client message", { ...ctx, sid, error: parsed.error });
+  const result = lenientParse(ClientMessageSchema, parsed);
+  if (!result.ok) {
+    if (result.malformed) {
+      log.warn("ws: malformed client message", { sid, error: result.error });
+    }
+    // else: unrecognised type — silently drop (rolling-upgrade tolerance)
     return;
   }
-
-  const msg: ClientMessage = parsed.data;
-  switch (msg.type) {
+  switch (result.data.type) {
     case "audio_ready":
       session.onAudioReady();
       break;
@@ -139,7 +132,7 @@ function handleTextMessage(
       session.onReset();
       break;
     case "history":
-      session.onHistory(msg.messages);
+      session.onHistory(result.data.messages);
       break;
     default:
       break;
@@ -147,13 +140,13 @@ function handleTextMessage(
 }
 
 /**
- * Attaches session lifecycle handlers to a native WebSocket using
- * plain JSON text frames and binary audio frames.
+ * Attaches session lifecycle handlers to a native WebSocket using JSON text
+ * frames for control messages and raw PCM16 binary frames for audio.
  *
  * Connection flow:
- * 1. WebSocket opens → server sends `{ type: "config", ...ReadyConfig }`
- * 2. Client sets up audio → sends `{ type: "audio_ready" }`
- * 3. If reconnecting → client sends `{ type: "history", messages: [...] }`
+ * 1. WebSocket opens → server sends JSON CONFIG frame with sampleRate, ttsSampleRate, sessionId
+ * 2. Client sets up audio → sends JSON AUDIO_READY frame
+ * 3. If reconnecting → client sends JSON HISTORY frame with prior messages
  */
 export function wireSessionSocket(ws: SessionWebSocket, opts: WsSessionOptions): void {
   const { sessions, logger: log = consoleLogger } = opts;
@@ -161,10 +154,10 @@ export function wireSessionSocket(ws: SessionWebSocket, opts: WsSessionOptions):
   const sid = sessionId.slice(0, 8);
   const ctx = opts.logContext ?? {};
 
-  let session: Session | null = null;
+  let session: SessionCore | null = null;
   /** Set to true once session.start() resolves. Messages arriving before
    *  this flag is set are buffered and replayed once the session is ready,
-   *  preventing audio/text from being dispatched to a half-initialized session. */
+   *  preventing audio/frames from being dispatched to a half-initialized session. */
   let sessionReady = false;
   let messageBuffer: { data: unknown }[] | null = [];
 
@@ -173,9 +166,8 @@ export function wireSessionSocket(ws: SessionWebSocket, opts: WsSessionOptions):
     const buf = messageBuffer;
     messageBuffer = null;
     for (const event of buf) {
-      const { data } = event;
-      if (handleBinaryAudio(data, session)) continue;
-      handleTextMessage(data, session, log, ctx, sid);
+      if (handleBinaryAudio(event.data, session)) continue;
+      handleTextMessage(event.data, session, log, sid);
     }
   }
 
@@ -188,9 +180,17 @@ export function wireSessionSocket(ws: SessionWebSocket, opts: WsSessionOptions):
     sessions.set(sessionId, session);
     opts.onSinkCreated?.(sessionId, client);
 
-    // Send config immediately — zero RTT. Include sessionId so the client
-    // can reconnect with ?sessionId=<id> to resume a persisted session.
-    ws.send(JSON.stringify({ type: "config", ...opts.readyConfig, sessionId }));
+    // Send config immediately — zero RTT. Include sessionId so the
+    // client can reconnect with ?sessionId=<id> to resume a persisted session.
+    ws.send(
+      JSON.stringify({
+        type: "config",
+        audioFormat: opts.readyConfig.audioFormat,
+        sampleRate: opts.readyConfig.sampleRate,
+        ttsSampleRate: opts.readyConfig.ttsSampleRate,
+        sessionId,
+      }),
+    );
 
     const timeoutMs = opts.sessionStartTimeoutMs ?? DEFAULT_SESSION_START_TIMEOUT_MS;
     const startWithTimeout = pTimeout(session.start(), {
@@ -222,17 +222,14 @@ export function wireSessionSocket(ws: SessionWebSocket, opts: WsSessionOptions):
   ws.addEventListener("message", (event) => {
     if (!session) return;
     // Buffer messages until session.start() completes to avoid dispatching
-    // to a session whose S2S connection isn't established yet.
+    // to a session whose transport connection isn't established yet.
     if (!sessionReady) {
-      if (messageBuffer && messageBuffer.length < MAX_MESSAGE_BUFFER_SIZE) {
+      if (messageBuffer && messageBuffer.length < MAX_MESSAGE_BUFFER_SIZE)
         messageBuffer.push(event);
-      }
       return;
     }
-    const { data } = event;
-
-    if (handleBinaryAudio(data, session)) return;
-    handleTextMessage(data, session, log, ctx, sid);
+    if (handleBinaryAudio(event.data, session)) return;
+    handleTextMessage(event.data, session, log, sid);
   });
 
   ws.addEventListener("close", () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexkroman1/aai",
-  "version": "1.4.5",
+  "version": "1.5.1",
   "type": "module",
   "exports": {
     ".": {
@@ -42,6 +42,7 @@
   "dependencies": {
     "@ai-sdk/anthropic": "^3.0.0",
     "@cartesia/cartesia-js": "^3.0.0",
+    "@deepgram/sdk": "^5.0.0",
     "ai": "^6.0.161",
     "assemblyai": "^4.30.0",
     "escape-html": "^1.0.3",

package/sdk/__snapshots__/exports.test.ts.snap

@@ -66,13 +66,13 @@ exports[`export surface stability > @alexkroman1/aai/protocol export 1`] = `
 exports[`export surface stability > @alexkroman1/aai/runtime export 1`] = `
 [
   "DEFAULT_S2S_CONFIG",
-  "_buildBaseCtx",
   "_internals",
-  "buildCtx",
   "consoleLogger",
+  "createPipelineTransport",
   "createRuntime",
-  "createS2sSession",
+  "createS2sTransport",
   "createServer",
+  "createSessionCore",
   "createUnstorageKv",
   "executeInIsolate",
   "executeToolCall",

package/sdk/__snapshots__/schema-shapes.test.ts.snap

@@ -22,6 +22,7 @@ exports[`manifest schema shapes > ToolSchemaSchema shape 1`] = `
   "description",
   "name",
   "parameters",
+  "type",
 ]
 `;
 

package/sdk/_internal-types.ts

@@ -128,6 +128,7 @@ export function toAgentConfig(src: AgentConfigSource): AgentConfig {
  * etc.) — the Vercel AI SDK wraps it via `jsonSchema()`.
  */
 export const ToolSchemaSchema = z.object({
+  type: z.literal("function"),
   name: z.string().min(1),
   description: z.string().min(1),
   parameters: z.record(z.string(), z.unknown()),
@@ -135,6 +136,7 @@ export const ToolSchemaSchema = z.object({
 
 /** Serialized tool schema — derived from {@link ToolSchemaSchema}. */
 export type ToolSchema = {
+  type: "function";
   name: string;
   description: string;
   parameters: JSONSchema7;
@@ -151,6 +153,7 @@ export const EMPTY_PARAMS = z.object({});
  */
 export function agentToolsToSchemas(tools: Readonly<Record<string, ToolDef>>): ToolSchema[] {
   return Object.entries(tools).map(([name, def]) => ({
+    type: "function",
     name,
     description: def.description,
     parameters: z.toJSONSchema(def.parameters ?? EMPTY_PARAMS) as JSONSchema7,

package/sdk/protocol-compat.test.ts

@@ -24,8 +24,16 @@ import {
 // ── Load fixtures ─────────────────────────────────────────────────────────
 
 const FIXTURE_DIR = join(import.meta.dirname, "compat-fixtures");
+// Only load compat fixtures that have the expected schema-compat structure
+// (ServerMessage, ClientMessage, KvRequest, constants). Wire-format fixtures
+// like wire-v1.json use a different shape and are tested by wire.test.ts.
 const fixtureFiles = readdirSync(FIXTURE_DIR)
   .filter((f) => f.endsWith(".json"))
+  .filter((f) => {
+    const raw = readFileSync(join(FIXTURE_DIR, f), "utf-8");
+    const parsed = JSON.parse(raw) as Record<string, unknown>;
+    return "ServerMessage" in parsed && "ClientMessage" in parsed;
+  })
   .sort();
 
 type Fixture = {

package/sdk/protocol.ts

@@ -141,16 +141,17 @@ export type ClientEvent = z.infer<typeof ClientEventSchema>;
 /**
  * Typed interface for pushing session events to a connected client.
  *
- * For WebSocket sessions this sends JSON text frames and binary audio frames.
+ * Events (`event`, `playAudioDone`) send JSON text frames. Audio chunks
+ * (`playAudioChunk`) send raw PCM16 binary frames.
  */
 export interface ClientSink {
-  /** Whether the underlying connection is open and accepting calls. */
+  /** True when the underlying connection is open and will accept calls. */
   readonly open: boolean;
-  /** Push a session event to the client. */
+  /** Push a session event (JSON text frame) to the client. */
   event(e: ClientEvent): void;
-  /** Send a single TTS audio chunk to the client. */
+  /** Send a single PCM16 audio chunk (raw binary frame) to the client. */
   playAudioChunk(chunk: Uint8Array): void;
-  /** Signal that TTS audio is complete. */
+  /** Signal that TTS audio is complete (JSON text frame). */
   playAudioDone(): void;
 }
 

package/sdk/providers/stt/deepgram.ts

@@ -0,0 +1,43 @@
+// Copyright 2026 the AAI authors. MIT license.
+/**
+ * Deepgram Nova streaming STT factory — returns a pure descriptor.
+ *
+ * The descriptor flows through the bundle → server → runtime pipeline
+ * without importing the `@deepgram/sdk` package. 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 DEEPGRAM_KIND = "deepgram" as const;
+
+export interface DeepgramOptions {
+  /**
+   * Streaming speech model. Defaults to `"nova-3"`. Any string is forwarded
+   * to the SDK unchanged, which allows opt-in to future models.
+   */
+  model?: "nova-3" | "nova-2" | string;
+  /**
+   * BCP-47 language code for transcription. Defaults to `"en"`.
+   * Examples: `"en"`, `"es"`, `"fr"`, `"de"`.
+   */
+  language?: string;
+}
+
+export type DeepgramProvider = SttProvider & {
+  readonly kind: typeof DEEPGRAM_KIND;
+  readonly options: DeepgramOptions;
+};
+
+/**
+ * Build a Deepgram STT descriptor.
+ *
+ * The API key is resolved host-side from the agent's env
+ * (`DEEPGRAM_API_KEY`); there is no factory-time key parameter, so the
+ * descriptor stays free of secrets and safe to serialize.
+ */
+export function deepgram(opts: DeepgramOptions = {}): DeepgramProvider {
+  return { kind: DEEPGRAM_KIND, options: { ...opts } };
+}

package/sdk/providers/stt-barrel.ts

@@ -10,3 +10,5 @@
 export type { SttError, SttEvents, SttOpenOptions, SttProvider, SttSession } from "../providers.ts";
 // biome-ignore lint/performance/noReExportAll: subpath barrel
 export * from "./stt/assemblyai.ts";
+// biome-ignore lint/performance/noReExportAll: subpath barrel
+export * from "./stt/deepgram.ts";

package/sdk/providers/tts/cartesia.ts

@@ -12,9 +12,16 @@ import type { TtsProvider } from "../../providers.ts";
 
 export const CARTESIA_KIND = "cartesia" as const;
 
+/**
+ * Default voice used when callers invoke `cartesia()` with no `voice`. This
+ * is the same voice the example templates ship with, so a bare `cartesia()`
+ * works out of the box for new agents.
+ */
+export const CARTESIA_DEFAULT_VOICE = "f786b574-daa5-4673-aa0c-cbe3e8534c02";
+
 export interface CartesiaOptions {
-  /** Cartesia voice ID. Required. */
-  voice: string;
+  /** Cartesia voice ID. Defaults to {@link CARTESIA_DEFAULT_VOICE}. */
+  voice?: string;
   /** Model ID. Defaults to `"sonic-2"`. */
   model?: string;
   /** Spoken language hint. Defaults to `"en"`. */
@@ -23,9 +30,12 @@ export interface CartesiaOptions {
 
 export type CartesiaProvider = TtsProvider & {
   readonly kind: typeof CARTESIA_KIND;
-  readonly options: CartesiaOptions;
+  readonly options: CartesiaOptions & { voice: string };
 };
 
-export function cartesia(opts: CartesiaOptions): CartesiaProvider {
-  return { kind: CARTESIA_KIND, options: { ...opts } };
+export function cartesia(opts: CartesiaOptions = {}): CartesiaProvider {
+  return {
+    kind: CARTESIA_KIND,
+    options: { ...opts, voice: opts.voice ?? CARTESIA_DEFAULT_VOICE },
+  };
 }

package/sdk/providers/tts/rime.ts

@@ -0,0 +1,52 @@
+// Copyright 2026 the AAI authors. MIT license.
+/**
+ * Rime 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
+ * `RIME_API_KEY` from the agent's env.
+ *
+ * Language codes follow ISO 639-3 (three-letter): `"eng"`, `"fra"`, etc.
+ * This differs from many APIs that use ISO 639-1 two-letter codes like `"en"`.
+ */
+
+import type { TtsProvider } from "../../providers.ts";
+
+export const RIME_KIND = "rime" as const;
+
+/**
+ * Default Rime speaker used when callers invoke `rime()` with no `voice`.
+ * `cove` is a `mistv2` speaker, matching the default model below — so a
+ * bare `rime()` works out of the box for new agents.
+ */
+export const RIME_DEFAULT_VOICE = "cove";
+
+export interface RimeOptions {
+  /** Rime speaker ID. Defaults to {@link RIME_DEFAULT_VOICE}. */
+  voice?: string;
+  /**
+   * Rime model ID. Defaults to `"mistv2"` (Rime's most compatible model).
+   * Common values: `"mistv2"`, `"arcana"`.
+   */
+  model?: "mistv2" | "arcana" | string;
+  /**
+   * Spoken language. Uses ISO 639-3 (three-letter codes).
+   * Defaults to `"eng"` (English).
+   *
+   * Note: Rime uses 3-letter codes — use `"eng"` not `"en"`.
+   */
+  language?: string;
+}
+
+export type RimeProvider = TtsProvider & {
+  readonly kind: typeof RIME_KIND;
+  readonly options: RimeOptions & { voice: string };
+};
+
+export function rime(opts: RimeOptions = {}): RimeProvider {
+  return {
+    kind: RIME_KIND,
+    options: { ...opts, voice: opts.voice ?? RIME_DEFAULT_VOICE },
+  };
+}

package/sdk/providers/tts-barrel.ts

@@ -10,3 +10,5 @@
 export type { TtsError, TtsEvents, TtsOpenOptions, TtsProvider, TtsSession } from "../providers.ts";
 // biome-ignore lint/performance/noReExportAll: subpath barrel
 export * from "./tts/cartesia.ts";
+// biome-ignore lint/performance/noReExportAll: subpath barrel
+export * from "./tts/rime.ts";

package/sdk/schema-alignment.test.ts

@@ -65,6 +65,7 @@ describe("AgentConfigSchema", () => {
 describe("ToolSchemaSchema", () => {
   test("accepts valid tool schema", () => {
     const valid = {
+      type: "function" as const,
       name: "get_weather",
       description: "Get weather",
       parameters: { type: "object", properties: { city: { type: "string" } } },
@@ -73,15 +74,25 @@ describe("ToolSchemaSchema", () => {
   });
 
   test("rejects empty name", () => {
-    expect(ToolSchemaSchema.safeParse({ name: "", description: "d", parameters: {} }).success).toBe(
-      false,
-    );
+    expect(
+      ToolSchemaSchema.safeParse({
+        type: "function",
+        name: "",
+        description: "d",
+        parameters: {},
+      }).success,
+    ).toBe(false);
   });
 
   test("rejects empty description", () => {
-    expect(ToolSchemaSchema.safeParse({ name: "n", description: "", parameters: {} }).success).toBe(
-      false,
-    );
+    expect(
+      ToolSchemaSchema.safeParse({
+        type: "function",
+        name: "n",
+        description: "",
+        parameters: {},
+      }).success,
+    ).toBe(false);
   });
 
   test("ToolSchema is assignable from schema inference", () => {
@@ -89,6 +100,7 @@ describe("ToolSchemaSchema", () => {
     // the runtime schema's Record<string, unknown>. Verify the direction:
     // a parsed result should be assignable to ToolSchema (narrow → wide).
     const parsed = ToolSchemaSchema.parse({
+      type: "function",
       name: "test",
       description: "test",
       parameters: { type: "object" },

package/dist/assemblyai-Cxg9eobY.js

@@ -1,18 +0,0 @@
-//#region sdk/providers/stt/assemblyai.ts
-/** Kind tag recognised by the host-side resolver. */
-const ASSEMBLYAI_KIND = "assemblyai";
-/**
-* 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.
-*/
-function assemblyAI(opts = {}) {
-	return {
-		kind: ASSEMBLYAI_KIND,
-		options: { ...opts }
-	};
-}
-//#endregion
-export { assemblyAI as n, ASSEMBLYAI_KIND as t };

package/dist/cartesia-DwDk2tEu.js

@@ -1,10 +0,0 @@
-//#region sdk/providers/tts/cartesia.ts
-const CARTESIA_KIND = "cartesia";
-function cartesia(opts) {
-	return {
-		kind: CARTESIA_KIND,
-		options: { ...opts }
-	};
-}
-//#endregion
-export { cartesia as n, CARTESIA_KIND as t };

package/dist/host/pipeline-session-ctx.d.ts

@@ -1,24 +0,0 @@
-/** Pipeline session context — base ctx + STT/TTS session slots. */
-import type { AgentConfig, ExecuteTool } from "../sdk/_internal-types.ts";
-import type { ClientSink } from "../sdk/protocol.ts";
-import type { SttSession, TtsSession } from "../sdk/providers.ts";
-import type { Logger } from "./runtime-config.ts";
-import { type BaseSessionCtx } from "./session-ctx.ts";
-/**
- * Pipeline session context — {@link BaseSessionCtx} plus STT/TTS provider
- * session handles. Replaces the S2S `s2s` field with decoupled `stt` + `tts`
- * slots so the pipeline orchestrator can drive independent providers.
- */
-export type PipelineSessionCtx = BaseSessionCtx & {
-    stt: SttSession | null;
-    tts: TtsSession | null;
-};
-export declare function buildPipelineCtx(opts: {
-    id: string;
-    agent: string;
-    client: ClientSink;
-    agentConfig: AgentConfig;
-    executeTool: ExecuteTool;
-    log: Logger;
-    maxHistory?: number | undefined;
-}): PipelineSessionCtx;

package/dist/host/pipeline-session.d.ts

@@ -1,52 +0,0 @@
-/**
- * Pipeline session — pluggable STT → LLM → TTS orchestrator.
- *
- * Alternative to the S2S session (see `session.ts`) that drives three
- * independent providers. A new partial STT event while the agent is replying
- * triggers barge-in (aborts the LLM stream and cancels TTS).
- */
-import type { LanguageModel } from "ai";
-import type { AgentConfig, ExecuteTool, ToolSchema } from "../sdk/_internal-types.ts";
-import type { ClientSink } from "../sdk/protocol.ts";
-import type { SttOpener, TtsOpener } from "../sdk/providers.ts";
-import { type Logger } from "./runtime-config.ts";
-import type { Session } from "./session.ts";
-/** Configuration options for {@link createPipelineSession}. */
-export interface PipelineSessionOptions {
-    /** Unique session identifier. */
-    id: string;
-    /** Agent slug. */
-    agent: string;
-    /** Sink for wire events + audio back to the browser client. */
-    client: ClientSink;
-    /** Serializable agent config (name, system prompt, maxSteps, etc.). */
-    agentConfig: AgentConfig;
-    /** JSON Schema definitions for the agent's tools. */
-    toolSchemas: readonly ToolSchema[];
-    /** Optional natural-language guidance appended to the system prompt. */
-    toolGuidance?: readonly string[] | undefined;
-    /** Function to invoke tools by name. */
-    executeTool: ExecuteTool;
-    /** STT opener (resolved from an {@link SttProvider} descriptor). */
-    stt: SttOpener;
-    /** LLM provider (Vercel AI SDK `LanguageModel`). */
-    llm: LanguageModel;
-    /** TTS opener (resolved from a {@link TtsProvider} descriptor). */
-    tts: TtsOpener;
-    /** STT API key. */
-    sttApiKey: string;
-    /** TTS API key. */
-    ttsApiKey: string;
-    /** STT audio sample rate (PCM16, Hz). Defaults to {@link DEFAULT_STT_SAMPLE_RATE}. */
-    sttSampleRate?: number | undefined;
-    /** TTS audio sample rate (PCM16, Hz). Must match the client's playback AudioContext rate. Defaults to {@link DEFAULT_TTS_SAMPLE_RATE}. */
-    ttsSampleRate?: number | undefined;
-    /** Skip the initial greeting audio on connect (used for session resume). */
-    skipGreeting?: boolean | undefined;
-    /** Logger. Defaults to the console logger. */
-    logger?: Logger | undefined;
-    /** Sliding-window conversation history size. */
-    maxHistory?: number | undefined;
-}
-/** Create a pluggable-provider voice session. */
-export declare function createPipelineSession(opts: PipelineSessionOptions): Session;