@voicelayer/sdk 0.1.7 → 0.1.9

package/dist/text-session-B8-jhQzv.d.ts

@@ -1,837 +0,0 @@
-import { JobContext, voice } from '@livekit/agents';
-import { z } from 'zod';
-
-declare const brand: unique symbol;
-type Brand<T, B> = T & {
-    readonly [brand]: B;
-};
-type TenantId = Brand<string, 'TenantId'>;
-declare const TenantId: (s: string) => TenantId;
-type CallId = Brand<string, 'CallId'>;
-declare const CallId: (s: string) => CallId;
-type ModuleId = Brand<string, 'ModuleId'>;
-declare const ModuleId: (s: string) => ModuleId;
-
-declare const participantBrand: unique symbol;
-type ParticipantId = string & {
-    readonly [participantBrand]: 'ParticipantId';
-};
-declare const ParticipantId: (s: string) => ParticipantId;
-/**
- * How this participant is connected to the room. Determines which transport
- * adapter owns the underlying media track.
- *   - `sip`     — PSTN-side via LiveKit SIP (Twilio/Telnyx trunk)
- *   - `webrtc`  — browser/native WebRTC peer
- *   - `agent`   — the AI agent itself (server-published track)
- *   - `bridge`  — incoming non-WebRTC ingress (e.g. an Egress recorder)
- */
-type ParticipantKind = 'sip' | 'webrtc' | 'agent' | 'bridge';
-/**
- * One participant in a room. Snapshot semantics: callers read from
- * `ParticipantSet`, which owns lifecycle. Fields are readonly because
- * mutations must go through the routing primitive to stay observable.
- */
-interface Participant {
-    readonly id: ParticipantId;
-    readonly kind: ParticipantKind;
-    /** True iff `kind === 'agent'`. Convenience for filtering. */
-    readonly isAgent: boolean;
-    /** E.164 when known (always for SIP, never for agent, sometimes for WebRTC). */
-    readonly phone: string | null;
-    /** Human-readable label (caller name, agent name). */
-    readonly displayName: string | null;
-    /**
-     * Free-form attributes attached by the dispatcher or runtime. Standardised
-     * keys the platform reads:
-     *   - `lang`  — BCP-47 (e.g. `en-US`, `es-MX`). Used by audio-experience.
-     *   - `role`  — e.g. `claimant`, `witness`, `interpreter`. Used by handoff.
-     *   - `tier`  — e.g. `vip`, `standard`. Used by audio-experience.
-     */
-    readonly attributes: Readonly<Record<string, string>>;
-    readonly joinedAt: Date;
-    /** Set when the participant has left. Stays in the set until call end. */
-    readonly leftAt: Date | null;
-}
-/**
- * Live view of room participants. The agent-worker owns the underlying
- * collection; primitives consume it read-only. Snapshot semantics: methods
- * return arrays/values valid at call time. The set itself updates in place
- * as participants join/leave — re-call to see new state.
- */
-interface ParticipantSet {
-    /** All participants ever in the room, including those who have left. */
-    readonly all: readonly Participant[];
-    /** Currently-connected, non-agent participants. */
-    readonly humans: readonly Participant[];
-    /** Currently-connected agents. Usually exactly one. */
-    readonly agents: readonly Participant[];
-    readonly size: number;
-    get(id: ParticipantId): Participant | undefined;
-    where(pred: (p: Participant) => boolean): readonly Participant[];
-}
-/**
- * The call container. One Room per call. Replaces the singular call+caller
- * model for multi-participant primitives; existing single-caller primitives
- * keep reading CallContext.callerId until migrated.
- */
-interface Room {
-    readonly id: CallId;
-    readonly tenantId: TenantId;
-    readonly moduleId: ModuleId;
-    readonly startedAt: Date;
-    readonly participants: ParticipantSet;
-    /** Dispatch metadata (LK job metadata) — projectId, agentId, etc. */
-    readonly metadata: Readonly<Record<string, unknown>>;
-}
-
-declare const FlowProgram: z.ZodObject<{
-    v: z.ZodLiteral<1>;
-    id: z.ZodString;
-    entry: z.ZodArray<z.ZodString, "many">;
-    nodes: z.ZodRecord<z.ZodString, z.ZodObject<{
-        id: z.ZodString;
-        type: z.ZodEnum<["start", "say", "ask", "confirm", "tool", "decision", "handoff", "end", "trigger", "gate", "playbook", "menu", "code", "set", "subflow", "llm", "rag", "memory", "classify", "router", "note"]>;
-        config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        out: z.ZodArray<z.ZodObject<{
-            to: z.ZodString;
-            condition: z.ZodOptional<z.ZodString>;
-            sourceHandle: z.ZodOptional<z.ZodString>;
-            label: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            to: string;
-            sourceHandle?: string | undefined;
-            label?: string | undefined;
-            condition?: string | undefined;
-        }, {
-            to: string;
-            sourceHandle?: string | undefined;
-            label?: string | undefined;
-            condition?: string | undefined;
-        }>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        type: "code" | "start" | "say" | "ask" | "confirm" | "tool" | "decision" | "handoff" | "end" | "trigger" | "gate" | "playbook" | "menu" | "set" | "subflow" | "llm" | "rag" | "memory" | "classify" | "router" | "note";
-        id: string;
-        config: Record<string, unknown>;
-        out: {
-            to: string;
-            sourceHandle?: string | undefined;
-            label?: string | undefined;
-            condition?: string | undefined;
-        }[];
-    }, {
-        type: "code" | "start" | "say" | "ask" | "confirm" | "tool" | "decision" | "handoff" | "end" | "trigger" | "gate" | "playbook" | "menu" | "set" | "subflow" | "llm" | "rag" | "memory" | "classify" | "router" | "note";
-        id: string;
-        config: Record<string, unknown>;
-        out: {
-            to: string;
-            sourceHandle?: string | undefined;
-            label?: string | undefined;
-            condition?: string | undefined;
-        }[];
-    }>>;
-    completionGate: z.ZodObject<{
-        requiredFields: z.ZodArray<z.ZodString, "many">;
-    }, "strip", z.ZodTypeAny, {
-        requiredFields: string[];
-    }, {
-        requiredFields: string[];
-    }>;
-    diagnostics: z.ZodOptional<z.ZodObject<{
-        acyclic: z.ZodBoolean;
-        droppedEdges: z.ZodArray<z.ZodString, "many">;
-        unsupportedNodes: z.ZodArray<z.ZodString, "many">;
-    }, "strip", z.ZodTypeAny, {
-        acyclic: boolean;
-        droppedEdges: string[];
-        unsupportedNodes: string[];
-    }, {
-        acyclic: boolean;
-        droppedEdges: string[];
-        unsupportedNodes: string[];
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    v: 1;
-    id: string;
-    nodes: Record<string, {
-        type: "code" | "start" | "say" | "ask" | "confirm" | "tool" | "decision" | "handoff" | "end" | "trigger" | "gate" | "playbook" | "menu" | "set" | "subflow" | "llm" | "rag" | "memory" | "classify" | "router" | "note";
-        id: string;
-        config: Record<string, unknown>;
-        out: {
-            to: string;
-            sourceHandle?: string | undefined;
-            label?: string | undefined;
-            condition?: string | undefined;
-        }[];
-    }>;
-    entry: string[];
-    completionGate: {
-        requiredFields: string[];
-    };
-    diagnostics?: {
-        acyclic: boolean;
-        droppedEdges: string[];
-        unsupportedNodes: string[];
-    } | undefined;
-}, {
-    v: 1;
-    id: string;
-    nodes: Record<string, {
-        type: "code" | "start" | "say" | "ask" | "confirm" | "tool" | "decision" | "handoff" | "end" | "trigger" | "gate" | "playbook" | "menu" | "set" | "subflow" | "llm" | "rag" | "memory" | "classify" | "router" | "note";
-        id: string;
-        config: Record<string, unknown>;
-        out: {
-            to: string;
-            sourceHandle?: string | undefined;
-            label?: string | undefined;
-            condition?: string | undefined;
-        }[];
-    }>;
-    entry: string[];
-    completionGate: {
-        requiredFields: string[];
-    };
-    diagnostics?: {
-        acyclic: boolean;
-        droppedEdges: string[];
-        unsupportedNodes: string[];
-    } | undefined;
-}>;
-type FlowProgram = z.infer<typeof FlowProgram>;
-
-type SessionState = 'initializing' | 'idle' | 'listening' | 'thinking' | 'speaking';
-declare const LK_AGENT_STATE_MAP: Readonly<Record<string, SessionState>>;
-declare const NON_BUSY_STATES: ReadonlySet<SessionState>;
-/** Normalize a raw LK state string to SessionState; unknown -> 'thinking' (fail-safe). */
-declare function normalizeState(raw: string): SessionState;
-interface UserInputEvent {
-    readonly transcript: string;
-    readonly isFinal: boolean;
-    readonly speakerId: string | null;
-}
-interface AgentTurnEvent {
-    readonly text: string;
-}
-interface DtmfEvent$1 {
-    readonly digit: string;
-    readonly code: number;
-    readonly participantId: string | null;
-}
-interface StateChangeEvent {
-    readonly oldState: SessionState | null;
-    readonly newState: SessionState | null;
-    readonly rawOldState: string | null;
-    readonly rawNewState: string | null;
-}
-interface SessionErrorEvent {
-    readonly error: unknown;
-    readonly source: 'llm' | 'stt' | 'tts' | 'realtime' | 'unknown';
-    readonly fatalTransport: boolean;
-}
-interface MetricsEvent {
-    readonly metrics: unknown;
-}
-interface SessionEventMap {
-    user_input: UserInputEvent;
-    agent_turn: AgentTurnEvent;
-    dtmf: DtmfEvent$1;
-    state: StateChangeEvent;
-    error: SessionErrorEvent;
-    metrics: MetricsEvent;
-    close: void;
-}
-type SessionEvent = keyof SessionEventMap;
-type Unsubscribe = () => void;
-type ChannelKind = 'voice' | 'text';
-interface SessionCapabilities {
-    readonly channel: ChannelKind;
-    readonly usingRealtime: boolean;
-    readonly hasStreamingTranscripts: boolean;
-    readonly canBargeIn: boolean;
-    readonly canReceiveDtmf: boolean;
-    readonly canPublishDtmf: boolean;
-    readonly canResolveSpeaker: boolean;
-}
-interface SayOptions$1 {
-    readonly allowInterruptions?: boolean;
-    readonly to?: string | readonly string[];
-}
-interface SpeechResult {
-    readonly interrupted: boolean;
-}
-interface EndCallOutcome {
-    readonly torn: 'room' | 'agent' | 'none';
-    readonly stranded: boolean;
-}
-interface SessionOutbound {
-    /** Speak verbatim. Under usingRealtime the LiveKit adapter routes to
-     *  generateReply(verbatim) NOT session.say (no TTS in S2S). Resolves after
-     *  playout (voice) or after the text turn is committed (text). */
-    say(text: string, opts?: SayOptions$1): Promise<SpeechResult>;
-    /** Ask the LLM to produce a turn. */
-    generateReply(opts?: {
-        readonly instructions?: string;
-    }): Promise<void>;
-    /** Barge-in cancel (puppet interrupt mode). text => no-op. */
-    interrupt(): Promise<void>;
-    /** Publish outbound DTMF from the agent leg. Throws if !canPublishDtmf. */
-    sendDtmf(code: number, digit: string): Promise<void>;
-    /** Hang up via the SDK end-call controller (deletes room so the SIP leg drops). */
-    endCall(opts?: {
-        readonly reason?: string;
-        readonly trigger?: string;
-    }): Promise<EndCallOutcome>;
-}
-type TurnEvent = {
-    readonly kind: 'partial';
-    readonly text: string;
-    readonly speakerId: string | null;
-} | {
-    readonly kind: 'final';
-    readonly text: string;
-    readonly speakerId: string | null;
-    readonly at: Date;
-} | {
-    readonly kind: 'dtmf';
-    readonly digit: string;
-    readonly code: number;
-    readonly participantId: string | null;
-    readonly at: Date;
-} | {
-    readonly kind: 'hangup';
-} | {
-    readonly kind: 'timeout';
-};
-interface InboundOptions {
-    readonly idleTimeoutMs?: number;
-    readonly finalsOnly?: boolean;
-}
-interface SessionAdapter extends SessionOutbound {
-    readonly capabilities: SessionCapabilities;
-    on<E extends SessionEvent>(event: E, handler: (payload: SessionEventMap[E]) => void): Unsubscribe;
-    once<E extends SessionEvent>(event: E, handler: (payload: SessionEventMap[E]) => void): Unsubscribe;
-    /** Graph read side. ONE underlying subscription. Mutually exclusive with the
-     *  flat on('user_input') consumer (THROWS if both active). The iterator's
-     *  return()/finally MUST unsubscribe. */
-    inbound(opts?: InboundOptions): AsyncIterableIterator<TurnEvent>;
-    /** Begin the session (was session.start + waitForSessionActivity). The LiveKit
-     *  impl preserves the activity sequence VERBATIM so a provider/LLM init failure
-     *  REJECTS rather than producing a silently-dead answered call. */
-    start(opts?: {
-        readonly agent?: unknown;
-        readonly room?: unknown;
-    }): Promise<void>;
-    readonly state: SessionState;
-    /** Resolve when idle/listening, on timeout, or on close. Synchronous fast-path:
-     *  if already non-busy, resolves 'idle' in the same microtask. */
-    waitForIdle(timeoutMs: number): Promise<'idle' | 'timeout' | 'closed'>;
-    waitForClose(): Promise<void>;
-    /** Escape hatch for genuinely LK-coupled sites. undefined on the text adapter. */
-    readonly raw?: {
-        readonly job: JobContext;
-        readonly session: unknown;
-        readonly room: unknown;
-    };
-    dispose(): void;
-}
-interface EndCallControllerHandle {
-    hangUp(opts?: {
-        readonly trigger?: string;
-        readonly reason?: string;
-    }): Promise<void>;
-    armIdle(): void;
-    cancelIdle(): void;
-    noteEngineClosed(): void;
-}
-/**
- * Fold the user's `speech.interruption` / `speech.endpointing` config into an
- * LK turnHandling object. User-set fields are merged over whatever mode
- * defaults (puppet/hostControlled) already put there — explicit agent config
- * wins. No-op when the config is absent, so existing agents keep LK defaults.
- * Lives here (not session-adapter-livekit) so agent.ts can import it without
- * pulling @livekit/agents in at module load.
- */
-declare function applySpeechTurnHandling(turnHandling: Record<string, unknown>, speech?: {
-    readonly interruption?: {
-        readonly enabled?: boolean;
-        readonly minWords?: number;
-        readonly minDuration?: number;
-    };
-    readonly endpointing?: {
-        readonly minDelay?: number;
-        readonly maxDelay?: number;
-    };
-}): Record<string, unknown>;
-interface SessionFactoryInput {
-    readonly usingRealtime: boolean;
-    readonly graphMode: boolean;
-    readonly puppetMode: boolean;
-    readonly hostControlled: boolean;
-    readonly captureDtmf: boolean;
-    readonly pipeline?: {
-        readonly stt?: unknown;
-        readonly tts?: unknown;
-        readonly vad?: unknown;
-        readonly llm: unknown;
-    };
-    readonly turnHandling?: Record<string, unknown>;
-    /** Per-agent barge-in + endpointing tuning (AgentConfig `speech`). Merged
-     *  over mode defaults by applySpeechTurnHandling — explicit config wins. */
-    readonly speech?: {
-        readonly interruption?: {
-            readonly enabled?: boolean;
-            readonly minWords?: number;
-            readonly minDuration?: number;
-        };
-        readonly endpointing?: {
-            readonly minDelay?: number;
-            readonly maxDelay?: number;
-        };
-    };
-    readonly resolveSpeaker?: (speakerId: string | null) => {
-        readonly id: string | null;
-        readonly label: string;
-    };
-    readonly classifyEngineClosed?: (err: unknown) => boolean;
-    readonly endCallController?: EndCallControllerHandle;
-}
-type SessionFactory = (input: SessionFactoryInput) => Promise<SessionAdapter>;
-interface UserTurn {
-    readonly text: string;
-    readonly speakerLabel: string;
-    readonly speakerId: string | null;
-    readonly at: Date;
-}
-interface FakeSessionAdapter extends SessionAdapter {
-    emitUserInput(e: UserInputEvent): void;
-    emitAgentTurn(text: string): void;
-    emitDtmf(digit: string): void;
-    /** Drives 'state' with correct oldState/rawOldState AND runs the SAME
-     *  arm/cancel + idle-release as production. Unknown string => 'thinking'. */
-    setState(next: SessionState | string): void;
-    emitError(error: unknown, fatalTransport?: boolean): void;
-    emitClose(): void;
-    readonly spoken: ReadonlyArray<string>;
-    readonly generatedReplies: ReadonlyArray<string | undefined>;
-    readonly sentDtmf: ReadonlyArray<string>;
-    readonly endCalls: ReadonlyArray<{
-        readonly reason?: string;
-        readonly trigger?: string;
-    }>;
-}
-
-interface ProcessSchema {
-    readonly id: string;
-    readonly fields: readonly FieldSpec[];
-    readonly completionGate: GateSpec;
-}
-interface FieldSpec {
-    readonly name: string;
-    readonly required: boolean;
-    /**
-     * Validation rule. Two accepted forms:
-     *   1. A Zod schema (preferred — e.g. `z.string().regex(...)` or `z.number().min(0)`).
-     *   2. The legacy JSON spec object — `{ type, pattern, min, max, enum }`.
-     * Both are compiled to a Zod schema at `loadSchema` time. New code should
-     * use Zod directly.
-     */
-    readonly validation: unknown;
-}
-interface GateSpec {
-    /** Names of fields that must be captured before canCallEnd() returns ok. */
-    readonly requiredFields: readonly string[];
-    /** Optional external ACK webhook — gate stays open until ACK received. */
-    readonly backendAck?: {
-        readonly url: string;
-        readonly timeoutMs: number;
-    };
-}
-/**
- * Side-channel event the actor records alongside its state machine — tool
- * calls, form-page activity, webhook dispatches, anything the agent does
- * that isn't a field capture. Recorded into context.lifecycle (rolling,
- * capped) so the dashboard React Flow board can render a timeline of "what
- * happened on this call" without us having to invent a separate event bus.
- */
-interface ProcessLifecycleEvent {
-    /** Stable id (ULID/UUID) so dashboards can de-dup across reconnects. */
-    readonly id: string;
-    /** ISO timestamp. */
-    readonly at: string;
-    /**
-     * Event kind. Convention: `<surface>.<verb_past>` —
-     *   form.link_sent, form.field_set, form.submitted,
-     *   email.sent, email.send_failed,
-     *   webhook.enqueued, webhook.delivered,
-     *   tool.invoked, tool.errored
-     * Keep these short and stable; the dashboard switches on them.
-     */
-    readonly kind: string;
-    /** Where the event came from. */
-    readonly source: 'agent' | 'caller' | 'form' | 'platform';
-    /** Free-form structured data. Kept small — this rides every snapshot. */
-    readonly data: Readonly<Record<string, unknown>>;
-}
-interface ProcessSnapshot$1 {
-    readonly schemaId: string;
-    readonly currentNode: string;
-    readonly fieldsCaptured: Readonly<Record<string, unknown>>;
-    readonly backendAckReceived: boolean;
-    readonly backendAckReceivedAt?: Date;
-    /**
-     * Side-channel events (tool calls, form events, webhooks). Empty when no
-     * lifecycle events have been recorded; capped at PROCESS_LIFECYCLE_MAX_EVENTS
-     * (oldest events dropped on overflow).
-     */
-    readonly lifecycle: readonly ProcessLifecycleEvent[];
-}
-
-interface TtsVoiceConfig {
-    readonly provider: 'deepgram' | 'openai' | 'elevenlabs' | 'cartesia';
-    readonly model: string;
-    readonly voice?: string;
-    readonly instructions?: string;
-}
-interface AudioProfile {
-    readonly holdMusicUrl: string;
-    readonly duckingDb: number;
-    readonly dtmfFallbackThreshold: number;
-    readonly languageHint: string;
-    readonly tts: TtsVoiceConfig;
-}
-
-type RoutingRule = {
-    readonly kind: 'passthrough';
-} | {
-    readonly kind: 'mute';
-} | {
-    readonly kind: 'duck';
-    readonly db: number;
-} | {
-    readonly kind: 'transform';
-    readonly id: string;
-};
-declare const passthrough: () => RoutingRule;
-declare const mute: () => RoutingRule;
-declare const duck: (db: number) => RoutingRule;
-declare const transform: (id: string) => RoutingRule;
-interface RouteEntry {
-    readonly source: ParticipantId;
-    readonly destination: ParticipantId;
-    readonly rule: RoutingRule;
-}
-interface FloorControlConfig {
-    /**
-     * Minimum quiet window (ms) after the last human utterance before the
-     * agent is allowed to speak. Prevents the agent from talking over a
-     * human who hasn't yielded the floor. Default 400ms.
-     */
-    readonly humanQuietWindowMs: number;
-    /**
-     * If true, the agent may speak immediately at call start before any
-     * human has spoken (the greeting). Default true.
-     */
-    readonly allowAgentGreeting: boolean;
-}
-interface RoutingSnapshot {
-    readonly entries: readonly RouteEntry[];
-    readonly lastSpokeAt: ReadonlyMap<ParticipantId, number>;
-}
-
-interface CallInfo {
-    /** Stable id for the call; comes from dispatch metadata or room name. */
-    readonly callId: string;
-    /** Caller phone number (E.164) when available, else participant identity. */
-    readonly callerId: string;
-    /** Phone number that was called (E.164) when available. */
-    readonly to: string | null;
-    /** Wall-clock when the agent joined. */
-    readonly startedAt: Date;
-    /** Free-form metadata from the dispatch rule (e.g. projectId, agentId). */
-    readonly metadata: Record<string, unknown>;
-}
-interface MemoryHandle {
-    get(key: string): Promise<unknown>;
-    set(key: string, value: unknown): Promise<void>;
-}
-interface ProcessSnapshot {
-    /** Captured field values. */
-    readonly data: Record<string, unknown>;
-    /** True once the process completion gate has fired. */
-    readonly complete: boolean;
-}
-/**
- * Input to ctx.recordEvent — id and timestamp are stamped by the runtime so
- * callers only supply the semantic fields. `source` defaults to 'agent' for
- * tool-call events; pass 'form'/'platform'/'caller' when emitting from a
- * different surface (form-page bridge, webhook handler).
- */
-interface RecordEventInput$1 {
-    readonly kind: string;
-    readonly source?: 'agent' | 'caller' | 'form' | 'platform';
-    readonly data?: Record<string, unknown>;
-}
-/**
- * Targets for participant-scoped speech operations. Either a raw
- * `ParticipantId`, a `Participant` snapshot, or an array of either.
- * `'broadcast'` is the explicit form of the default — everyone in the room.
- */
-type SpeechTarget = ParticipantId | Participant | readonly (ParticipantId | Participant)[] | 'broadcast';
-/**
- * Audio surface — per-participant profiles, routing matrix, and floor
- * control. Exposed on `ctx.audio` so user hooks (e.g. translation in
- * onUtterance) can drive the underlying primitives without importing
- * them directly.
- *
- * In PR#4 these are wired to live LK participant events but the audio
- * fanout itself (per-participant STT, per-listener TTS) is still single-
- * pipeline; users that need actual per-listener delivery should go
- * through `ctx.livekit` for now.
- */
-interface AudioSurface {
-    /** Profile (voice/lang/DTMF) for one participant. */
-    profileFor(participantId: ParticipantId): AudioProfile;
-    /** Update one participant's language hint (also swaps TTS voice). */
-    setLanguage(participantId: ParticipantId, languageHint: string): AudioProfile;
-    /** Current routing matrix snapshot. */
-    routes(): RoutingSnapshot;
-    /** Override a single (source, destination) edge in the routing matrix. */
-    setRoute(source: ParticipantId, destination: ParticipantId, rule: RoutingRule): void;
-    /** Floor-control: true iff no human has spoken inside the quiet window. */
-    canAgentSpeak(): boolean;
-}
-interface SayOptions {
-    /** Restrict the spoken track to one or more participants. Default: broadcast. */
-    readonly to?: SpeechTarget;
-}
-/**
- * A DTMF keypress received from a participant. `code` is the RFC 4733 event
- * code (0–15: digits 0–9, *=10, #=11, A–D=12–15); `digit` is the canonical
- * single-character representation. `participantId` identifies the sender in
- * the synthesized room (matches Room.participants).
- */
-interface DtmfEvent {
-    readonly participantId: ParticipantId;
-    readonly code: number;
-    readonly digit: string;
-    readonly at: Date;
-}
-/** Handler signature for ctx.onDtmf. Returning false unsubscribes. */
-type DtmfHandler = (event: DtmfEvent) => void | Promise<void>;
-interface SendDtmfOptions {
-    /** Milliseconds between consecutive digits. Default 100. */
-    readonly delayMs?: number;
-}
-interface RespondOptions {
-    readonly instructions?: string;
-    readonly to?: SpeechTarget;
-}
-interface AgentContext {
-    readonly call: CallInfo;
-    readonly memory: MemoryHandle;
-    /** Typed connector APIs. Empty record when no connectors are configured. */
-    readonly connectors: Readonly<Record<string, unknown>>;
-    /** Read-only view of process state. Undefined when no process is configured. */
-    readonly process: ProcessSnapshot | undefined;
-    /**
-     * Record a side-channel lifecycle event into the process actor. Visible
-     * to the dashboard React Flow board in real time alongside field
-     * captures. Use for "this happened on the call" facts — tool calls,
-     * form-page activity, webhook dispatches — that aren't field captures.
-     * No-op when the agent has no process configured.
-     */
-    recordEvent(event: RecordEventInput$1): void;
-    /**
-     * Subscribe the agent to a form-page session's WS stream so values typed
-     * on the form-page mirror into the process actor (channel-agnostic field
-     * capture). Tools call this after a successful sendFormLink; the runtime
-     * owns the lifecycle of the underlying WebSocket.
-     *
-     * Returns a function the tool can call to tear down the subscription
-     * early. The subscription also self-closes on form submission or idle.
-     *
-     * No-op (returns a no-op teardown) when the agent has no process or
-     * VOICELAYER_API_URL is unset.
-     */
-    watchFormSession(token: string): () => void;
-    /** Free-form scratch space for hooks to share state within a call. */
-    readonly metadata: Record<string, unknown>;
-    /**
-     * Live view of the call as a participant room. Always populated — for
-     * 1:1 calls the room contains one human participant + the agent.
-     */
-    readonly room: Room;
-    /** Per-participant audio profiles + routing matrix + floor control. */
-    readonly audio: AudioSurface;
-    /**
-     * Speak text (via TTS). Returns when the speech is queued.
-     * `opts.to` selects a participant subset; default is broadcast. The
-     * runtime currently publishes a single shared track; targeted delivery
-     * lands with the per-listener track work (PR#4).
-     */
-    say(text: string, opts?: SayOptions): Promise<void>;
-    /** Ask the LLM to produce a reply now (optionally with extra instructions). */
-    respond(instructionsOrOpts?: string | RespondOptions): Promise<void>;
-    /** Pose a question and resolve with the caller's transcribed answer. */
-    ask(question: string): Promise<string>;
-    /** Transfer the caller to another phone number. Ends the agent's leg.
-     *  `mode` overrides the agent-level warm/cold default for this transfer. */
-    handoff(to: string, opts?: {
-        reason?: string;
-        briefing?: string;
-        mode?: 'warm' | 'cold';
-    }): Promise<void>;
-    /**
-     * Hang up the call. Optionally records a reason (surfaced to logs and
-     * `endCall.onEnd`). Teardown is owned by the SDK end-call controller, which
-     * deletes the whole LiveKit room by default so the SIP/PSTN leg drops too —
-     * not just the agent participant.
-     */
-    endCall(opts?: {
-        reason?: string;
-    }): Promise<void>;
-    /**
-     * Subscribe to inbound DTMF keypresses from participants. Returns an
-     * unsubscribe function. Handlers are called once per digit in the order
-     * received. Errors thrown inside a handler are caught and logged so one
-     * bad handler can't break others.
-     *
-     * @example
-     *   ctx.onDtmf(async (ev) => {
-     *     if (ev.digit === '0') await ctx.handoff('+18005551212');
-     *   });
-     */
-    onDtmf(handler: DtmfHandler): () => void;
-    /**
-     * Send DTMF digits from the agent's leg. Each character is published as
-     * a separate RFC 4733 event; non-DTMF characters (anything not in
-     * 0-9*#A-D) are dropped. `opts.delayMs` controls pacing between digits.
-     *
-     * Useful for IVR navigation post-handoff or during outbound calls.
-     */
-    sendDtmf(digits: string, opts?: SendDtmfOptions): Promise<void>;
-    /** Escape hatch to LiveKit primitives — use when a hook isn't enough. */
-    readonly livekit: {
-        readonly job: JobContext;
-        readonly session: voice.AgentSession;
-    };
-    /** Transport-agnostic session seam. When present, say/respond/ask/handoff and
-     *  the graph executors route through this instead of the raw LiveKit session
-     *  (the lift onto the omnichannel SessionAdapter). Undefined in legacy/unit
-     *  paths that build ctx with only a session. */
-    readonly adapter?: SessionAdapter;
-}
-/**
- * Map a single character to its RFC 4733 event code, or null when the
- * character isn't a valid DTMF digit. 0–9 → 0–9, * → 10, # → 11, A–D → 12–15.
- */
-declare function dtmfDigitToCode(digit: string): number | null;
-/** Inverse of dtmfDigitToCode. Returns null for codes outside 0..15. */
-declare function dtmfCodeToDigit(code: number): string | null;
-
-/** What the agent passes into recordEvent — id/at filled in by the runtime. */
-interface RecordEventInput {
-    readonly kind: string;
-    readonly source?: ProcessLifecycleEvent['source'];
-    readonly data?: Record<string, unknown>;
-}
-interface ProcessRuntime {
-    /** Add field-collection guidance to the system prompt. */
-    augmentPrompt(basePrompt: string): string;
-    /** Run on each finalized caller utterance. */
-    ingest(utterance: string, ctx: AgentContext): Promise<void>;
-    /** Read the current captured data bag (used by handoff briefings). */
-    getData(): Record<string, unknown>;
-    /** True if the process completion gate has fired. */
-    isComplete(): boolean;
-    /**
-     * Capture a field directly — bypasses the LLM extractor. Used by
-     * non-voice sources (form-page websocket, prefill, etc.) so they drive
-     * the same state machine as spoken utterances. Returns true if the
-     * primitive accepted the value.
-     */
-    captureField(name: string, value: unknown): boolean;
-    /**
-     * Record a side-channel lifecycle event into the actor's context — tool
-     * call, form-page activity, webhook dispatch. Triggers the snapshot
-     * subscription so the dashboard timeline updates in real time.
-     */
-    recordEvent(event: RecordEventInput): void;
-    /** @internal — current primitive snapshot (used by publishers). */
-    getSnapshot(): ProcessSnapshot$1 | null;
-    /** @internal — the compiled schema (used for publisher boot + dashboard registration). */
-    getSchema(): ProcessSchema | null;
-    /** @internal — subscribe to state transitions. Returns unsubscribe. */
-    subscribe(listener: (snap: ProcessSnapshot$1) => void): () => void;
-}
-
-/** How the whole flow run finished. */
-type FlowOutcome = {
-    readonly kind: 'completed';
-} | {
-    readonly kind: 'ended';
-    readonly nodeId: string;
-} | {
-    readonly kind: 'handoff';
-    readonly to: string;
-} | {
-    readonly kind: 'hangup';
-} | {
-    readonly kind: 'error';
-    readonly nodeId: string;
-    readonly message: string;
-};
-
-/** One graph-lifecycle event, for the builder's dry-run trace overlay. */
-interface GraphTraceEvent {
-    readonly kind: string;
-    readonly data: Record<string, unknown>;
-}
-interface RunTextSessionOptions {
-    readonly program: FlowProgram;
-    /** Process runtime for slot capture. Defaults to a no-op (say/llm/code flows). */
-    readonly processRt?: ProcessRuntime;
-    /** Sink for outbound agent text (say / generated replies). */
-    readonly onAgentText: (text: string) => void | Promise<void>;
-    /** Produce an autonomous LLM turn for generateReply (llm/clarify nodes). */
-    readonly generate?: (instructions?: string) => Promise<string>;
-    /** Optional call metadata surfaced on ctx.call. */
-    readonly call?: {
-        readonly callId: string;
-        readonly metadata?: Record<string, unknown>;
-    };
-    readonly maxSteps?: number;
-    /** Tap the graph lifecycle (node.entered / edge.traversed / notes) — the
-     *  same stream the live timeline records, surfaced for the dry-run trace. */
-    readonly onTrace?: (event: GraphTraceEvent) => void;
-}
-interface TextSession {
-    /** Feed an inbound user message (a final turn). */
-    sendUserMessage(text: string): void;
-    /** Resolves with the flow outcome when the graph completes/ends/hangs up. */
-    readonly result: Promise<FlowOutcome>;
-    /** End the session (hangup). */
-    end(): void;
-}
-declare function runTextSession(opts: RunTextSessionOptions): TextSession;
-interface RunTextTranscriptOptions {
-    readonly program: FlowProgram;
-    /** Scripted caller turns, consumed in order at the flow's ask points. */
-    readonly messages: readonly string[];
-    readonly processRt?: ProcessRuntime;
-    readonly generate?: (instructions?: string) => Promise<string>;
-    readonly call?: RunTextSessionOptions['call'];
-    readonly maxSteps?: number;
-}
-interface TextTranscriptResult {
-    readonly replies: readonly string[];
-    readonly outcome: FlowOutcome;
-    /** Graph lifecycle in execution order — the dry-run trace. */
-    readonly trace: readonly GraphTraceEvent[];
-}
-/** Batch-drive a flow over text with a fixed list of caller turns and collect the
- *  agent's replies. The turns are queued (createUtteranceStream buffers), so the
- *  flow consumes them in order as it reaches ask points. Stateless — the request/
- *  response shape the text playground route uses. */
-declare function runTextTranscript(opts: RunTextTranscriptOptions): Promise<TextTranscriptResult>;
-
-export { duck as $, type AgentContext as A, type SessionOutbound as B, type CallInfo as C, type DtmfEvent as D, type EndCallControllerHandle as E, type FakeSessionAdapter as F, type SessionState as G, type SpeechResult as H, type InboundOptions as I, type SpeechTarget as J, type StateChangeEvent as K, LK_AGENT_STATE_MAP as L, type MemoryHandle as M, NON_BUSY_STATES as N, type TextTranscriptResult as O, type Participant as P, type TtsVoiceConfig as Q, type RespondOptions as R, type SayOptions as S, type TextSession as T, type TurnEvent as U, type Unsubscribe as V, type UserInputEvent as W, type UserTurn as X, applySpeechTurnHandling as Y, dtmfCodeToDigit as Z, dtmfDigitToCode as _, type AgentTurnEvent as a, mute as a0, normalizeState as a1, passthrough as a2, runTextSession as a3, runTextTranscript as a4, transform as a5, type GraphTraceEvent as a6, type AudioProfile as b, type AudioSurface as c, type ChannelKind as d, type DtmfHandler as e, type EndCallOutcome as f, type FloorControlConfig as g, type MetricsEvent as h, ParticipantId as i, type ParticipantKind as j, type ParticipantSet as k, type ProcessSnapshot as l, type Room as m, type RouteEntry as n, type RoutingRule as o, type RoutingSnapshot as p, type RunTextSessionOptions as q, type RunTextTranscriptOptions as r, type SendDtmfOptions as s, type SessionAdapter as t, type SessionCapabilities as u, type SessionErrorEvent as v, type SessionEvent as w, type SessionEventMap as x, type SessionFactory as y, type SessionFactoryInput as z };