@alexkroman1/aai 1.7.0 → 1.8.0

package/host/runtime-config.ts

@@ -12,6 +12,10 @@ import { DEFAULT_STT_SAMPLE_RATE, DEFAULT_TTS_SAMPLE_RATE } from "../sdk/constan
 /** 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.
@@ -27,15 +31,10 @@ 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>;
 
-function consoleLog(fn: typeof console.log): Logger[keyof Logger] {
-  return (msg: string, ctx?: LogContext) => (ctx ? fn(msg, ctx) : fn(msg));
+function consoleLog(fn: typeof console.log): LogFn {
+  return (msg, ctx) => (ctx ? fn(msg, ctx) : fn(msg));
 }
 
 /** Default console-backed logger. */
@@ -46,29 +45,24 @@ export const consoleLogger: Logger = {
   debug: consoleLog(console.debug),
 };
 
-/**
- * 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.
- */
-function jsonLog(level: string) {
-  return (msg: string, ctx?: LogContext): void => {
+function jsonLog(level: LogLevel): LogFn {
+  const out = level === "error" || level === "warn" ? process.stderr : process.stdout;
+  return (msg, ctx) => {
     const entry: Record<string, unknown> = {
       timestamp: new Date().toISOString(),
       level,
       msg,
+      ...ctx,
     };
-
-    if (ctx) {
-      Object.assign(entry, ctx);
-    }
-
-    // Single-line JSON to stdout/stderr based on level.
-    const out = level === "error" || level === "warn" ? process.stderr : process.stdout;
     out.write(`${JSON.stringify(entry)}\n`);
   };
 }
 
+/**
+ * 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 const jsonLogger: Logger = {
   info: jsonLog("info"),
   warn: jsonLog("warn"),

package/host/runtime.test.ts

@@ -4,6 +4,8 @@ import { createStorage } from "unstorage";
 import { afterEach, describe, expect, test, vi } from "vitest";
 import { z } from "zod";
 import { toAgentConfig } from "../sdk/_internal-types.ts";
+import { openaiRealtime } from "../sdk/providers/s2s/openai-realtime.ts";
+import type { S2sProvider } from "../sdk/providers.ts";
 import type { ToolDef } from "../sdk/types.ts";
 import {
   createFakeLanguageModel,
@@ -14,9 +16,22 @@ import { CONFORMANCE_AGENT, testRuntime } from "./_runtime-conformance.ts";
 import { flush, makeAgent, makeClientSink, makeMockHandle, silentLogger } from "./_test-utils.ts";
 import { createRuntime } from "./runtime.ts";
 import { executeToolCall } from "./tool-executor.ts";
+import type { OpenaiRealtimeWebSocket } from "./transports/openai-realtime-transport.ts";
 import { _internals } from "./transports/s2s-transport.ts";
 import { createUnstorageKv } from "./unstorage-kv.ts";
 
+function makeLogger() {
+  return { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
+}
+
+function makeMockWs() {
+  return {
+    readyState: 1,
+    send: vi.fn(),
+    addEventListener: vi.fn(),
+  };
+}
+
 describe("toAgentConfig", () => {
   test("maps name, systemPrompt, greeting from AgentDef", () => {
     const config = toAgentConfig(makeAgent());
@@ -237,7 +252,7 @@ describe("executeToolCall", () => {
         throw new Error("boom");
       },
     };
-    const logger = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
+    const logger = makeLogger();
     const result = await executeToolCall("failTool", {}, { tool, env: {}, logger });
     expect(result).toContain("error");
     expect(result).toContain("boom");
@@ -276,7 +291,7 @@ describe("executeToolCall", () => {
         return "ok";
       },
     };
-    const logger = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
+    const logger = makeLogger();
     const result = await executeToolCall("kvTool", {}, { tool, env: {}, logger });
     expect(result).toContain("error");
     expect(result).toContain("KV not available");
@@ -333,7 +348,6 @@ describe("createRuntime sandbox mode", () => {
       toolSchemas: mockToolSchemas,
     });
 
-    // Should use the provided overrides, not build its own
     expect(runtime.toolSchemas).toBe(mockToolSchemas);
     const result = await runtime.executeTool("any_tool", {}, "s1", []);
     expect(result).toBe("mocked-result");
@@ -346,37 +360,17 @@ describe("createRuntime shutdown", () => {
     vi.restoreAllMocks();
   });
 
-  /** Helper: create a mock WS (readyState=1) that captures event listeners. */
-  function makeMockWs() {
-    const listeners: Record<string, Array<(...args: unknown[]) => void>> = {};
-    return {
-      readyState: 1,
-      send: vi.fn(),
-      listeners,
-      addEventListener: vi.fn((type: string, listener: (...args: unknown[]) => void) => {
-        if (!listeners[type]) listeners[type] = [];
-        listeners[type].push(listener);
-      }),
-    };
-  }
-
   test("shutdown stops active sessions gracefully", async () => {
     const mockHandle = makeMockHandle();
     const connectSpy = vi.spyOn(_internals, "connectS2s").mockResolvedValue(mockHandle);
 
-    const agent = makeAgent();
-    const runtime = createRuntime({ agent, env: {}, logger: silentLogger });
-    const ws = makeMockWs();
-
-    // readyState=1 means onOpen fires immediately in wireSessionSocket
-    runtime.startSession(ws as never);
+    const runtime = createRuntime({ agent: makeAgent(), env: {}, logger: silentLogger });
+    runtime.startSession(makeMockWs() as never);
 
-    // Wait for session.start() to resolve (fires on next tick via setTimeout)
     await vi.waitFor(() => {
       expect(connectSpy).toHaveBeenCalled();
     });
     await flush();
-    // Give session.start() time to resolve
     await new Promise((r) => setTimeout(r, 50));
 
     await expect(runtime.shutdown()).resolves.toBeUndefined();
@@ -384,19 +378,14 @@ describe("createRuntime shutdown", () => {
   });
 
   test("shutdown warns when a session stop rejects", async () => {
-    const logger = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
     const mockHandle = makeMockHandle();
-    // Make close() throw to cause session.stop() to reject
     mockHandle.close = vi.fn(() => {
       throw new Error("close failed");
     });
     const connectSpy = vi.spyOn(_internals, "connectS2s").mockResolvedValue(mockHandle);
 
-    const agent = makeAgent();
-    const runtime = createRuntime({ agent, env: {}, logger });
-    const ws = makeMockWs();
-
-    runtime.startSession(ws as never);
+    const runtime = createRuntime({ agent: makeAgent(), env: {}, logger: makeLogger() });
+    runtime.startSession(makeMockWs() as never);
 
     await vi.waitFor(() => {
       expect(connectSpy).toHaveBeenCalled();
@@ -404,31 +393,23 @@ describe("createRuntime shutdown", () => {
     await flush();
 
     await runtime.shutdown();
-    // The session stop rejection should be caught and logged
-    // (Note: whether the warn fires depends on whether stop() actually rejects
-    // from close() throwing — session.stop() may catch it internally)
     connectSpy.mockRestore();
   });
 
   test("shutdown warns on timeout when sessions hang", async () => {
-    const logger = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
     const mockHandle = makeMockHandle();
-    // Make close() hang forever so stop() never resolves
     mockHandle.close = vi.fn(() => {
-      // intentionally do nothing — session stop will hang
+      /* no-op */
     });
     const connectSpy = vi.spyOn(_internals, "connectS2s").mockResolvedValue(mockHandle);
 
-    const agent = makeAgent();
     const runtime = createRuntime({
-      agent,
+      agent: makeAgent(),
       env: {},
-      logger,
-      shutdownTimeoutMs: 50, // Very short timeout
+      logger: makeLogger(),
+      shutdownTimeoutMs: 50,
     });
-    const ws = makeMockWs();
-
-    runtime.startSession(ws as never);
+    runtime.startSession(makeMockWs() as never);
 
     await vi.waitFor(() => {
       expect(connectSpy).toHaveBeenCalled();
@@ -436,7 +417,6 @@ describe("createRuntime shutdown", () => {
     await flush();
 
     await runtime.shutdown();
-    // Whether timeout warning fires depends on internal session map population
     connectSpy.mockRestore();
   });
 
@@ -448,8 +428,9 @@ describe("createRuntime shutdown", () => {
         increment: {
           description: "Increment counter",
           execute: (_args, ctx) => {
-            (ctx.state as { counter: number }).counter++;
-            return String((ctx.state as { counter: number }).counter);
+            const state = ctx.state as { counter: number };
+            state.counter++;
+            return String(state.counter);
           },
         },
         get_state: {
@@ -460,13 +441,10 @@ describe("createRuntime shutdown", () => {
     });
     const runtime = createRuntime({ agent, env: {} });
 
-    // First call creates state
     await runtime.executeTool("increment", {}, "s1", []);
-    // Second call reuses same state
     await runtime.executeTool("increment", {}, "s1", []);
     const result = await runtime.executeTool("get_state", {}, "s1", []);
     expect(JSON.parse(result)).toEqual({ counter: 2 });
-    // State factory should have been called only once
     expect(stateFactory).toHaveBeenCalledTimes(1);
   });
 });
@@ -494,7 +472,6 @@ describe("createRuntime createSession", () => {
     const agent = makeAgent();
     const runtime = createRuntime({ agent, env: {} });
     const client = makeClientSink();
-    // Should not throw when skipGreeting is set
     const session = runtime.createSession({
       id: "test-session",
       agent: agent.name,
@@ -520,16 +497,10 @@ describe("createRuntime createSession", () => {
 
 describe("createRuntime startSession", () => {
   test("startSession wires WebSocket and passes options", () => {
-    const agent = makeAgent();
-    const runtime = createRuntime({ agent, env: {}, logger: silentLogger });
-    const mockWs = {
-      readyState: 1,
-      send: vi.fn(),
-      addEventListener: vi.fn(),
-    };
+    const runtime = createRuntime({ agent: makeAgent(), env: {}, logger: silentLogger });
+    const ws = makeMockWs();
 
-    // Should not throw
-    runtime.startSession(mockWs as never, {
+    runtime.startSession(ws as never, {
       skipGreeting: true,
       resumeFrom: "prev-session",
       logContext: { userId: "u1" },
@@ -537,21 +508,15 @@ describe("createRuntime startSession", () => {
       onClose: vi.fn(),
     });
 
-    // addEventListener should have been called to wire up the WebSocket
-    expect(mockWs.addEventListener).toHaveBeenCalled();
+    expect(ws.addEventListener).toHaveBeenCalled();
   });
 
   test("startSession works with no options", () => {
-    const agent = makeAgent();
-    const runtime = createRuntime({ agent, env: {}, logger: silentLogger });
-    const mockWs = {
-      readyState: 1,
-      send: vi.fn(),
-      addEventListener: vi.fn(),
-    };
+    const runtime = createRuntime({ agent: makeAgent(), env: {}, logger: silentLogger });
+    const ws = makeMockWs();
 
-    runtime.startSession(mockWs as never);
-    expect(mockWs.addEventListener).toHaveBeenCalled();
+    runtime.startSession(ws as never);
+    expect(ws.addEventListener).toHaveBeenCalled();
   });
 });
 
@@ -582,7 +547,6 @@ describe("createRuntime with custom options", () => {
       env: { ASSEMBLYAI_API_KEY: "test-api-key" },
     });
     const client = makeClientSink();
-    // Should not throw — the API key gets passed to createS2sTransport internally
     const session = runtime.createSession({
       id: "test-session",
       agent: agent.name,
@@ -676,6 +640,80 @@ describe("Runtime — session routing", () => {
     await session.stop();
     connectSpy.mockRestore();
   });
+
+  test("agent.s2s = openaiRealtime() routes to OpenAI Realtime transport", async () => {
+    type Listener = (ev: unknown) => void;
+    const listeners: Record<string, Listener[]> = {
+      open: [],
+      message: [],
+      close: [],
+      error: [],
+    };
+    const fakeWs: OpenaiRealtimeWebSocket = {
+      readyState: 1,
+      send: vi.fn(),
+      close: vi.fn(),
+      addEventListener: ((type: string, fn: Listener) => {
+        (listeners[type] ?? []).push(fn);
+      }) as OpenaiRealtimeWebSocket["addEventListener"],
+    };
+    let capturedUrl: string | null = null;
+    let capturedOpts: { headers: Record<string, string> } | null = null;
+    const createOpenaiRealtimeWebSocket = vi.fn(
+      (url: string, wsOpts: { headers: Record<string, string> }) => {
+        capturedUrl = url;
+        capturedOpts = wsOpts;
+        return fakeWs;
+      },
+    );
+
+    const runtime = createRuntime({
+      agent: makeAgent({ s2s: openaiRealtime({ model: "gpt-realtime" }) }),
+      env: { OPENAI_API_KEY: "sk-test" },
+      logger: silentLogger,
+      createOpenaiRealtimeWebSocket,
+    });
+
+    const client = makeClientSink();
+    const session = runtime.createSession({
+      id: "sess-openai-realtime",
+      agent: "test-agent",
+      client,
+    });
+
+    const startP = session.start();
+    // Drive the WS open so transport.start() resolves
+    for (const fn of listeners.open ?? []) fn(undefined);
+    await startP;
+
+    expect(createOpenaiRealtimeWebSocket).toHaveBeenCalledTimes(1);
+    expect(capturedUrl).toContain("api.openai.com");
+    expect(capturedUrl).toContain("model=gpt-realtime");
+    expect(capturedOpts).toMatchObject({
+      headers: { Authorization: "Bearer sk-test" },
+    });
+
+    await session.stop();
+  });
+
+  test("createSession throws on unknown s2s provider kind", () => {
+    const runtime = createRuntime({
+      agent: makeAgent({
+        // Bypass typing for this test — descriptor with unrecognized kind:
+        s2s: { kind: "made-up-provider", options: {} } as unknown as S2sProvider,
+      }),
+      env: {},
+      logger: silentLogger,
+    });
+
+    expect(() =>
+      runtime.createSession({
+        id: "sess-bad",
+        agent: "test-agent",
+        client: makeClientSink(),
+      }),
+    ).toThrow(/Unknown s2s provider kind/);
+  });
 });
 
 // ── Shared conformance suite (same tests run against sandbox in integration) ─

package/host/runtime.ts

@@ -15,6 +15,10 @@ import { DEFAULT_SHUTDOWN_TIMEOUT_MS } from "../sdk/constants.ts";
 import type { Kv } from "../sdk/kv.ts";
 import type { ClientSink } from "../sdk/protocol.ts";
 import { buildReadyConfig, type ReadyConfig } from "../sdk/protocol.ts";
+import {
+  OPENAI_REALTIME_KIND,
+  type OpenaiRealtimeOptions,
+} from "../sdk/providers/s2s/openai-realtime.ts";
 import { DEEPGRAM_KIND } from "../sdk/providers/stt/deepgram.ts";
 import { RIME_KIND } from "../sdk/providers/tts/rime.ts";
 import {
@@ -39,6 +43,11 @@ import { consoleLogger, DEFAULT_S2S_CONFIG } from "./runtime-config.ts";
 import type { CreateS2sWebSocket } from "./s2s.ts";
 import { createSessionCore, type SessionCore } from "./session-core.ts";
 import { type ExecuteTool, executeToolCall } from "./tool-executor.ts";
+import {
+  type CreateOpenaiRealtimeWebSocket,
+  createOpenaiRealtimeTransport,
+  type OpenaiRealtimeToolSchema,
+} from "./transports/openai-realtime-transport.ts";
 import { createPipelineTransport } from "./transports/pipeline-transport.ts";
 import { createS2sTransport } from "./transports/s2s-transport.ts";
 import type { Transport, TransportCallbacks } from "./transports/types.ts";
@@ -48,46 +57,27 @@ import { type SessionWebSocket, wireSessionSocket } from "./ws-handler.ts";
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
 /**
- * Resolve the API key env-var for the configured STT provider.
- *
- * Each STT provider uses its own env var (e.g. `ASSEMBLYAI_API_KEY`,
- * `DEEPGRAM_API_KEY`). We read the kind from the descriptor if it is one;
- * pre-resolved openers have no kind field so we fall back to AssemblyAI for
- * backward compatibility (openers supply their own key at open-time anyway).
+ * Read the descriptor `kind` if present. Pre-resolved openers (test escape
+ * hatch) have no `kind` field, so callers fall back to a default env var.
  */
+function descriptorKind(value: object | undefined): string | undefined {
+  const kind = (value as { kind?: unknown } | undefined)?.kind;
+  return typeof kind === "string" ? kind : undefined;
+}
+
 function resolveSttApiKey(
   stt: SttProvider | SttOpener | undefined,
   env: Record<string, string>,
 ): string {
-  // SttProvider descriptors carry a `kind` field; SttOpener does not.
-  const kind =
-    stt != null && "kind" in stt && typeof (stt as SttProvider).kind === "string"
-      ? (stt as SttProvider).kind
-      : undefined;
-  if (kind === DEEPGRAM_KIND) return resolveApiKey("DEEPGRAM_API_KEY", env);
-  // Default: ASSEMBLYAI_KIND or pre-resolved opener (backward compat).
+  if (descriptorKind(stt) === DEEPGRAM_KIND) return resolveApiKey("DEEPGRAM_API_KEY", env);
   return resolveApiKey("ASSEMBLYAI_API_KEY", env);
 }
 
-/**
- * Resolve the API key env-var for the configured TTS provider.
- *
- * Each TTS provider uses its own env var (e.g. `CARTESIA_API_KEY`,
- * `RIME_API_KEY`). We read the kind from the descriptor if it is one;
- * pre-resolved openers have no kind field so we fall back to Cartesia for
- * backward compatibility (openers supply their own key at open-time anyway).
- */
 function resolveTtsApiKey(
   tts: TtsProvider | TtsOpener | undefined,
   env: Record<string, string>,
 ): string {
-  // TtsProvider descriptors carry a `kind` field; TtsOpener does not.
-  const kind =
-    tts != null && "kind" in tts && typeof (tts as TtsProvider).kind === "string"
-      ? (tts as TtsProvider).kind
-      : undefined;
-  if (kind === RIME_KIND) return resolveApiKey("RIME_API_KEY", env);
-  // Default: CARTESIA_KIND or pre-resolved opener (backward compat).
+  if (descriptorKind(tts) === RIME_KIND) return resolveApiKey("RIME_API_KEY", env);
   return resolveApiKey("CARTESIA_API_KEY", env);
 }
 
@@ -173,6 +163,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;
   /**
@@ -276,6 +268,7 @@ export function createRuntime(opts: RuntimeOptions): Runtime {
     kv = createLocalKv(),
     vector,
     createWebSocket,
+    createOpenaiRealtimeWebSocket,
     logger = consoleLogger,
     s2sConfig = DEFAULT_S2S_CONFIG,
     sessionStartTimeoutMs,
@@ -369,25 +362,123 @@ export function createRuntime(opts: RuntimeOptions): Runtime {
   // Resolve pipeline providers once per runtime (not per session). Each
   // session reuses the same opener / LanguageModel — the opener's `open()`
   // mints the per-session stream inside.
-  const pipelineProviders =
-    mode === "pipeline"
-      ? {
-          // biome-ignore lint/style/noNonNullAssertion: mode === "pipeline" ⇒ all three set
-          stt: resolveSttIfDescriptor(opts.stt!),
-          // biome-ignore lint/style/noNonNullAssertion: mode === "pipeline" ⇒ all three set
-          llm: resolveLlmIfDescriptor(opts.llm!, env),
-          // biome-ignore lint/style/noNonNullAssertion: mode === "pipeline" ⇒ all three set
-          tts: resolveTtsIfDescriptor(opts.tts!),
-        }
-      : null;
-
-  function createSession(sessionOpts: {
+  let pipelineProviders: { stt: SttOpener; llm: LanguageModel; tts: TtsOpener } | null = null;
+  if (mode === "pipeline" && opts.stt && opts.llm && opts.tts) {
+    pipelineProviders = {
+      stt: resolveSttIfDescriptor(opts.stt),
+      llm: resolveLlmIfDescriptor(opts.llm, env),
+      tts: resolveTtsIfDescriptor(opts.tts),
+    };
+  }
+
+  type SessionOpts = {
     id: string;
     agent: string;
     client: ClientSink;
     skipGreeting?: boolean;
     resumeFrom?: string;
-  }): SessionCore {
+  };
+
+  function buildPipelineTransport(args: {
+    sessionOpts: SessionOpts;
+    systemPrompt: string;
+    callbacks: TransportCallbacks;
+    providers: { stt: SttOpener; llm: LanguageModel; tts: TtsOpener };
+  }): Transport {
+    const { sessionOpts, systemPrompt, callbacks, providers } = args;
+    return createPipelineTransport({
+      sid: sessionOpts.id,
+      agent: sessionOpts.agent,
+      stt: providers.stt,
+      llm: providers.llm,
+      tts: providers.tts,
+      callbacks,
+      sessionConfig: {
+        systemPrompt,
+        greeting: agentConfig.greeting,
+        tools: toolSchemas,
+      },
+      toolSchemas,
+      executeTool,
+      providerKeys: {
+        stt: resolveSttApiKey(opts.stt, env),
+        tts: resolveTtsApiKey(opts.tts, env),
+      },
+      sttSampleRate: s2sConfig.inputSampleRate,
+      ttsSampleRate: s2sConfig.outputSampleRate,
+      maxSteps: agentConfig.maxSteps,
+      toolChoice: agentConfig.toolChoice,
+      skipGreeting: sessionOpts.skipGreeting ?? false,
+      logger,
+    });
+  }
+
+  function buildOpenaiRealtimeTransport(args: {
+    sessionOpts: SessionOpts;
+    systemPrompt: string;
+    callbacks: TransportCallbacks;
+  }): Transport {
+    const { sessionOpts, systemPrompt, callbacks } = args;
+    return createOpenaiRealtimeTransport({
+      apiKey: resolveApiKey("OPENAI_API_KEY", env),
+      options: (agent.s2s?.options ?? {}) as OpenaiRealtimeOptions,
+      sessionConfig: {
+        systemPrompt,
+        ...(agentConfig.greeting !== undefined ? { greeting: agentConfig.greeting } : {}),
+        tools: toolSchemas,
+      },
+      toolSchemas: toolSchemas as OpenaiRealtimeToolSchema[],
+      toolChoice: agentConfig.toolChoice ?? "auto",
+      callbacks,
+      sid: sessionOpts.id,
+      agent: sessionOpts.agent,
+      ...(createOpenaiRealtimeWebSocket ? { createWebSocket: createOpenaiRealtimeWebSocket } : {}),
+      logger,
+    });
+  }
+
+  function buildAssemblyS2sTransport(args: {
+    sessionOpts: SessionOpts;
+    systemPrompt: string;
+    callbacks: TransportCallbacks;
+  }): Transport {
+    const { sessionOpts, systemPrompt, callbacks } = args;
+    return createS2sTransport({
+      apiKey: env.ASSEMBLYAI_API_KEY ?? "",
+      s2sConfig,
+      sessionConfig: {
+        systemPrompt,
+        tools: toolSchemas as import("./s2s.ts").S2sToolSchema[],
+        ...(agentConfig.greeting !== undefined ? { greeting: agentConfig.greeting } : {}),
+      },
+      toolSchemas: toolSchemas as import("./s2s.ts").S2sToolSchema[],
+      callbacks,
+      sid: sessionOpts.id,
+      agent: sessionOpts.agent,
+      ...(createWebSocket ? { createWebSocket } : {}),
+      logger,
+    });
+  }
+
+  function buildTransport(args: {
+    sessionOpts: SessionOpts;
+    systemPrompt: string;
+    callbacks: TransportCallbacks;
+  }): Transport {
+    if (pipelineProviders) {
+      return buildPipelineTransport({ ...args, providers: pipelineProviders });
+    }
+    if (agent.s2s !== undefined) {
+      const kind = descriptorKind(agent.s2s);
+      if (kind === OPENAI_REALTIME_KIND) {
+        return buildOpenaiRealtimeTransport(args);
+      }
+      throw new Error(`Unknown s2s provider kind: ${kind ?? "<missing>"}`);
+    }
+    return buildAssemblyS2sTransport(args);
+  }
+
+  function createSession(sessionOpts: SessionOpts): SessionCore {
     sinkMap.set(sessionOpts.id, sessionOpts.client);
 
     const isPipeline = Boolean(pipelineProviders);
@@ -426,50 +517,11 @@ export function createRuntime(opts: RuntimeOptions): Runtime {
       onSpeechStopped: () => bindCore().onSpeechStopped(),
     };
 
-    let transport: Transport;
-    if (pipelineProviders) {
-      transport = createPipelineTransport({
-        sid: sessionOpts.id,
-        agent: sessionOpts.agent,
-        stt: pipelineProviders.stt,
-        llm: pipelineProviders.llm,
-        tts: pipelineProviders.tts,
-        callbacks,
-        sessionConfig: {
-          systemPrompt,
-          greeting: agentConfig.greeting,
-          tools: toolSchemas,
-        },
-        toolSchemas,
-        executeTool,
-        providerKeys: {
-          stt: resolveSttApiKey(opts.stt, env),
-          tts: resolveTtsApiKey(opts.tts, env),
-        },
-        sttSampleRate: s2sConfig.inputSampleRate,
-        ttsSampleRate: s2sConfig.outputSampleRate,
-        maxSteps: agentConfig.maxSteps,
-        toolChoice: agentConfig.toolChoice,
-        skipGreeting: sessionOpts.skipGreeting ?? false,
-        logger,
-      });
-    } else {
-      transport = createS2sTransport({
-        apiKey: env.ASSEMBLYAI_API_KEY ?? "",
-        s2sConfig,
-        sessionConfig: {
-          systemPrompt,
-          tools: toolSchemas as import("./s2s.ts").S2sToolSchema[],
-          ...(agentConfig.greeting !== undefined ? { greeting: agentConfig.greeting } : {}),
-        },
-        toolSchemas: toolSchemas as import("./s2s.ts").S2sToolSchema[],
-        callbacks,
-        sid: sessionOpts.id,
-        agent: sessionOpts.agent,
-        ...(createWebSocket ? { createWebSocket } : {}),
-        logger,
-      });
-    }
+    const transport = buildTransport({
+      sessionOpts,
+      systemPrompt,
+      callbacks,
+    });
 
     core = createSessionCore({
       id: sessionOpts.id,