@voicelayer/sdk 0.2.0 → 0.3.1

package/dist/index.d.ts

@@ -1,12 +1,131 @@
-import { A as AgentDTO, a as AgentStatus, b as AgentEnvironment, c as AgentContext, P as Participant, C as CallInfo, d as ProcessSchemaDTO } from './text-session-BqMWaNsN.js';
-export { e as AgentTurnEvent, f as AudioProfile, g as AudioSurface, h as ChannelKind, D as DtmfEvent, i as DtmfHandler, E as EndCallControllerHandle, j as EndCallOutcome, F as FakeSessionAdapter, k as FloorControlConfig, I as InboundOptions, L as LK_AGENT_STATE_MAP, M as MemoryHandle, l as MetricsEvent, N as NON_BUSY_STATES, m as ParticipantId, n as ParticipantKind, o as ParticipantSet, p as ProcessSnapshot, R as RespondOptions, q as Room, r as RouteEntry, s as RoutingRule, t as RoutingSnapshot, u as RunTextSessionOptions, v as RunTextTranscriptOptions, S as SayOptions, w as SendDtmfOptions, x as SessionAdapter, y as SessionCapabilities, z as SessionErrorEvent, B as SessionEvent, G as SessionEventMap, H as SessionFactory, J as SessionFactoryInput, K as SessionOutbound, O as SessionState, Q as SpeechResult, T as SpeechTarget, U as StateChangeEvent, V as TextSession, W as TextTranscriptResult, X as TtsVoiceConfig, Y as TurnEvent, Z as Unsubscribe, _ as UserInputEvent, $ as UserStateEvent, a0 as UserTurn, a1 as applySpeechTurnHandling, a2 as dtmfCodeToDigit, a3 as dtmfDigitToCode, a4 as duck, a5 as mute, a6 as normalizeState, m as participantId, a7 as passthrough, a8 as runTextSession, a9 as runTextTranscript, aa as transform } from './text-session-BqMWaNsN.js';
-import { llm } from '@livekit/agents';
+import { A as AgentDTO, a as AgentStatus, b as AgentEnvironment, c as AgentContext, P as Participant, C as CallInfo, d as ProcessSchemaDTO } from './text-session-oMqJh6SF.js';
+export { e as AgentTurnEvent, f as AudioProfile, g as AudioSurface, h as ChannelKind, D as DtmfEvent, i as DtmfHandler, E as EndCallControllerHandle, j as EndCallOutcome, F as FakeSessionAdapter, k as FloorControlConfig, I as InboundOptions, L as LK_AGENT_STATE_MAP, M as MemoryHandle, l as MetricsEvent, N as NON_BUSY_STATES, m as ParticipantId, n as ParticipantKind, o as ParticipantSet, p as ProcessSnapshot, R as RespondOptions, q as Room, r as RouteEntry, s as RoutingRule, t as RoutingSnapshot, u as RunTextSessionOptions, v as RunTextTranscriptOptions, S as SayOptions, w as SendDtmfOptions, x as SessionAdapter, y as SessionCapabilities, z as SessionErrorEvent, B as SessionEvent, G as SessionEventMap, H as SessionFactory, J as SessionFactoryInput, K as SessionOutbound, O as SessionState, Q as SpeechResult, T as SpeechTarget, U as StateChangeEvent, V as TextSession, W as TextTranscriptResult, X as TtsVoiceConfig, Y as TurnEvent, Z as Unsubscribe, _ as UserInputEvent, $ as UserStateEvent, a0 as UserTurn, a1 as applySpeechTurnHandling, a2 as dtmfCodeToDigit, a3 as dtmfDigitToCode, a4 as duck, a5 as mute, a6 as normalizeState, m as participantId, a7 as passthrough, a8 as runTextSession, a9 as runTextTranscript, aa as transform } from './text-session-oMqJh6SF.js';
 import { z, ZodType } from 'zod';
 import { OnQuery, BrainTransport } from './brain/index.js';
 export { BrainCallMetadata, BrainCapabilities, BrainChunk, BrainConfigError, BrainEndpointConfig, BrainMessage, BrainPubSub, BrainRequest, BrainRequestError, ConnectorChatModel, ConnectorChatModelOptions, ConnectorLLMOptions, IncomingBrainRequest, OnQueryContext, OnQueryResult, RedisBrainPubSub, SseDelta, TunnelBrainTransportOptions, assertPublicHttpsUrl, buildRedisBrainPubSub, callbackTransport, createConnectorLLM, httpBrainTransport, parseChatCompletionSse, runBrainRequest, tunnelBrainTransport } from './brain/index.js';
+import '@livekit/agents';
 import 'openai';
 import 'ioredis';
 
+/** What the worker fetches: the message, the conversation before it, and who sent it. */
+declare const TextTurn: z.ZodObject<{
+    turnId: z.ZodString;
+    agentId: z.ZodString;
+    /** The Line the message came in on (`sms`, `discord`, `web`, `playground`, …). */
+    channel: z.ZodString;
+    /** The sender on that Line (phone number, Discord user, widget visitor) — the agent's caller-scoped memory key. */
+    from: z.ZodString;
+    /** The conversation this turn belongs to (stable across turns) — the tool context's call id. */
+    conversationKey: z.ZodString;
+    history: z.ZodArray<z.ZodObject<{
+        role: z.ZodEnum<["user", "assistant"]>;
+        content: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        role: "user" | "assistant";
+        content: string;
+    }, {
+        role: "user" | "assistant";
+        content: string;
+    }>, "many">;
+    text: z.ZodString;
+    /** When the API stops waiting; the worker stops the run before it. */
+    deadlineAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    agentId: string;
+    turnId: string;
+    channel: string;
+    from: string;
+    conversationKey: string;
+    history: {
+        role: "user" | "assistant";
+        content: string;
+    }[];
+    deadlineAt: string;
+}, {
+    text: string;
+    agentId: string;
+    turnId: string;
+    channel: string;
+    from: string;
+    conversationKey: string;
+    history: {
+        role: "user" | "assistant";
+        content: string;
+    }[];
+    deadlineAt: string;
+}>;
+type TextTurn = z.infer<typeof TextTurn>;
+declare const TextTurnReply: z.ZodUnion<[z.ZodObject<{
+    agentId: z.ZodString;
+    replies: z.ZodArray<z.ZodString, "many">;
+    usage: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        /** Only a first-party worker's label is used; a customer's worker runs on its own key (the API decides). */
+        byok: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        provider: string;
+        model: string;
+        inputTokens: number;
+        outputTokens: number;
+        byok: boolean;
+    }, {
+        provider: string;
+        model: string;
+        inputTokens: number;
+        outputTokens: number;
+        byok: boolean;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    agentId: string;
+    replies: string[];
+    usage: {
+        provider: string;
+        model: string;
+        inputTokens: number;
+        outputTokens: number;
+        byok: boolean;
+    }[];
+}, {
+    agentId: string;
+    replies: string[];
+    usage?: {
+        provider: string;
+        model: string;
+        inputTokens: number;
+        outputTokens: number;
+        byok: boolean;
+    }[] | undefined;
+}>, z.ZodObject<{
+    agentId: z.ZodString;
+    error: z.ZodObject<{
+        code: z.ZodEnum<["agent_unavailable", "agent_timeout"]>;
+        detail: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        code: "agent_unavailable" | "agent_timeout";
+        detail?: string | undefined;
+    }, {
+        code: "agent_unavailable" | "agent_timeout";
+        detail?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    error: {
+        code: "agent_unavailable" | "agent_timeout";
+        detail?: string | undefined;
+    };
+    agentId: string;
+}, {
+    error: {
+        code: "agent_unavailable" | "agent_timeout";
+        detail?: string | undefined;
+    };
+    agentId: string;
+}>]>;
+type TextTurnReply = z.infer<typeof TextTurnReply>;
+
 /**
  * The plan itself. Everything the agent needs to run the call without the
  * host being present turn-by-turn.
@@ -2205,272 +2324,6 @@ interface CallOutcomeSummary {
  */
 declare function defineProcess<T extends Record<string, ProcessField>>(def: ProcessDefinition<T>): ProcessDefinition<T>;
 
-interface RunAgentTextTranscriptOptions {
-    /** The agent's system prompt / instructions (its code-defined behavior). */
-    readonly instructions: string;
-    /** The LLM that generates replies — injected so this stays provider-agnostic and
-     *  unit-testable (real inference/openai LLM in prod; a scripted fake in tests). */
-    readonly llm: llm.LLM;
-    /** Scripted caller turns, run in order; each produces the agent's reply turn(s). */
-    readonly messages: readonly string[];
-    /** Optional id surfaced on the Agent (for traceability). */
-    readonly agentId?: string;
-}
-interface AgentTextTranscriptResult {
-    readonly replies: string[];
-}
-interface RunLiveAgentTextOptions {
-    /** The agent's system prompt / instructions (its code-defined behavior). */
-    readonly instructions: string;
-    /** The LLM that generates replies (injected — real provider LLM or a fake). */
-    readonly llm: llm.LLM;
-    /** Optional id surfaced on the Agent (for traceability). */
-    readonly agentId?: string;
-    /**
-     * Labels for the model usage each turn reports (the surface that owns the reply meters it): which provider and
-     * model this session's LLM is, and whether the workspace's own key (BYOK) serves it. Absent ⇒ turns report no usage.
-     */
-    readonly meter?: {
-        readonly provider: string;
-        readonly model: string;
-        readonly byok: boolean;
-    };
-}
-/** Model usage behind one turn (one entry per model request) — the host-sdk `TurnModelUsage` shape, structurally. */
-interface LiveAgentTurnUsage {
-    readonly provider: string;
-    readonly model: string;
-    readonly inputTokens: number;
-    readonly outputTokens: number;
-    readonly byok: boolean;
-}
-/** One live turn of a code-first agent: the assistant text for that turn, and
- *  whether the conversation ended (code-first sessions stay open until `end`). */
-interface LiveAgentTurn {
-    readonly replies: string[];
-    readonly done: boolean;
-    /** The model requests this turn made (only when the session was given `meter` labels). */
-    readonly usage?: readonly LiveAgentTurnUsage[];
-}
-/** A live, turn-by-turn conversation with a code-first agent — the AgentSession is
- *  kept alive across turns (it carries chat history internally), so this is the
- *  code-first analogue of `runLiveTextConversation` (the flow driver). Shape
- *  matches the engine's AgentConversation so the agent-runner drives both alike. */
-interface LiveAgentTextSession {
-    /** Start the session. Code-first agents don't auto-greet in no-room text mode,
-     *  so the opening turn is empty; the first user turn produces the first reply. */
-    start(): Promise<LiveAgentTurn>;
-    /** Feed one user message; resolves with the agent's replies for that turn. */
-    turn(text: string): Promise<LiveAgentTurn>;
-    /** Close the session. */
-    end(): Promise<void>;
-}
-declare function runLiveAgentTextSession(opts: RunLiveAgentTextOptions): LiveAgentTextSession;
-/** Drive an instruction-based agent over text and collect its replies. Stateless
- *  batch turn — built on the live driver (start → turn per message → end). */
-declare function runAgentTextTranscript(opts: RunAgentTextTranscriptOptions): Promise<AgentTextTranscriptResult>;
-
-interface WrapOptions<T> {
-    /** Emit OTel spans around each method call. Default: true. */
-    readonly trace?: boolean;
-    /** Tag spans with `vl.provider.label` for easy filtering. */
-    readonly label?: string;
-    /**
-     * Fallback provider used if the primary throws. Accepts an instance OR a
-     * ProviderFactory (so `deepgram.tts(...)` works directly). The fallback is
-     * resolved lazily on first error.
-     */
-    readonly fallback?: T | ProviderFactory<T>;
-    /**
-     * Methods to instrument. By default the wrapper instruments every method
-     * call. Pass an explicit list to limit overhead on hot paths.
-     */
-    readonly methods?: readonly string[];
-}
-/**
- * Returns either the wrapped instance directly (when called with one) or a
- * ProviderFactory that produces the wrapped instance (when called with one of
- * those). This keeps the lazy import story intact: `wrap(deepgram.tts(...))`
- * is itself a factory.
- */
-declare function wrap<T extends object>(target: T | ProviderFactory<T>, options?: WrapOptions<T>): T | ProviderFactory<T>;
-
-interface ProviderCreds {
-    readonly apiKey?: string;
-    readonly baseURL?: string;
-}
-declare const deepgram: {
-    stt(options?: {
-        model?: string;
-        language?: string;
-        apiKey?: string;
-        baseURL?: string;
-    }): ProviderFactory<STTProvider>;
-    tts(options?: {
-        model?: string;
-        apiKey?: string;
-        baseURL?: string;
-    }): ProviderFactory<TTSProvider>;
-};
-declare const openai: {
-    llm(options?: {
-        model?: string;
-        apiKey?: string;
-        baseURL?: string;
-    }): ProviderFactory<LLMProvider>;
-    tts(options?: {
-        model?: string;
-        voice?: string;
-        instructions?: string;
-        apiKey?: string;
-        baseURL?: string;
-    }): ProviderFactory<TTSProvider>;
-    realtime(options?: {
-        model?: string;
-        voice?: string;
-        apiKey?: string;
-        baseURL?: string;
-    }): ProviderFactory<RealtimeProvider>;
-};
-declare const cartesia: {
-    tts(options?: {
-        voice?: string;
-        model?: string;
-        apiKey?: string;
-        baseURL?: string;
-    }): ProviderFactory<TTSProvider>;
-    stt(options?: {
-        model?: string;
-        language?: string;
-        apiKey?: string;
-        baseURL?: string;
-    }): ProviderFactory<STTProvider>;
-};
-declare const elevenlabs: {
-    tts(options?: {
-        voice?: string;
-        model?: string;
-        apiKey?: string;
-        baseURL?: string;
-    }): ProviderFactory<TTSProvider>;
-};
-declare const assemblyai: {
-    stt(options?: {
-        language?: string;
-        apiKey?: string;
-        baseURL?: string;
-    }): ProviderFactory<STTProvider>;
-};
-declare const google: {
-    llm(options?: {
-        model?: string;
-        apiKey?: string;
-        baseURL?: string;
-    }): ProviderFactory<LLMProvider>;
-    realtime(options?: {
-        model?: string;
-        voice?: string;
-        apiKey?: string;
-        baseURL?: string;
-    }): ProviderFactory<RealtimeProvider>;
-};
-declare const silero: {
-    vad(): ProviderFactory<VADProvider>;
-};
-declare const livekitTurn: {
-    english(): ProviderFactory<TurnDetectorProvider>;
-    multilingual(): ProviderFactory<TurnDetectorProvider>;
-};
-interface ConnectorLLMConfig {
-    /** Upstream model id / alias (defaults to the brain's own default). */
-    readonly model?: string;
-    readonly temperature?: number;
-    /** Spoken instead of dead air when the brain errors before replying. */
-    readonly fallbackText?: string;
-    /** In-process brain. */
-    readonly onQuery?: OnQuery;
-    /** Direct-egress brain — a public OpenAI-compatible base URL. */
-    readonly url?: string;
-    /** API key for the direct-egress endpoint. */
-    readonly apiKey?: string;
-    /** Hostnames that bypass the SSRF IP checks (direct mode). */
-    readonly allowHosts?: readonly string[];
-    /** Advanced: a custom transport (tunnel, etc.). */
-    readonly transport?: BrainTransport;
-}
-declare const connector: {
-    llm(config?: ConnectorLLMConfig): ProviderFactory<LLMProvider>;
-};
-
-/** The control-plane reads the resolver needs. Structural (not the full
- *  VoiceLayerClient) so it stays trivially fakeable in tests — a real client
- *  satisfies it. */
-interface AgentTextRuntimeClient {
-    readonly agents: {
-        getPrompt(agentId: string): Promise<string | null>;
-        getConfig(agentId: string): Promise<{
-            readonly model?: {
-                readonly provider: string;
-                readonly model: string;
-            };
-            readonly routingInstructions?: string | undefined;
-        } | null>;
-    };
-    readonly connections: {
-        resolveProviderCredential(provider: string): Promise<{
-            readonly apiKey: string;
-            readonly baseUrl?: string | undefined;
-        } | null>;
-    };
-}
-interface ResolvedAgentTextRuntime {
-    /** The composed system prompt (persona + routing), ready for the AgentSession. */
-    readonly instructions: string;
-    /** The concrete provider LLM that generates replies. */
-    readonly llm: llm.LLM;
-    /** Which provider/model resolved — surfaced for traceability/logging. */
-    readonly model: {
-        readonly provider: string;
-        readonly model: string;
-    };
-    /** True when a project BYOK key backed the LLM (vs the platform env key). */
-    readonly byok: boolean;
-}
-/** Builds the concrete provider LLM from (provider, model, BYOK creds). Injectable
- *  so tests can substitute a fake without loading a provider plugin. */
-type BuildTextLlm = (providerId: string, modelId: string, creds: ProviderCreds | undefined) => Promise<llm.LLM>;
-interface ResolveAgentTextRuntimeOptions {
-    /** Override the LLM build (tests). Defaults to the real provider registry. */
-    readonly buildLlm?: BuildTextLlm;
-}
-/** A code-first agent's resolved text runtime WITHOUT the built LLM — the cheap,
- *  shareable part (instructions + which provider/model + BYOK creds). Cache THIS
- *  and build a fresh LLM per session, never the LLM itself (an lk.LLM is a live
- *  EventEmitter — sharing one across concurrent sessions cross-fires errors). */
-interface AgentTextPlan {
-    readonly instructions: string;
-    readonly provider: string;
-    readonly model: string;
-    readonly creds?: ProviderCreds;
-    readonly byok: boolean;
-}
-/**
- * Resolve a code-first agent's text PLAN (instructions + provider/model + BYOK),
- * or `null` when it isn't code-first-runnable (no synced prompt). No LLM built —
- * this is the cacheable part. Best-effort on the pipeline: a missing/blank config
- * falls back to the platform default model, mirroring the live path.
- */
-declare function resolveAgentTextPlan(agentId: string, client: AgentTextRuntimeClient): Promise<AgentTextPlan | null>;
-/** Build a fresh provider LLM for a plan. Call once PER SESSION so no two live
- *  sessions ever share an lk.LLM instance. */
-declare function buildTextLlm(plan: AgentTextPlan, buildLlm?: BuildTextLlm): Promise<llm.LLM>;
-/**
- * Resolve a code-first agent's text runtime (plan + a freshly-built LLM), or
- * `null` when it isn't runnable. Convenience over resolveAgentTextPlan +
- * buildTextLlm — kept for callers that want a one-shot runtime (and tests).
- */
-declare function resolveAgentTextRuntime(agentId: string, client: AgentTextRuntimeClient, opts?: ResolveAgentTextRuntimeOptions): Promise<ResolvedAgentTextRuntime | null>;
-
 interface TransportOptions {
     readonly apiKey: string;
     readonly baseUrl: string;
@@ -2512,10 +2365,15 @@ interface RegisterInput {
     readonly processSchema?: ProcessSchemaDTO | null;
     /**
      * A code-first agent's base prompt (its `defineAgent({ prompt })`). Synced to
-     * the agent's record so a generic runner can run it over text by id (P2). Omit
-     * for flow agents (their behavior lives in the compiled program).
+     * the agent's record (the dashboard shows it). Omit for flow agents (their
+     * behavior lives in the compiled program).
      */
     readonly prompt?: string | null;
+    /**
+     * The text-turn protocol this worker speaks (burn-down G-4): it registered `<name>::text` and answers text turns as
+     * the agent. Omit when it doesn't — the agent is then not text-runnable.
+     */
+    readonly textTurns?: number;
     /**
      * Opt this agent into MCP exposure. When true, the API upserts a matching
      * agent_config row keyed by (project_id, name, environment) so MCP /
@@ -2603,6 +2461,10 @@ declare class AgentsClient {
      * through the engine over text. Returns null on 404 or when the agent has no
      * synced prompt (flow agents, or agents registered before the sync landed).
      */
+    /** A text turn dispatched to this worker (burn-down G-4); null when it's gone or isn't this agent's. */
+    fetchTextTurn(turnId: string, agentId: string): Promise<TextTurn | null>;
+    /** Answer a text turn. False when the API no longer waits for it (answered already, or past its deadline). */
+    replyTextTurn(turnId: string, reply: TextTurnReply): Promise<boolean>;
     getPrompt(agentId: string): Promise<string | null>;
     /**
      * Fetch a deployed agent's PUBLISHED AgentConfig — the pipeline the owner
@@ -3165,6 +3027,8 @@ declare function formTools(vl: VoiceLayerClient, options?: FormToolsOptions): Re
 declare class Agent {
     private readonly config;
     private registered;
+    /** Whether this process registered `<name>::text` and takes text turns (said so at registration). */
+    private textTurns;
     private processStatePublisher;
     constructor(config: AgentConfig);
     /**
@@ -3205,41 +3069,6 @@ declare function defineFlowRuntime(opts: {
     readonly version?: string;
 }): Agent;
 
-interface PuppetControlDeps {
-    /**
-     * LiveKit room name — used as the control-channel key. This is the only
-     * identifier the agent reliably has at dispatch time (the API-side
-     * project_calls UUID may not even exist yet when the agent boots, since
-     * the LK `room_started` webhook fires after dispatch).
-     *
-     * The API translates UUID → room name before publishing — see
-     * apps/api/src/routes/call-control.ts.
-     */
-    readonly roomName: string;
-    readonly session: unknown;
-    readonly onHangup: () => Promise<void>;
-    readonly onDtmf?: (digits: string) => Promise<void>;
-    readonly log?: (msg: string, attrs?: Record<string, unknown>) => void;
-}
-interface PuppetControlHandle {
-    /** Stop listening for commands and tear down the Redis subscription. */
-    close(): Promise<void>;
-}
-/** @deprecated since 0.2.0 — see startPuppetControl. True if we should run puppet wiring — REDIS_URL must be set. */
-declare function puppetEnvAvailable(): boolean;
-/**
- * @deprecated since 0.2.0 (burn-down G-5): every agent now listens on its call's control channel and confirms each
- * command (runtime/call-control.ts + runtime/host-control.ts). This listener never confirms, so the API refuses its
- * commands. Kept for SDK consumers that call it directly; removed in the next major.
- *
- * Start a puppet-mode control listener for the given call. Returns a handle
- * the caller invokes when the call ends to release the Redis connection.
- *
- * Pubsub semantics: one IORedis subscriber per call. Cheap (Valkey handles
- * thousands of subscriptions per node) and isolates listener teardown from
- * other calls in the same agent process.
- */
-declare function startPuppetControl(deps: PuppetControlDeps): Promise<PuppetControlHandle>;
 /**
  * Build a no-op LLM compatible with @livekit/agents voice.AgentSession.
  * Used in puppet mode to suppress autonomous replies — every STT turn
@@ -3282,6 +3111,134 @@ declare function webhook(config: WebhookConfig): ConnectorInstance<'webhook', We
 /** Subset of ModelConfig the Agent class converts AgentConfig.models into. */
 type PipelineConfig = ModelConfig;
 
+interface WrapOptions<T> {
+    /** Emit OTel spans around each method call. Default: true. */
+    readonly trace?: boolean;
+    /** Tag spans with `vl.provider.label` for easy filtering. */
+    readonly label?: string;
+    /**
+     * Fallback provider used if the primary throws. Accepts an instance OR a
+     * ProviderFactory (so `deepgram.tts(...)` works directly). The fallback is
+     * resolved lazily on first error.
+     */
+    readonly fallback?: T | ProviderFactory<T>;
+    /**
+     * Methods to instrument. By default the wrapper instruments every method
+     * call. Pass an explicit list to limit overhead on hot paths.
+     */
+    readonly methods?: readonly string[];
+}
+/**
+ * Returns either the wrapped instance directly (when called with one) or a
+ * ProviderFactory that produces the wrapped instance (when called with one of
+ * those). This keeps the lazy import story intact: `wrap(deepgram.tts(...))`
+ * is itself a factory.
+ */
+declare function wrap<T extends object>(target: T | ProviderFactory<T>, options?: WrapOptions<T>): T | ProviderFactory<T>;
+
+declare const deepgram: {
+    stt(options?: {
+        model?: string;
+        language?: string;
+        apiKey?: string;
+        baseURL?: string;
+    }): ProviderFactory<STTProvider>;
+    tts(options?: {
+        model?: string;
+        apiKey?: string;
+        baseURL?: string;
+    }): ProviderFactory<TTSProvider>;
+};
+declare const openai: {
+    llm(options?: {
+        model?: string;
+        apiKey?: string;
+        baseURL?: string;
+    }): ProviderFactory<LLMProvider>;
+    tts(options?: {
+        model?: string;
+        voice?: string;
+        instructions?: string;
+        apiKey?: string;
+        baseURL?: string;
+    }): ProviderFactory<TTSProvider>;
+    realtime(options?: {
+        model?: string;
+        voice?: string;
+        apiKey?: string;
+        baseURL?: string;
+    }): ProviderFactory<RealtimeProvider>;
+};
+declare const cartesia: {
+    tts(options?: {
+        voice?: string;
+        model?: string;
+        apiKey?: string;
+        baseURL?: string;
+    }): ProviderFactory<TTSProvider>;
+    stt(options?: {
+        model?: string;
+        language?: string;
+        apiKey?: string;
+        baseURL?: string;
+    }): ProviderFactory<STTProvider>;
+};
+declare const elevenlabs: {
+    tts(options?: {
+        voice?: string;
+        model?: string;
+        apiKey?: string;
+        baseURL?: string;
+    }): ProviderFactory<TTSProvider>;
+};
+declare const assemblyai: {
+    stt(options?: {
+        language?: string;
+        apiKey?: string;
+        baseURL?: string;
+    }): ProviderFactory<STTProvider>;
+};
+declare const google: {
+    llm(options?: {
+        model?: string;
+        apiKey?: string;
+        baseURL?: string;
+    }): ProviderFactory<LLMProvider>;
+    realtime(options?: {
+        model?: string;
+        voice?: string;
+        apiKey?: string;
+        baseURL?: string;
+    }): ProviderFactory<RealtimeProvider>;
+};
+declare const silero: {
+    vad(): ProviderFactory<VADProvider>;
+};
+declare const livekitTurn: {
+    english(): ProviderFactory<TurnDetectorProvider>;
+    multilingual(): ProviderFactory<TurnDetectorProvider>;
+};
+interface ConnectorLLMConfig {
+    /** Upstream model id / alias (defaults to the brain's own default). */
+    readonly model?: string;
+    readonly temperature?: number;
+    /** Spoken instead of dead air when the brain errors before replying. */
+    readonly fallbackText?: string;
+    /** In-process brain. */
+    readonly onQuery?: OnQuery;
+    /** Direct-egress brain — a public OpenAI-compatible base URL. */
+    readonly url?: string;
+    /** API key for the direct-egress endpoint. */
+    readonly apiKey?: string;
+    /** Hostnames that bypass the SSRF IP checks (direct mode). */
+    readonly allowHosts?: readonly string[];
+    /** Advanced: a custom transport (tunnel, etc.). */
+    readonly transport?: BrainTransport;
+}
+declare const connector: {
+    llm(config?: ConnectorLLMConfig): ProviderFactory<LLMProvider>;
+};
+
 /**
  * Turn the persisted `agents.process_schema` (or a freshly-compiled flow) into a
  * ProcessDefinition. The completion gate drives the `required` flags so the
@@ -3321,13 +3278,6 @@ interface ExchangeWorkerTokenInput {
  *  attributable to a specific call in the API's audit log. Returns null when
  *  the exchange isn't configured or fails — callers fall back to the env key. */
 declare function exchangeWorkerToken(input: ExchangeWorkerTokenInput): Promise<string | null>;
-/** Build a client directly from a PRE-MINTED worker token (W3-lite control-plane
- *  mint). The authority (API for text, call-router for voice) minted the token
- *  from the projectId it already holds and handed it to the worker — so the
- *  worker never self-mints via /v1/internal/worker-token, closing the master-key
- *  path where a worker asserts its own projectId. Returns null on a bad token so
- *  callers can fall back to the self-mint chain (resolveWorkerClient). */
-declare function workerClientFromToken(token: string): VoiceLayerClient | null;
 /** Build the per-call SDK client under the calling project's identity, with
  *  the env-key fallback chain above. `md` is the parsed dispatch metadata. */
 declare function resolveWorkerClient(md: Record<string, unknown>, fetchImpl?: typeof fetch): Promise<VoiceLayerClient | null>;
@@ -3383,4 +3333,4 @@ interface HttpToolSpec {
  */
 declare function httpTool(spec: HttpToolSpec): Record<string, ToolDefinition>;
 
-export { Agent, type AgentConfig, AgentContext, type AgentEventEmitter, type AgentEventListener, type AgentLifecycleEvent, type AgentTextPlan, type AgentTextRuntimeClient, type AgentTextTranscriptResult, type AppendDtmfEventInput, type AppendTranscriptInput, BaseTool, BrainTransport, type BuildTextLlm, type CallAttributeValue, CallInfo, type CallLegInput, type CallOutcomeSummary, type CallParticipantInput, type CallStatus, type CallSummary, CallsClient, type CompiledAgentParts, type CompletionStrategy, type ComplianceTag, type ConnectorInstance, type ConnectorLLMConfig, ConsultationPolicy, type CreateClientOptions, type CreatedFormSession, type DefaultMetadata, type DtmfDirection, EmailClient, type SendEmailInput as EmailSendInput, type EndCallInfo, type EndCallPolicy, type EndCallTrigger, type EndpointingConfig, type EnsureCallByRoomInput, type ExchangeWorkerTokenInput, type CreateFormSessionInput as FormCreateInput, type FormToolsOptions, FormsClient, type HandoffConfig, type HttpToolResult, type HttpToolSpec, type InferProcessData, type InterruptionConfig, type LLMProvider, type LiveAgentTextSession, type LiveAgentTurn, type LiveAgentTurnUsage, type MemoryConfig, type MemoryScope, type ModelConfig, OnQuery, Participant, type ParticipantsConfig, type PipelineConfig, PlansClient, type ProcessBackendAck, type ProcessDefinition, type ProcessField, type ProcessFieldType, type PronunciationDict, type ProviderFactory, type PublicFormSessionView, type PuppetControlDeps, type PuppetControlHandle, type ReadinessProbe, type ReadinessReport, type ReadinessResult, type RealtimeProvider, type RegisterInput, type RegisterOptions, type RegisteredAgent, type ResendCredentials, type ResendEmailToolOptions, type ResolveAgentTextRuntimeOptions, type ResolvedAgentTextRuntime, type RunAgentTextTranscriptOptions, type RunLiveAgentTextOptions, type STTProvider, type SecurityConfig, type SentEmail, type ShorthandPrimitive$1 as ShorthandPrimitive, type SpeechConfig, type SyncCallStateInput, type TTSProvider, type ToolDefinition$1 as ToolDefinition, type ToolInputShape$1 as ToolInputShape, type TriggerAction, type TriggerCondition, type TriggerDefinition, type TurnDetectorProvider, type VADProvider, VoiceLayerAuthError, type VoiceLayerClient, VoiceLayerError, VoiceLayerHttpError, VoiceLayerNetworkError, VoiceLayerValidationError, type WebhookApi, type WebhookConfig, type WrapOptions, applyPronunciations, assemblyai, asyncProbe, buildTextLlm, cartesia, collectDefaultMetadata, connector, createClient, createNoOpLLM, deepgram, defineAgent, defineFlowRuntime, defineProcess, defineTool, elevenlabs, envProbe, exchangeWorkerToken, formTools, google, httpTool, livekitTurn, mergeMetadata, openai, processSchemaToAgentParts, processSchemaToDefinition, puppetEnvAvailable, resendEmailTool, resolveAgentTextPlan, resolveAgentTextRuntime, resolveWorkerClient, runAgentTextTranscript, runLiveAgentTextSession, runProbes, silero, startPuppetControl, urlProbe, webhook, workerClientFromToken, wrap };
+export { Agent, type AgentConfig, AgentContext, type AgentEventEmitter, type AgentEventListener, type AgentLifecycleEvent, type AppendDtmfEventInput, type AppendTranscriptInput, BaseTool, BrainTransport, type CallAttributeValue, CallInfo, type CallLegInput, type CallOutcomeSummary, type CallParticipantInput, type CallStatus, type CallSummary, CallsClient, type CompiledAgentParts, type CompletionStrategy, type ComplianceTag, type ConnectorInstance, type ConnectorLLMConfig, ConsultationPolicy, type CreateClientOptions, type CreatedFormSession, type DefaultMetadata, type DtmfDirection, EmailClient, type SendEmailInput as EmailSendInput, type EndCallInfo, type EndCallPolicy, type EndCallTrigger, type EndpointingConfig, type EnsureCallByRoomInput, type ExchangeWorkerTokenInput, type CreateFormSessionInput as FormCreateInput, type FormToolsOptions, FormsClient, type HandoffConfig, type HttpToolResult, type HttpToolSpec, type InferProcessData, type InterruptionConfig, type LLMProvider, type MemoryConfig, type MemoryScope, type ModelConfig, OnQuery, Participant, type ParticipantsConfig, type PipelineConfig, PlansClient, type ProcessBackendAck, type ProcessDefinition, type ProcessField, type ProcessFieldType, type PronunciationDict, type ProviderFactory, type PublicFormSessionView, type ReadinessProbe, type ReadinessReport, type ReadinessResult, type RealtimeProvider, type RegisterInput, type RegisterOptions, type RegisteredAgent, type ResendCredentials, type ResendEmailToolOptions, type STTProvider, type SecurityConfig, type SentEmail, type ShorthandPrimitive$1 as ShorthandPrimitive, type SpeechConfig, type SyncCallStateInput, type TTSProvider, type ToolDefinition$1 as ToolDefinition, type ToolInputShape$1 as ToolInputShape, type TriggerAction, type TriggerCondition, type TriggerDefinition, type TurnDetectorProvider, type VADProvider, VoiceLayerAuthError, type VoiceLayerClient, VoiceLayerError, VoiceLayerHttpError, VoiceLayerNetworkError, VoiceLayerValidationError, type WebhookApi, type WebhookConfig, type WrapOptions, applyPronunciations, assemblyai, asyncProbe, cartesia, collectDefaultMetadata, connector, createClient, createNoOpLLM, deepgram, defineAgent, defineFlowRuntime, defineProcess, defineTool, elevenlabs, envProbe, exchangeWorkerToken, formTools, google, httpTool, livekitTurn, mergeMetadata, openai, processSchemaToAgentParts, processSchemaToDefinition, resendEmailTool, resolveWorkerClient, runProbes, silero, urlProbe, webhook, wrap };