@alexkroman1/aai 1.7.0 → 1.8.0

package/dist/host/runtime-config.d.ts

@@ -1,5 +1,7 @@
 /** Structured context attached to log messages. */
 export type LogContext = Record<string, unknown>;
+type LogLevel = "info" | "warn" | "error" | "debug";
+type LogFn = (msg: string, ctx?: LogContext) => void;
 /**
  * Structured logger interface. Used by tests to suppress output and by
  * consumers to plug in custom logging backends.
@@ -15,14 +17,14 @@ export type LogContext = Record<string, unknown>;
  * createServer({ agent, logger: myLogger });
  * ```
  */
-export type Logger = {
-    info(msg: string, ctx?: LogContext): void;
-    warn(msg: string, ctx?: LogContext): void;
-    error(msg: string, ctx?: LogContext): void;
-    debug(msg: string, ctx?: LogContext): void;
-};
+export type Logger = Record<LogLevel, LogFn>;
 /** Default console-backed logger. */
 export declare const consoleLogger: Logger;
+/**
+ * Structured JSON logger for production diagnostics. Each log entry is a
+ * single-line JSON object with `timestamp`, `level`, `msg`, and any
+ * caller-provided context fields.
+ */
 export declare const jsonLogger: Logger;
 /**
  * Speech-to-Speech (S2S) endpoint configuration.
@@ -40,3 +42,4 @@ export type S2SConfig = {
 };
 /** Default S2S endpoint configuration. */
 export declare const DEFAULT_S2S_CONFIG: S2SConfig;
+export {};

package/dist/host/runtime.d.ts

@@ -17,6 +17,7 @@ import type { Logger, S2SConfig } from "./runtime-config.ts";
 import type { CreateS2sWebSocket } from "./s2s.ts";
 import { type SessionCore } from "./session-core.ts";
 import { type ExecuteTool } from "./tool-executor.ts";
+import { type CreateOpenaiRealtimeWebSocket } from "./transports/openai-realtime-transport.ts";
 import { type SessionWebSocket } from "./ws-handler.ts";
 /** Per-session options passed to {@link AgentRuntime.startSession}. */
 export type SessionStartOptions = {
@@ -58,6 +59,8 @@ export type RuntimeOptions = {
     vector?: Vector | undefined;
     /** Custom WebSocket factory for the S2S connection (useful for testing). */
     createWebSocket?: CreateS2sWebSocket | undefined;
+    /** Custom WebSocket factory for the OpenAI Realtime connection (testing). */
+    createOpenaiRealtimeWebSocket?: CreateOpenaiRealtimeWebSocket | undefined;
     logger?: Logger | undefined;
     s2sConfig?: S2SConfig | undefined;
     /**

package/dist/host/to-vercel-tools.d.ts

@@ -1,45 +1,15 @@
 /**
- * Converts agent {@link ToolSchema}[] to Vercel AI SDK tools with `execute`
- * delegation to the agent's {@link ExecuteTool} function.
- *
- * The pipeline orchestrator passes the output to `streamText({ tools })`.
- * Each produced tool's `execute` closure calls
- * `ctx.executeTool(name, args, sessionId, messages(), { signal, toolCallId })`,
- * so the existing agent tool infrastructure (argument validation, KV, hooks,
- * timeout) remains the single source of truth for tool behavior.
- *
- * Per-call `options.abortSignal` (forwarded by `streamText` when the
- * outer turn is aborted, e.g. barge-in) takes precedence over the
- * bag-level `ctx.signal` so individual invocations respect streamText
- * aborts.
+ * Converts agent {@link ToolSchema}[] to Vercel AI SDK tools, delegating
+ * `execute` to the agent's {@link ExecuteTool} so validation, KV, hooks,
+ * and timeouts remain the single source of truth for tool behavior.
  */
 import { type Tool } from "ai";
 import type { ExecuteTool, ToolSchema } from "../sdk/_internal-types.ts";
 import type { Message } from "../sdk/types.ts";
 export interface ToVercelToolsContext {
-    /** The agent's tool-execution function (from the runtime). */
     executeTool: ExecuteTool;
-    /** Session id threaded to {@link executeTool}. */
     sessionId: string;
-    /**
-     * Returns the current conversation history at call-time. The orchestrator
-     * calls this per invocation; `toVercelTools` snapshots the returned array
-     * before forwarding to `executeTool` so concurrent mutations cannot leak
-     * across tool calls.
-     */
     messages: () => readonly Message[];
-    /**
-     * Bag-level abort signal. Used as a fallback when the per-call
-     * `options.abortSignal` from Vercel's `ToolExecutionOptions` is absent.
-     */
     signal?: AbortSignal;
 }
-/**
- * Convert an array of {@link ToolSchema} to a Vercel AI SDK `ToolSet`
- * (record keyed by tool name).
- *
- * Uses the v6 `tool()` helper with `inputSchema: jsonSchema(...)` wrapping
- * the agent's JSON Schema `parameters`. Execution is delegated to
- * `ctx.executeTool` so validation, KV, timeouts, and hooks keep working.
- */
 export declare function toVercelTools(schemas: readonly ToolSchema[], ctx: ToVercelToolsContext): Record<string, Tool>;

package/dist/host/transports/openai-realtime-transport.d.ts

@@ -0,0 +1,43 @@
+import type { JSONSchema7 } from "json-schema";
+import type { OpenaiRealtimeOptions } from "../../sdk/providers/s2s/openai-realtime.ts";
+import type { Logger } from "../runtime-config.ts";
+import type { Transport, TransportCallbacks, TransportSessionConfig } from "./types.ts";
+export type OpenaiRealtimeWebSocket = {
+    readonly readyState: number;
+    send(data: string): void;
+    close(): void;
+    addEventListener(type: "open", fn: () => void): void;
+    addEventListener(type: "message", fn: (ev: {
+        data: unknown;
+    }) => void): void;
+    addEventListener(type: "close", fn: (ev: {
+        code?: number;
+        reason?: string;
+    }) => void): void;
+    addEventListener(type: "error", fn: (ev: {
+        message?: string;
+    }) => void): void;
+};
+export type CreateOpenaiRealtimeWebSocket = (url: string, opts: {
+    headers: Record<string, string>;
+}) => OpenaiRealtimeWebSocket;
+export declare const defaultCreateOpenaiRealtimeWebSocket: CreateOpenaiRealtimeWebSocket;
+export type OpenaiRealtimeToolSchema = {
+    type: "function";
+    name: string;
+    description: string;
+    parameters: JSONSchema7;
+};
+export type OpenaiRealtimeTransportOptions = {
+    apiKey: string;
+    options: OpenaiRealtimeOptions;
+    sessionConfig: TransportSessionConfig;
+    toolSchemas: OpenaiRealtimeToolSchema[];
+    toolChoice: "auto" | "required";
+    callbacks: TransportCallbacks;
+    sid: string;
+    agent: string;
+    createWebSocket?: CreateOpenaiRealtimeWebSocket;
+    logger?: Logger;
+};
+export declare function createOpenaiRealtimeTransport(opts: OpenaiRealtimeTransportOptions): Transport;

package/dist/host/unstorage-kv.d.ts

@@ -1,33 +1,7 @@
-/**
- * Key-value store backed by unstorage.
- *
- * Works with any unstorage driver (memory, fs, S3/R2, etc.).
- */
 import { type Storage } from "unstorage";
 import type { Kv } from "../sdk/kv.ts";
-/**
- * Options for creating an unstorage-backed KV store.
- */
 export type UnstorageKvOptions = {
-    /** Configured unstorage Storage instance. */
     storage: Storage;
-    /** Key prefix prepended to all operations (e.g. `"agents/my-agent/kv"`). */
     prefix?: string;
 };
-/**
- * Create a KV store backed by any unstorage driver.
- *
- * @param options - See {@link UnstorageKvOptions}.
- * @returns A {@link Kv} instance.
- *
- * @example
- * ```ts
- * import { createStorage } from "unstorage";
- * import { createUnstorageKv } from "@alexkroman1/aai/unstorage-kv";
- *
- * const kv = createUnstorageKv({ storage: createStorage() });
- * await kv.set("greeting", "hello");
- * const value = await kv.get<string>("greeting"); // "hello"
- * ```
- */
 export declare function createUnstorageKv(options: UnstorageKvOptions): Kv;

package/dist/index.js

@@ -1,6 +1,6 @@
-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";
+import { a as matchesAllowedHost, i as ToolChoiceSchema, n as DEFAULT_GREETING, o as validateAllowedHostPattern, r as DEFAULT_SYSTEM_PROMPT, t as BuiltinToolSchema } from "./types-DOWVZhb9.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-y68COEGj.js";
+import { i as toolError, n as errorDetail, r as errorMessage, t as parseWsUpgradeParams } from "./ws-upgrade-CG8-by1n.js";
 //#region sdk/define.ts
 /**
 * Define a tool with typed parameters and execute function.

package/dist/openai-realtime-cjPAHMMx.js

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

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

@@ -1,40 +1,13 @@
-/**
- * Internal type definitions shared by server and CLI.
- *
- * Note: this module is for internal use only and should not be used directly.
- */
 import type { JSONSchema7 } from "json-schema";
 import { z } from "zod";
-import { type KvProvider, type LlmProvider, type SttProvider, type TtsProvider, type VectorProvider } from "./providers.ts";
+import { type KvProvider, type LlmProvider, type S2sProvider, type SttProvider, type TtsProvider, type VectorProvider } from "./providers.ts";
 import type { Message } from "./types.ts";
 import { type ToolDef } from "./types.ts";
-/**
- * Options forwarded to an {@link ExecuteTool} invocation.
- *
- * Primarily used by the pipeline orchestrator (streamText tool loop) to
- * thread an {@link AbortSignal} into tool execution. The S2S voice path
- * does not pass these options today — recipients must treat the whole
- * bag as optional.
- */
 export interface ExecuteToolOptions {
-    /** Abort signal bound to the enclosing LLM turn / request. */
     signal?: AbortSignal;
-    /** Vercel AI SDK tool-call ID for this invocation. Useful for tracing and correlation. */
     toolCallId?: string;
 }
-/**
- * Function signature for executing a tool by name.
- *
- * Used by session.ts to invoke tools, by direct-executor.ts and
- * harness-runtime.ts to implement the execution.
- */
 export type ExecuteTool = (name: string, args: Readonly<Record<string, unknown>>, sessionId?: string, messages?: readonly Message[], opts?: ExecuteToolOptions) => Promise<string>;
-/**
- * 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.
- */
 export declare const AgentConfigSchema: z.ZodObject<{
     name: z.ZodString;
     systemPrompt: z.ZodString;
@@ -64,6 +37,10 @@ export declare const AgentConfigSchema: z.ZodObject<{
         kind: z.ZodString;
         options: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, z.core.$strip>>;
+    s2s: 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";
@@ -77,13 +54,7 @@ export declare const AgentConfigSchema: z.ZodObject<{
         options: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-/** Serializable agent configuration — derived from {@link AgentConfigSchema}. */
 export type AgentConfig = z.infer<typeof AgentConfigSchema>;
-/**
- * Input shape accepted by {@link toAgentConfig}. Covers both `AgentDef`
- * (where `maxSteps` may be a function) and `IsolateConfig` (where it is
- * always a number).
- */
 export interface AgentConfigSource {
     name: string;
     systemPrompt: string;
@@ -96,42 +67,22 @@ export interface AgentConfigSource {
     stt?: SttProvider | undefined;
     llm?: LlmProvider | undefined;
     tts?: TtsProvider | undefined;
+    s2s?: S2sProvider | undefined;
     kv?: KvProvider | undefined;
     vector?: VectorProvider | undefined;
 }
-/**
- * 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.
- *
- * `parameters` must be a valid JSON Schema object (with `type`, `properties`,
- * etc.) — the Vercel AI SDK wraps it via `jsonSchema()`.
- */
 export declare const ToolSchemaSchema: z.ZodObject<{
     type: z.ZodLiteral<"function">;
     name: z.ZodString;
     description: z.ZodString;
     parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, z.core.$strip>;
-/** Serialized tool schema — derived from {@link ToolSchemaSchema}. */
 export type ToolSchema = {
     type: "function";
     name: string;
     description: string;
     parameters: JSONSchema7;
 };
-/** Empty Zod object schema used as default when tools have no parameters. */
 export declare const EMPTY_PARAMS: z.ZodObject<{}, z.core.$strip>;
-/**
- * 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.
- */
 export declare function agentToolsToSchemas(tools: Readonly<Record<string, ToolDef>>): ToolSchema[];

package/dist/sdk/allowed-hosts.d.ts

@@ -7,12 +7,13 @@
  * Lives in sdk/ because it has zero Node.js dependencies and can run in any
  * environment (browser, Deno, Node.js sandboxes).
  */
-type ValidationResult = {
-    valid: true;
-} | {
+type ValidationFailure = {
     valid: false;
     reason: string;
 };
+type ValidationResult = {
+    valid: true;
+} | ValidationFailure;
 /**
  * Validate a single `allowedHosts` pattern at deploy time.
  *

package/dist/sdk/constants.d.ts

@@ -1,51 +1,26 @@
-/**
- * Centralised numeric constants — timeouts, size limits, sample rates.
- *
- * Every magic number that controls a timeout, buffer size, or threshold
- * lives here so the values are discoverable in one place.
- */
-/** Default sample rate for speech-to-text audio in Hz (AssemblyAI). */
 export declare const DEFAULT_STT_SAMPLE_RATE = 16000;
-/** Default sample rate for text-to-speech audio in Hz. */
 export declare const DEFAULT_TTS_SAMPLE_RATE = 24000;
-/** Default timeout for tool execution in the worker. */
 export declare const TOOL_EXECUTION_TIMEOUT_MS = 30000;
-/** Timeout for session.start() (S2S connection setup). */
 export declare const DEFAULT_SESSION_START_TIMEOUT_MS = 10000;
-/** S2S session idle timeout before auto-close. */
 export declare const DEFAULT_IDLE_TIMEOUT_MS = 300000;
-/** Per-fetch timeout for network tools (web_search, visit_webpage, fetch_json). */
 export declare const FETCH_TIMEOUT_MS = 15000;
-/** Timeout for sandboxed run_code execution. */
 export declare const RUN_CODE_TIMEOUT_MS = 5000;
-/** Maximum time to wait for sessions to stop during graceful shutdown. */
 export declare const DEFAULT_SHUTDOWN_TIMEOUT_MS = 30000;
 /**
- * Maximum time to wait for a pipeline-mode TTS drain after `flush()` before
- * forcing the turn to complete. Prevents a stuck TTS provider from wedging
- * the session. Short relative to `DEFAULT_SHUTDOWN_TIMEOUT_MS` so stop()
- * can still reclaim the socket cleanly.
+ * Short relative to `DEFAULT_SHUTDOWN_TIMEOUT_MS` so a stuck TTS provider
+ * can't wedge the session — stop() must still reclaim the socket cleanly.
  */
 export declare const PIPELINE_FLUSH_TIMEOUT_MS = 10000;
-/** Maximum length for tool result strings sent to clients. */
 export declare const MAX_TOOL_RESULT_CHARS = 4000;
-/** Maximum chars for webpage text after HTML-to-text conversion. */
 export declare const MAX_PAGE_CHARS = 10000;
-/** Maximum bytes to fetch from an HTML page before conversion. */
 export declare const MAX_HTML_BYTES = 200000;
-/** Maximum value size for KV store entries (bytes). */
 export declare const MAX_VALUE_SIZE = 65536;
-/** Maximum conversation messages to retain (sliding window). */
 export declare const DEFAULT_MAX_HISTORY = 200;
-/** Maximum WebSocket message payload size (bytes, 1 MiB). */
 export declare const MAX_WS_PAYLOAD_BYTES: number;
-/** Maximum messages buffered while session.start() is pending. */
 export declare const MAX_MESSAGE_BUFFER_SIZE = 100;
-/** WebSocket readyState value indicating the connection is open. */
 export declare const WS_OPEN = 1;
 /**
- * Content-Security-Policy applied to agent UI pages (both self-hosted and
- * platform). Single source of truth — used by `secureHeaders` middleware
- * and per-response CSP headers.
+ * Single source of truth — used by `secureHeaders` middleware and
+ * per-response CSP headers across self-hosted and platform agent UIs.
  */
 export declare const AGENT_CSP: string;

package/dist/sdk/define.d.ts

@@ -1,8 +1,5 @@
-/**
- * Helper functions for defining agents and tools with full type inference.
- */
 import type { z } from "zod";
-import type { KvProvider, LlmProvider, SttProvider, TtsProvider, VectorProvider } from "./providers.ts";
+import type { KvProvider, LlmProvider, S2sProvider, SttProvider, TtsProvider, VectorProvider } from "./providers.ts";
 import { type AgentDef, type BuiltinTool, type ToolChoice, type ToolContext, type ToolDef } from "./types.ts";
 /**
  * Define a tool with typed parameters and execute function.
@@ -84,6 +81,12 @@ export declare function agent(def: {
      * enable pipeline mode.
      */
     tts?: TtsProvider;
+    /**
+     * Pluggable S2S provider descriptor. When set, overrides the implicit
+     * AssemblyAI default. Mutually exclusive with the `stt`/`llm`/`tts`
+     * pipeline triple.
+     */
+    s2s?: S2sProvider;
     /** Pluggable KV backend. Falls back to platform default when omitted. */
     kv?: KvProvider;
     /** Pluggable Vector backend. Falls back to platform default when omitted. */

package/dist/sdk/kv.d.ts

@@ -1,60 +1,36 @@
-/**
- * Key-value storage interface and shared utilities.
- */
 /**
  * Async key-value store interface used by agents.
  *
- * Agents access the KV store via `ToolContext.kv`. Values are JSON-serialized and stored as
- * strings with an optional TTL.
+ * Agents access the KV store via `ToolContext.kv`. Values are JSON-serialized
+ * and stored as strings with an optional TTL.
  *
  * @example
  * ```ts
- * // Inside a tool execute function:
- * const myTool = {
- *   description: "Save and retrieve data",
- *   execute: async (_args: unknown, ctx: { kv: Kv }) => {
- *     await ctx.kv.set("user:name", "Alice", { expireIn: 60_000 });
- *     const name = await ctx.kv.get<string>("user:name");
- *     return name; // "Alice"
- *   },
- * };
+ * await ctx.kv.set("user:name", "Alice", { expireIn: 60_000 });
+ * const name = await ctx.kv.get<string>("user:name"); // "Alice"
  * ```
  *
  * @public
  */
 export type Kv = {
-    /**
-     * Get a value by key, or `null` if not found.
-     *
-     * @typeParam T - The expected type of the stored value.
-     * @param key - The key to look up.
-     * @returns The deserialized value, or `null` if the key does not exist
-     *   or has expired.
-     */
+    /** Get a value by key. Returns `null` if missing or expired. */
     get<T = unknown>(key: string): Promise<T | null>;
     /**
-     * Set a value, optionally with a TTL in milliseconds.
+     * Set a value, optionally with a TTL.
      *
-     * @param key - The key to store the value under.
-     * @param value - The value to store. Must be JSON-serializable.
-     * @param options - Optional settings. `expireIn` sets the time-to-live in **milliseconds**
-     *   (e.g. `60_000` for 1 minute). The entry is automatically removed after this duration.
-     * @throws Throws an Error if the serialized value exceeds 65,536 bytes.
+     * @param options.expireIn - Time-to-live in **milliseconds** (e.g. `60_000`
+     *   for 1 minute). The entry is automatically removed after this duration.
+     * @throws If the serialized value exceeds 65,536 bytes.
      */
     set(key: string, value: unknown, options?: {
         expireIn?: number;
     }): Promise<void>;
-    /**
-     * Delete one or more keys.
-     *
-     * @param keys - A single key or array of keys to delete. No-op for keys that do not exist.
-     */
+    /** Delete one or more keys. No-op for keys that do not exist. */
     delete(keys: string | string[]): Promise<void>;
     /**
-     * Close the KV store, releasing any resources (intervals, database handles).
-     *
-     * After calling `close()`, the store must not be used. This is a no-op
-     * for implementations that hold no resources (e.g. in-memory stores).
+     * Release any held resources (intervals, database handles). After calling,
+     * the store must not be used. No-op for stateless implementations (e.g.
+     * in-memory stores).
      */
     close?(): void;
 };

package/dist/sdk/manifest-barrel.js

@@ -1,2 +1,2 @@
-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-CrnTi9Ew.js";
+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-CfOAbK6V.js";
 export { AgentConfigSchema, EMPTY_PARAMS, ProviderDescriptorSchema, ToolSchemaSchema, agentToolsToSchemas, assertProviderTriple, toAgentConfig };

package/dist/sdk/manifest.d.ts

@@ -5,7 +5,7 @@
  * then used as a plain typed object throughout the runtime.
  */
 import { z } from "zod";
-import { type KvProvider, type LlmProvider, type SessionMode, type SttProvider, type TtsProvider, type VectorProvider } from "./providers.ts";
+import { type KvProvider, type LlmProvider, type S2sProvider, type SessionMode, type SttProvider, type TtsProvider, type VectorProvider } from "./providers.ts";
 /**
  * Tool definition as it appears in the serialized manifest JSON.
  *
@@ -56,13 +56,19 @@ export type Manifest = {
      * enable pipeline mode.
      */
     tts?: TtsProvider | undefined;
+    /**
+     * Pluggable S2S provider descriptor. When set, overrides the implicit
+     * AssemblyAI default. Mutually exclusive with the `stt`/`llm`/`tts`
+     * pipeline triple.
+     */
+    s2s?: S2sProvider | undefined;
     /** Pluggable KV backend descriptor. Falls back to platform default when omitted. */
     kv?: KvProvider | undefined;
     /** Pluggable Vector backend descriptor. Falls back to platform default when omitted. */
     vector?: VectorProvider | undefined;
     /**
      * Session mode derived from provider fields:
-     * - `"s2s"` (default): AssemblyAI Streaming Speech-to-Speech path (no stt/llm/tts set).
+     * - `"s2s"`: speech-to-speech path (default when no stt/llm/tts set, or when `s2s` is set).
      * - `"pipeline"`: pluggable STT → LLM → TTS path (stt + llm + tts all set).
      */
     mode: SessionMode;

package/dist/sdk/protocol.js

@@ -1,4 +1,4 @@
-import { f as MAX_TOOL_RESULT_CHARS } from "../constants-C2nirZUI.js";
+import { f as MAX_TOOL_RESULT_CHARS } from "../constants-y68COEGj.js";
 import { z } from "zod";
 //#region sdk/protocol.ts
 /**

package/dist/sdk/providers/s2s/openai-realtime.d.ts

@@ -0,0 +1,17 @@
+/** OpenAI Realtime S2S descriptor — host transport resolves at session start. */
+import type { S2sProvider } from "../../providers.ts";
+export declare const OPENAI_REALTIME_KIND: "openai-realtime";
+export type OpenaiRealtimeVoice = "alloy" | "ash" | "ballad" | "cedar" | "coral" | "echo" | "marin" | "sage" | "shimmer" | "verse";
+export type OpenaiRealtimeOptions = {
+    /** Realtime model identifier. Default applied by the host (currently `"gpt-realtime-2"`). */
+    model?: string;
+    /** TTS voice. Default applied by the host (currently `"alloy"`). */
+    voice?: OpenaiRealtimeVoice;
+    /** Override the WebSocket base URL (testing/proxy). */
+    url?: string;
+};
+export type OpenaiRealtimeProvider = S2sProvider & {
+    readonly kind: typeof OPENAI_REALTIME_KIND;
+    readonly options: OpenaiRealtimeOptions;
+};
+export declare function openaiRealtime(opts?: OpenaiRealtimeOptions): OpenaiRealtimeProvider;

package/dist/sdk/providers/s2s-barrel.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `@alexkroman1/aai/s2s` subpath barrel.
+ *
+ * Re-exports S2S descriptor factories. Importing this barrel does not
+ * pull in any provider SDK — the host resolver handles that at session
+ * start.
+ */
+export type { S2sProvider } from "../providers.ts";
+export * from "./s2s/openai-realtime.ts";

package/dist/sdk/providers/s2s-barrel.js

@@ -0,0 +1,2 @@
+import { n as openaiRealtime, t as OPENAI_REALTIME_KIND } from "../../openai-realtime-cjPAHMMx.js";
+export { OPENAI_REALTIME_KIND, openaiRealtime };

package/dist/sdk/providers/tts/rime.d.ts

@@ -24,7 +24,7 @@ export interface RimeOptions {
      * Rime model ID. Defaults to `"mistv2"` (Rime's most compatible model).
      * Common values: `"mistv2"`, `"arcana"`.
      */
-    model?: "mistv2" | "arcana" | string;
+    model?: string;
     /**
      * Spoken language. Uses ISO 639-3 (three-letter codes).
      * Defaults to `"eng"` (English).

package/dist/sdk/providers.d.ts

@@ -39,6 +39,8 @@ export type SttProvider = ProviderDescriptor<string, Record<string, unknown>>;
 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>>;
+/** Descriptor for an S2S provider. Returned by factories like `openaiRealtime(...)`. */
+export type S2sProvider = ProviderDescriptor<string, Record<string, unknown>>;
 /** Descriptor for a KV backend. Returned by factories like `redisKv()`. */
 export type KvProvider = ProviderDescriptor<string, Record<string, unknown>>;
 /** Descriptor for a Vector backend. Returned by factories like `pinecone(...)`. */
@@ -55,9 +57,11 @@ 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.
+ * none of them. Anything in-between is a configuration error. An optional
+ * `s2s` descriptor selects a non-default S2S provider — it must not be
+ * combined with any pipeline field.
  */
-export declare function assertProviderTriple(stt: unknown, llm: unknown, tts: unknown): SessionMode;
+export declare function assertProviderTriple(stt: unknown, llm: unknown, tts: unknown, s2s?: unknown): SessionMode;
 export interface SttError extends Error {
     readonly code: "stt_connect_failed" | "stt_auth_failed" | "stt_stream_error";
 }

package/dist/sdk/types.d.ts

@@ -3,7 +3,7 @@
  */
 import { z } from "zod";
 import type { Kv } from "./kv.ts";
-import type { KvProvider, LlmProvider, SttProvider, TtsProvider, VectorProvider } from "./providers.ts";
+import type { KvProvider, LlmProvider, S2sProvider, SttProvider, TtsProvider, VectorProvider } from "./providers.ts";
 import type { Vector } from "./vector.ts";
 /**
  * Identifier for a built-in server-side tool.
@@ -207,6 +207,12 @@ export type AgentDef<S = Record<string, unknown>> = {
      * pipeline mode.
      */
     tts?: TtsProvider;
+    /**
+     * Pluggable S2S provider descriptor. When set, overrides the implicit
+     * AssemblyAI default. Mutually exclusive with the `stt`/`llm`/`tts`
+     * pipeline triple.
+     */
+    s2s?: S2sProvider;
     /** Pluggable KV backend. Falls back to platform default when omitted. */
     kv?: KvProvider;
     /** Pluggable Vector backend. Falls back to platform default when omitted. */

package/dist/{types-KUgezM6u.js → types-DOWVZhb9.js}

@@ -9,16 +9,11 @@ import { z } from "zod";
 * 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 {
@@ -76,8 +71,7 @@ function validateAllowedHostPattern(pattern) {
 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(/\.$/, "");
+	const host = (portIndex !== -1 && !hostname.includes("[") ? hostname.slice(0, portIndex) : hostname).toLowerCase().replace(/\.$/, "");
 	for (const pattern of patterns) {
 		const p = pattern.toLowerCase();
 		if (p.startsWith("*.")) {