@pipedog/openai 0.0.0 → 0.3.0

package/dist/live/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/live/index.js

@@ -0,0 +1,8 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/services/openai/live/__init__.py
+// Upstream's package __init__ is empty: import the submodules directly.
+export {};
+//# sourceMappingURL=index.js.map

package/dist/live/llm.d.ts

@@ -0,0 +1,566 @@
+/**
+ * OpenAI Live LLM service: full-duplex speech-to-speech over WebSocket.
+ *
+ * Porting notes:
+ * - The WebSocket is opened with `websocketConnect` from core, which sends
+ *   the `Authorization` header on Bun, Node and Deno. Runtimes whose
+ *   `WebSocket` can't send headers (Cloudflare Workers) pass a
+ *   `webSocketFactory` (an addition to the upstream options).
+ * - `parse_server_event` raises only `ValueError`, which the receive loop
+ *   skips; here any (non-cancellation) error from `parseServerEvent` is
+ *   treated as that.
+ * - `OpenAIResponsesReasoningConfig` is sent as its set fields (`effort`,
+ *   `summary`, `mode`), which is what upstream's `model_dump(exclude_none=True)`
+ *   produces.
+ */
+import { Event, Lock, type Task } from "@pipedog/asyncio";
+import type { BaseLLMAdapter } from "@pipedog/core/adapters/base_llm_adapter";
+import { type CancelFrame, type EndFrame, type Frame, FunctionCallCancelFrame, FunctionCallResultFrame, InputAudioRawFrame, LLMServiceMetadataFrame } from "@pipedog/core/frames/frames";
+import type { LLMContext, LLMStandardMessage } from "@pipedog/core/processors/aggregators/llm_context";
+import { FrameDirection, type FrameProcessorSetup } from "@pipedog/core/processors/frame_processor";
+import { LLMService, type LLMServiceOptions, type LLMWithBackendRole } from "@pipedog/core/services/llm_service";
+import { LLMSettings, type LLMSettingsOptions } from "@pipedog/core/services/settings";
+import { type WebsocketClientConnection, type WebsocketConnectOptions } from "@pipedog/core/services/websocket_service";
+import { type NotGiven } from "@pipedog/core/utils/types";
+import { _BackendSession, BackendError, BackendIdle, BackendLLMWorker, BackendOutput, BackendToolCall } from "@pipedog/core/workers/llm/backend_llm_worker";
+import { OpenAILiveLLMAdapter, type OpenAILiveLLMInvocationParams } from "../open_ai_live_adapter.ts";
+import { type OpenAIResponsesLLMSettings } from "../responses/llm.ts";
+import * as events from "./events.ts";
+export declare const DEFAULT_MODEL = "gpt-live-1";
+export declare const TURN_GAP_SECS = 0.8;
+export declare const SESSION_CLOSE_TIMEOUT_SECS = 10;
+/** How long a delegation waits for the session with the backend to open. */
+export declare const BACKEND_ATTACH_TIMEOUT_SECS = 5;
+export declare const MAX_CONTEXT_APPEND_TOKENS = 450;
+export interface OpenAILiveLLMSettingsOptions extends LLMSettingsOptions {
+    /**
+     * Output voice name (for example `marin` or `cedar`). `null` leaves the
+     * choice to the API. Cannot be changed once the session has started.
+     */
+    voice?: string | null | NotGiven;
+    /**
+     * Whether the API keeps the session, making it available for 30 days as a
+     * stereo recording from `GET /v1/live/sessions/{id}/content` and as a
+     * source a later session can fork from. `false` by default at the API, and
+     * requires a project whose data policy permits persistence. Cannot be
+     * changed once the session has started.
+     */
+    store?: boolean | null | NotGiven;
+}
+/**
+ * Settings for OpenAILiveLLMService.
+ *
+ * - `voice`: output voice name (for example `marin` or `cedar`). `null`
+ *   leaves the choice to the API. Cannot be changed once the session has
+ *   started.
+ * - `store`: whether the API keeps the session, making it available for 30
+ *   days as a stereo recording from `GET /v1/live/sessions/{id}/content` and
+ *   as a source a later session can fork from. `false` by default at the API,
+ *   and requires a project whose data policy permits persistence. Cannot be
+ *   changed once the session has started.
+ */
+export declare class OpenAILiveLLMSettings extends LLMSettings {
+    voice: string | null | NotGiven;
+    store: boolean | null | NotGiven;
+    constructor(options?: OpenAILiveLLMSettingsOptions);
+}
+/**
+ * One speaker's in-progress turn, assembled from timed transcript fragments.
+ *
+ * - `gapSecs`: quiet time that ends the turn.
+ * - `text`: fragments accumulated so far.
+ * - `open`: whether a turn is currently open.
+ * - `timer`: the task that closes the turn once `gapSecs` elapses.
+ * - `lock`: held while the turn opens or closes. The timer runs in its own
+ *   task, so this is what keeps one turn's end frames from landing among the
+ *   next turn's start frames.
+ */
+export declare class _TurnGrouper {
+    gapSecs: number;
+    text: string;
+    open: boolean;
+    timer: Task<unknown> | null;
+    lock: Lock;
+    constructor(options: {
+        gapSecs: number;
+    });
+}
+/**
+ * A client delegation in progress: what to correlate the backend's outputs with.
+ *
+ * - `id`: the delegation's id, which the appends carry.
+ * - `answered`: whether the backend has sent a spoken output for it yet; its
+ *   notes do not count.
+ * - `timeoutTask`: the task that abandons it if the backend takes too long.
+ */
+export declare class _LiveDelegation {
+    id: string;
+    answered: boolean;
+    timeoutTask: Task<unknown> | null;
+    constructor(options: {
+        id: string;
+    });
+}
+export interface ResponsesDelegationOptions {
+    /**
+     * Request settings for the backend model — the same object
+     * `OpenAIResponsesLLMService` takes. `model` is required.
+     */
+    settings: OpenAIResponsesLLMSettings;
+    /**
+     * Responses API service tier for delegated requests (`auto`, `default`,
+     * `flex` or `priority`).
+     */
+    serviceTier?: string | null;
+}
+/**
+ * Responses delegation: OpenAI hosts the backend model the live model delegates to.
+ *
+ * Hosted tools run server-side; function calls are executed by this service
+ * with the handlers registered for the tools in the pipeline's `LLMContext`
+ * (which is also where the backend model's `tools` and `tool_choice` come
+ * from).
+ *
+ * - `settings`: request settings for the backend model — the same object
+ *   `OpenAIResponsesLLMService` takes. `model` is required.
+ *   `systemInstruction` becomes the backend's `instructions`,
+ *   `maxCompletionTokens` its `max_output_tokens`, `reasoning` is sent when
+ *   configured (the server default applies otherwise) and `extra` is merged
+ *   into the delegation configuration. Fields the Live API doesn't accept for
+ *   a delegated model (`temperature`, `topP`, the penalties, `seed`, `topK`,
+ *   `maxTokens`, and the user-turn-completion fields) are dropped with a
+ *   warning.
+ * - `serviceTier`: Responses API service tier for delegated requests
+ *   (`auto`, `default`, `flex` or `priority`).
+ */
+export declare class ResponsesDelegation {
+    settings: OpenAIResponsesLLMSettings;
+    serviceTier: string | null;
+    constructor(options: ResponsesDelegationOptions);
+}
+export interface ClientDelegationOptions {
+    /**
+     * The worker that runs delegated work — normally a `BackendLLMWorker`
+     * wrapping any LLM service, or the name of one registered elsewhere.
+     */
+    backend: BackendLLMWorker | string;
+    /** How long a delegation may take before it is abandoned. Defaults to 120. */
+    timeoutSecs?: number;
+}
+/**
+ * Client delegation: a Pipecat worker is the backend the live model delegates to.
+ *
+ * A delegation names no task: the live model signals only that it is handing
+ * work over. Each one is put to the backend as a message carrying the
+ * transcript fragments since the previous delegation, and the backend works
+ * out the request from them. The service attaches to the backend for its
+ * life and takes delegations one at a time: the next waits until the backend
+ * reports it has nothing left to do, since they share one backend
+ * conversation.
+ *
+ * What comes back is appended to the live session according to each output's
+ * `prefersSpoken` flag: what it wants heard goes as commentary, for the model
+ * to relay in its own words, and the rest as thinking — silent context it can
+ * draw on if the conversation turns that way.
+ *
+ * - `backend`: the worker that runs delegated work — normally a
+ *   `BackendLLMWorker` wrapping any LLM service, or the name of one
+ *   registered elsewhere (in the app, or in another process on a shared
+ *   bus). A worker given here is registered as a child of the pipeline worker
+ *   at setup, so the pipeline must run under a `WorkerRunner`.
+ * - `timeoutSecs`: how long a delegation may take before it is abandoned.
+ */
+export declare class ClientDelegation {
+    backend: BackendLLMWorker | string;
+    timeoutSecs: number;
+    constructor(options: ClientDelegationOptions);
+}
+/**
+ * A delegated Responses run whose function calls we are collecting.
+ *
+ * - `callIds`: calls still awaiting an output.
+ * - `hadCalls`: whether the response asked for any function call at all.
+ * - `finished`: whether the response emitted all of its output items.
+ */
+export declare class _PendingResponse {
+    callIds: Set<string>;
+    hadCalls: boolean;
+    finished: boolean;
+}
+export interface OpenAILiveLLMServiceOptions extends LLMServiceOptions {
+    /** OpenAI project API key. */
+    apiKey: string;
+    /** WebSocket base URL of the Live API. */
+    baseUrl?: string;
+    /**
+     * Runtime-updatable settings. `model`, `voice`, `store` and
+     * `systemInstruction` are fixed once the session has started.
+     */
+    settings?: OpenAILiveLLMSettings | null;
+    /**
+     * Where the model's delegated work runs. `null` selects client delegation
+     * with no backend configured.
+     */
+    delegation?: ResponsesDelegation | ClientDelegation | null;
+    /**
+     * Creates the underlying `WebSocket` (see `WebsocketConnectOptions`), for
+     * runtimes whose `WebSocket` can't send the `Authorization` header.
+     */
+    webSocketFactory?: WebsocketConnectOptions["webSocketFactory"];
+}
+/**
+ * OpenAI Live LLM service: full-duplex speech-to-speech over WebSocket.
+ *
+ * The live model (`gpt-live-1`) listens and speaks at the same time. It
+ * decides on its own when to answer, when to stop talking when the user
+ * speaks over it, and when to *delegate* work — search, reasoning, tool use —
+ * to a backend text model while the conversation continues. In the
+ * frontend/backend terms used throughout, the live model is the *frontend*
+ * (the conversational model) and the delegated-to model is the *backend*.
+ * There is no client-side turn detection or response triggering: the
+ * pipeline streams audio in and plays audio out.
+ *
+ * Delegation modes, selected with `delegation`:
+ *
+ * - `ResponsesDelegation` — OpenAI hosts the backend (Responses API) model.
+ *   Function calls it makes are executed here with the handlers registered
+ *   for the pipeline context's tools; results go back to the API as soon as
+ *   they are available.
+ * - `ClientDelegation` — a `BackendLLMWorker` running any Pipecat LLM service
+ *   is the backend. The model does not share its conversation with the
+ *   backend, so the service ships the transcript turns since the previous
+ *   delegation along with each request.
+ * - `null` — client delegation mode with no backend configured; delegated
+ *   requests are declined.
+ *
+ * Turn frames: the service proposes user turn boundaries from the API's
+ * projected transcript turns, and the recommended
+ * `new ExternalUserTurnStrategies({ enableInterruptions: false })` resolve
+ * them into `UserStartedSpeakingFrame` / `UserStoppedSpeakingFrame` **without
+ * broadcasting interruptions**: the model handles being talked over itself,
+ * and a delegation keeps running when that happens (the model is expected to
+ * disregard results the conversation has moved past). As a consequence every
+ * tool behaves as `cancelOnInterruption: false`; use `cancellableByLlm: true`
+ * for tools the model should be able to cancel on request.
+ *
+ * The context aggregators record both sides of the conversation from the
+ * transcript frames. Unlike the Realtime services, this one is not flagged as
+ * a realtime service for the aggregators: the service closes a user turn
+ * itself once the speaker falls quiet and pushes its final transcript then,
+ * so the user aggregator writes each user turn to the context as it ends —
+ * before any tool calls it triggers — rather than when the assistant starts
+ * to respond.
+ *
+ * The session starts on the first `LLMContextFrame` (typically queued as an
+ * `LLMRunFrame`): the context's leading system message (or
+ * `Settings.systemInstruction`) becomes the model's instructions and the
+ * remaining text messages seed the session as prior conversation.
+ *
+ * Event handlers available:
+ *
+ * - on_session_started: called with the session resource once the session is
+ *   ready for audio.
+ * - on_delegation_created: called with the delegation item when the model
+ *   delegates work.
+ *
+ * @example
+ * const llm = new OpenAILiveLLMService({
+ *   apiKey: process.env.OPENAI_API_KEY!,
+ *   settings: new OpenAILiveLLMService.Settings({ systemInstruction: "..." }),
+ *   delegation: new OpenAILiveLLMService.ResponsesDelegation({
+ *     settings: new OpenAIResponsesLLMService.Settings({ model: "gpt-5.4-mini" }),
+ *   }),
+ * });
+ */
+export declare class OpenAILiveLLMService extends LLMService<OpenAILiveLLMAdapter & BaseLLMAdapter> {
+    static Settings: typeof OpenAILiveLLMSettings;
+    static ResponsesDelegation: typeof ResponsesDelegation;
+    static ClientDelegation: typeof ClientDelegation;
+    protected _settings: OpenAILiveLLMSettings;
+    static adapterClass: typeof OpenAILiveLLMAdapter;
+    apiKey: string;
+    baseUrl: string;
+    protected _sessionModel: string;
+    protected _delegation: ResponsesDelegation | ClientDelegation | null;
+    protected _webSocketFactory: WebsocketConnectOptions["webSocketFactory"];
+    protected _websocket: WebsocketClientConnection | null;
+    protected _receiveTask: Task<unknown> | null;
+    protected _disconnecting: boolean;
+    protected _context: LLMContext | null;
+    protected _needsSessionConfig: boolean;
+    protected _sessionStarted: boolean;
+    protected _sessionClosedEvent: Event;
+    protected _sentToolsSnapshot: string | null;
+    protected _sessionStartedOnConnection: boolean;
+    protected _resampler: import("@pipedog/core/audio/resamplers/base_audio_resampler").BaseAudioResampler;
+    protected _warnedAudioDropped: boolean;
+    protected _userTurn: _TurnGrouper;
+    protected _assistantTurn: _TurnGrouper;
+    protected _openingInstruction: string | null;
+    protected _openFunctionCalls: Map<string, string>;
+    protected _pendingResponses: Map<string, _PendingResponse>;
+    protected _transcriptFragments: {
+        role: string;
+        content: string;
+    }[];
+    protected _delegatedBefore: boolean;
+    protected _backendSession: _BackendSession | null;
+    protected _backendSessionTask: Task<unknown> | null;
+    protected _backendAttached: Event;
+    protected _currentDelegation: _LiveDelegation | null;
+    protected _queuedDelegations: [events.DelegationMetadata, string][];
+    /**
+     * Initialize the OpenAI Live LLM service.
+     *
+     * @param options.apiKey OpenAI project API key.
+     * @param options.baseUrl WebSocket base URL of the Live API.
+     * @param options.settings Runtime-updatable settings. `model`, `voice`,
+     *   `store` and `systemInstruction` are fixed once the session has started.
+     * @param options.delegation Where the model's delegated work runs. `null`
+     *   selects client delegation with no backend configured.
+     *   Other options are passed to the parent LLMService.
+     */
+    constructor(options: OpenAILiveLLMServiceOptions);
+    /**
+     * Check if the service can generate usage metrics.
+     *
+     * @returns True if metrics generation is supported.
+     */
+    canGenerateMetrics(): boolean;
+    /** The Live API takes one output per function call, so intermediate results are dropped. */
+    get acceptsIntermediateFunctionCallResults(): boolean;
+    /**
+     * Decline both roles: this service is a frontend with a backend of its own.
+     *
+     * @param role The role the service is being asked to take.
+     * @returns The reason, naming what to use instead.
+     */
+    llmWithBackendRoleObjection(role: LLMWithBackendRole): string | null;
+    /**
+     * Recommend external turn strategies, resolved from the API's projected turns.
+     *
+     * `isRealtimeService` is left off on purpose: the aggregators' realtime
+     * mode defers the user-message write until the assistant responds, to
+     * absorb late transcripts, and here that would place a delegation's tool
+     * calls ahead of the user message that caused them.
+     */
+    serviceMetadataFrame(): LLMServiceMetadataFrame;
+    /**
+     * Set up the service, register the client-delegation backend, and connect.
+     *
+     * @param setup Configuration object containing setup parameters.
+     */
+    setup(setup: FrameProcessorSetup): Promise<void>;
+    /** Release resources at teardown. */
+    cleanup(): Promise<void>;
+    /**
+     * Close the session gracefully and disconnect.
+     *
+     * @param frame The end frame triggering service shutdown.
+     */
+    stop(frame: EndFrame): Promise<void>;
+    /**
+     * Disconnect immediately.
+     *
+     * @param frame The cancel frame triggering service cancellation.
+     */
+    cancel(frame: CancelFrame): Promise<void>;
+    /**
+     * Apply a settings delta.
+     *
+     * The API fixes the session's settings when it starts, so a change is
+     * stored and reaches the API on the next session (see `resetConversation`).
+     */
+    protected _updateSettings(delta: LLMSettings): Promise<Record<string, unknown>>;
+    /**
+     * Start a new session seeded from the current context.
+     *
+     * The Live API only takes conversation history at session start, so
+     * replacing the context (for example to restore a saved conversation) means
+     * dropping the session and opening a new one configured from the context as
+     * it is now. The old session is abandoned rather than closed gracefully: a
+     * graceful close waits for its in-flight delegations to drain, and their
+     * results belong to the conversation being replaced. Must not be called
+     * from the receive task.
+     */
+    resetConversation(): Promise<void>;
+    /**
+     * Process incoming frames from the pipeline.
+     *
+     * @param frame The frame to process.
+     * @param direction The direction of frame flow in the pipeline.
+     */
+    processFrame(frame: Frame, direction: FrameDirection): Promise<void>;
+    /**
+     * Push a frame, delivering function call outcomes to the API on the way.
+     *
+     * Function call results and cancellations are broadcast by the base
+     * service; the downstream copy is observed here and answered to the backend
+     * model immediately. The frames continue to the assistant aggregator, which
+     * records them in the context.
+     *
+     * @param frame The frame to push.
+     * @param direction The direction of frame pushing.
+     */
+    pushFrame(frame: Frame, direction?: FrameDirection): Promise<void>;
+    /**
+     * Take the context, configuring the session from the first one.
+     *
+     * A later context carries messages the aggregators recorded from this
+     * session's own transcripts, tool results (delivered to the API as they are
+     * produced, see `pushFrame`), or messages the app appended. None of it
+     * reaches the API: user and assistant messages can't be told apart from the
+     * transcript recordings. Newly appended system/developer messages can only
+     * come from the app (the aggregators add user, assistant and tool messages,
+     * and async-tool envelopes that `async_tool_messages.parseMessage`
+     * identifies), so a future diff could forward those as
+     * `session.context.append(channel="developer")` unambiguously.
+     */
+    protected _handleContext(context: LLMContext): Promise<void>;
+    protected _invocationParams(): Promise<OpenAILiveLLMInvocationParams>;
+    /** Send `session.start`, the first message on the socket. */
+    protected _sendSessionConfig(): Promise<void>;
+    protected _delegationConfig(tools: Record<string, unknown>[], toolChoice: unknown): events.ClientDelegationConfig | events.ResponsesDelegationConfig;
+    /** Send a sparse `session.update` when the backend model's tools changed. */
+    protected _maybeSendToolsUpdate(): Promise<void>;
+    protected static _toolsSnapshot(params: OpenAILiveLLMInvocationParams): string;
+    /**
+     * Send a client event to the Live API.
+     *
+     * @param event The client event to send.
+     */
+    sendClientEvent(event: events.ClientEvent): Promise<void>;
+    protected _connect(): Promise<void>;
+    protected _disconnect(): Promise<void>;
+    /** Ask the server to shut down gracefully and wait for `session.closed`. */
+    protected _closeSession(): Promise<void>;
+    protected _wsSend(message: Record<string, unknown>): Promise<void>;
+    protected _receiveTaskHandler(): Promise<void>;
+    protected _handleServerEvent(evt: events.ServerEvent): Promise<void>;
+    protected _handleEvtSessionStarted(evt: events.SessionStartedEvent): Promise<void>;
+    protected _handleEvtSessionClosed(evt: events.SessionClosedEvent): Promise<void>;
+    protected _handleEvtError(evt: events.ErrorEvent): Promise<void>;
+    protected _sendUserAudio(frame: InputAudioRawFrame): Promise<void>;
+    protected _handleEvtAudioDelta(evt: events.OutputAudioDeltaEvent): Promise<void>;
+    protected _handleEvtTranscriptDelta(evt: events.TranscriptDeltaEvent): Promise<void>;
+    protected _restartTurnTimer(role: string, turn: _TurnGrouper): Promise<void>;
+    protected _closeTurnAfterGap(role: string, turn: _TurnGrouper): Promise<void>;
+    /** Close an open turn, if any, emitting its end frames. */
+    protected _closeTurn(role: string): Promise<void>;
+    /** Emit an open turn's end frames, with the turn's lock held. */
+    protected _endTurn(role: string): Promise<void>;
+    /** Close both directions, so response frames stay balanced across sessions. */
+    protected _closeOpenTurns(): Promise<void>;
+    protected _openTurn(role: string): Promise<void>;
+    protected _appendTurn(role: string, delta: string, accumulated: string, evt: events.ServerEvent): Promise<void>;
+    /**
+     * Keep a transcript fragment for the next client delegation.
+     *
+     * Fragments land on frame boundaries, so consecutive ones from the same
+     * speaker are joined back up as they arrive, giving the backend whole
+     * utterances to read. Deltas carry their own leading spaces, so they
+     * concatenate into the original text unaltered.
+     */
+    protected _rememberFragment(role: "user" | "assistant", delta: string): void;
+    /** Take the conversation recorded since the previous delegation. */
+    protected _takeTranscript(): LLMStandardMessage[];
+    protected _pushAssistantText(text: string): Promise<void>;
+    protected _pushInterimTranscription(transcript: string, evt: events.ServerEvent): Promise<void>;
+    protected _handleEvtDelegationCreated(evt: events.SessionDelegationCreatedEvent): Promise<void>;
+    protected _handleClientDelegation(delegation: events.DelegationMetadata): Promise<void>;
+    /** Hold the session with the backend, appending what it produces to the live session. */
+    protected _runBackendSession(): Promise<void>;
+    protected _onBackendEvent(event: BackendOutput | BackendToolCall | BackendIdle | BackendError): Promise<void>;
+    protected _startDelegation(delegation: events.DelegationMetadata, request: string): Promise<void>;
+    /** Close the delegation in progress and start the next one waiting, if any. */
+    protected _finishDelegation(): Promise<void>;
+    protected _delegationTimeout(current: _LiveDelegation, timeoutSecs: number): Promise<void>;
+    /**
+     * Drop the delegation in progress and the ones waiting: the session they belong to is over.
+     *
+     * The backend is detached, which stops its work; the next connection
+     * attaches again.
+     */
+    protected _abandonDelegations(): Promise<void>;
+    /** Open the session with the backend, when client delegation is configured and none is open. */
+    protected _attachBackend(): Promise<void>;
+    /** Close the session with the backend, which stops its work. */
+    protected _detachBackend(): Promise<void>;
+    /**
+     * Append text to the live session, for it to speak or to keep to itself.
+     *
+     * The API's two channels are named for what the live model does with the
+     * text: commentary is paraphrased aloud, thinking joins its private
+     * reasoning. That vantage is the model's own, which is why what arrives
+     * from a backend is flagged `prefersSpoken` instead — ordinary prose can go
+     * unspoken without being anything like a thought.
+     */
+    protected _sendContextAppend(delegationId: string | null, text: string, options: {
+        spoken: boolean;
+    }): Promise<void>;
+    /** Dispatch a wrapped Responses lifecycle event by its own type. */
+    protected _handleEvtResponse(evt: events.ResponseEventEnvelope): Promise<void>;
+    /**
+     * Remember a delegated response so its function calls can be collected.
+     *
+     * @returns The response's correlation key.
+     */
+    protected _trackResponse(evt: events.ResponseEventEnvelope): string;
+    protected _handleResponseOutputItemDone(evt: events.ResponseEventEnvelope): Promise<void>;
+    /**
+     * Note that a response emitted all of its output items.
+     *
+     * The lifecycle snapshot's `output` is empty even here, so the calls
+     * collected from the individual item events are what has to be answered.
+     */
+    protected _handleResponseFinished(evt: events.ResponseEventEnvelope): Promise<void>;
+    /** Continue a response once every function call it made has been answered. */
+    protected _maybeContinueResponse(key: string): Promise<void>;
+    protected _handleFunctionCallResult(frame: FunctionCallResultFrame): Promise<void>;
+    protected _handleFunctionCallCancel(frame: FunctionCallCancelFrame): Promise<void>;
+    /** Queue one function result, and continue the response once all are in. */
+    protected _sendFunctionCallOutput(callId: string, output: string): Promise<void>;
+    /**
+     * Log the session's cumulative live audio duration.
+     *
+     * The live model's usage is reported as seconds rather than tokens. Token
+     * metrics come from the backend model instead, on the nested Responses
+     * completion events.
+     */
+    protected _reportUsage(usage: events.Usage): Promise<void>;
+    /** Report the backend model's token usage from a completed delegated response. */
+    protected _reportBackendUsage(response: Record<string, unknown>): Promise<void>;
+}
+/** Return the text of a trailing developer message, if the history ends with one. */
+export declare function _trailingDeveloperText(items: readonly events.InputItem[]): string | null;
+/**
+ * Build `delegation.responses` from the nested Responses settings.
+ *
+ * Mirrors how `OpenAIResponsesLLMService` builds a request from the same
+ * settings, minus what the Live API owns for a delegated model.
+ */
+export declare function _responsesDelegationConfig(delegation: ResponsesDelegation): Record<string, unknown>;
+/**
+ * Estimate how many tokens a piece of text costs.
+ *
+ * A byte-pair encoding packs about four characters of ASCII into a token.
+ * Other scripts cost more per character — CJK runs close to one token each —
+ * so anything outside ASCII is counted whole.
+ */
+export declare function _estimatedTokens(text: string): number;
+/** Return a text's cost in quarter-tokens: one for an ASCII character, four for any other. */
+export declare function _tokenQuarters(text: string): number;
+/**
+ * Split off the longest prefix of `text` that fits `tokenLimit`.
+ *
+ * The cut lands on the last space within the limit, so words stay whole.
+ */
+export declare function _splitAtTokenLimit(text: string, tokenLimit: number): [string, string];
+/**
+ * Split text into chunks of at most `tokenLimit` estimated tokens.
+ *
+ * Chunks break on sentence boundaries; a sentence longer than the limit is
+ * split at a space.
+ */
+export declare function _chunkText(text: string, tokenLimit: number): string[];
+//# sourceMappingURL=llm.d.ts.map