qlogicagent 2.13.5 → 2.13.6

package/dist/cli/tunable-store.js

@@ -1,105 +0,0 @@
-/**
- * Tunable override store — the SINGLE write/read path for settings.tunables.
- *
- * Shared by the config.updateTunable RPC (UI settings page) and the `config`
- * tool (conversational tuning), so both go through identical validation,
- * persistence, and runtime sync. Values are hot: ModelRegistry.getTunable()
- * re-reads settings.json on every call, so a persisted override takes effect
- * on the next read with no restart.
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { runtimeVars } from "../agent/runtime-vars.js";
-import { getTunableDefaults } from "../runtime/config/tunable-defaults.js";
-/** Read the current override map from settings.json (missing file → empty). */
-export function readTunableOverrides(settingsPath) {
-    try {
-        const parsed = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
-        return parsed.tunables && typeof parsed.tunables === "object"
-            ? parsed.tunables
-            : {};
-    }
-    catch {
-        return {};
-    }
-}
-/**
- * Validate a tunable update against the declared defaults.
- * Returns an error message, or null when the update is acceptable.
- * Coercible values ("3" → 3, "true" → true) are NOT accepted here —
- * callers wanting leniency must coerce before validating.
- */
-export function validateTunableUpdate(key, value) {
-    const defaults = getTunableDefaults();
-    if (!(key in defaults)) {
-        return `Unknown tunable key: "${key}". Valid keys: ${Object.keys(defaults).join(", ")}`;
-    }
-    const expectedType = typeof defaults[key];
-    if (value === undefined || value === null || typeof value !== expectedType) {
-        return `Invalid value for "${key}": expected ${expectedType}, got ${typeof value}`;
-    }
-    return null;
-}
-/** Coerce a string value toward the tunable's declared type ("3"→3, "true"→true). */
-export function coerceTunableValue(key, value) {
-    if (typeof value !== "string")
-        return value;
-    const defaults = getTunableDefaults();
-    if (!(key in defaults))
-        return value;
-    const expectedType = typeof defaults[key];
-    if (expectedType === "number") {
-        const n = Number(value);
-        if (!Number.isNaN(n) && value.trim() !== "")
-            return n;
-    }
-    else if (expectedType === "boolean") {
-        if (value === "true")
-            return true;
-        if (value === "false")
-            return false;
-    }
-    return value;
-}
-/** Persist one override into settings.json and sync live runtime state. */
-export async function writeTunableOverride(settingsPath, key, value) {
-    let config = {};
-    try {
-        config = JSON.parse(await fs.promises.readFile(settingsPath, "utf-8"));
-    }
-    catch { /* start fresh */ }
-    if (!config.tunables || typeof config.tunables !== "object") {
-        config.tunables = {};
-    }
-    config.tunables[key] = value;
-    await fs.promises.mkdir(path.dirname(settingsPath), { recursive: true });
-    await fs.promises.writeFile(settingsPath, JSON.stringify(config, null, 2), "utf-8");
-    applyTunableRuntimeSync(key, value);
-}
-/** Remove one override (value falls back to the declared default). */
-export async function clearTunableOverride(settingsPath, key) {
-    let config = {};
-    try {
-        config = JSON.parse(await fs.promises.readFile(settingsPath, "utf-8"));
-    }
-    catch {
-        return; // no file → nothing to clear
-    }
-    if (config.tunables && typeof config.tunables === "object") {
-        delete config.tunables[key];
-        await fs.promises.writeFile(settingsPath, JSON.stringify(config, null, 2), "utf-8");
-    }
-    const defaults = getTunableDefaults();
-    if (key in defaults)
-        applyTunableRuntimeSync(key, defaults[key]);
-}
-/**
- * Sync live in-process state for tunables that are read once instead of
- * per-use. Most tunables are hot via getTunable() re-reads; the ones below
- * are cached in runtimeVars and must be pushed.
- */
-function applyTunableRuntimeSync(key, value) {
-    if (key === "teamBudgetTokens" && typeof value === "number") {
-        runtimeVars.teamBudget.budgetTokens = value;
-    }
-}

package/dist/cli/turn-ask-user-setup.d.ts

@@ -1,24 +0,0 @@
-import type { AskUserQuestion } from "../skills/tools/ask-user-tool.js";
-interface PendingAskUserRequest {
-    resolve(answers: Record<string, string> | null): void;
-}
-export interface TurnAskUserSetupHost {
-    pendingAskUser: Map<string, PendingAskUserRequest>;
-    sendNotification(method: string, params: Record<string, unknown>): void;
-}
-/**
- * Build the ask_user backend closure: mint a requestId, park its resolver in
- * `host.pendingAskUser`, and emit `turn.ask_user`. The answer is delivered later via
- * `thread.user_response` (handleUserResponse), which resolves the same map entry by requestId.
- *
- * Shared by the turn pipeline (configureTurnAskUser) and the Solo Spec phase
- * (handleAcpSoloSpecChat) so both drive the SAME UI channel. requestId isolation (full UUID) lets a
- * concurrent chat-turn ask and a spec-phase ask coexist in the one shared map without collision.
- *
- * The optional `signal` makes an unanswered ask abortable + self-cleaning: on abort we drop the
- * parked resolver from the map and resolve to null (caller degrades to a best-effort result), so a
- * cancelled/abandoned turn can't leak a map entry or hang the awaiting fork forever.
- */
-export declare function makeAskUserBackend(host: TurnAskUserSetupHost): (questions: AskUserQuestion[], signal?: AbortSignal) => Promise<Record<string, string> | null>;
-export declare function configureTurnAskUser(host: TurnAskUserSetupHost): void;
-export {};

package/dist/cli/turn-ask-user-setup.js

@@ -1,46 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { setAskUserCallback } from "./tool-bootstrap.js";
-/**
- * Build the ask_user backend closure: mint a requestId, park its resolver in
- * `host.pendingAskUser`, and emit `turn.ask_user`. The answer is delivered later via
- * `thread.user_response` (handleUserResponse), which resolves the same map entry by requestId.
- *
- * Shared by the turn pipeline (configureTurnAskUser) and the Solo Spec phase
- * (handleAcpSoloSpecChat) so both drive the SAME UI channel. requestId isolation (full UUID) lets a
- * concurrent chat-turn ask and a spec-phase ask coexist in the one shared map without collision.
- *
- * The optional `signal` makes an unanswered ask abortable + self-cleaning: on abort we drop the
- * parked resolver from the map and resolve to null (caller degrades to a best-effort result), so a
- * cancelled/abandoned turn can't leak a map entry or hang the awaiting fork forever.
- */
-export function makeAskUserBackend(host) {
-    return (questions, signal) => {
-        const requestId = `ask-${randomUUID()}`;
-        return new Promise((resolve) => {
-            if (signal?.aborted) {
-                resolve(null);
-                return;
-            }
-            const settle = (answers) => {
-                host.pendingAskUser.delete(requestId);
-                signal?.removeEventListener("abort", onAbort);
-                resolve(answers);
-            };
-            const onAbort = () => settle(null);
-            host.pendingAskUser.set(requestId, { resolve: settle });
-            signal?.addEventListener("abort", onAbort, { once: true });
-            host.sendNotification("turn.ask_user", {
-                requestId,
-                questions: questions.map(q => ({
-                    header: q.header,
-                    question: q.question,
-                    options: q.options,
-                    multiSelect: q.multiSelect,
-                })),
-            });
-        });
-    };
-}
-export function configureTurnAskUser(host) {
-    setAskUserCallback(makeAskUserBackend(host));
-}

package/dist/cli/turn-ask-user-setup.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/cli/turn-ask-user-setup.test.js

@@ -1,39 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { makeAskUserBackend } from "./turn-ask-user-setup.js";
-describe("makeAskUserBackend", () => {
-    it("emits turn.ask_user with a requestId + mapped questions, parks the resolver, and resolves on response", async () => {
-        const notifications = [];
-        const host = {
-            pendingAskUser: new Map(),
-            sendNotification: (method, params) => notifications.push({ method, params }),
-        };
-        const ask = makeAskUserBackend(host);
-        const questions = [
-            { question: "Which DB?", header: "DB", options: [{ label: "sqlite" }], multiSelect: false },
-        ];
-        const pending = ask(questions);
-        // Notification went out on the shared turn.ask_user channel.
-        expect(notifications).toHaveLength(1);
-        expect(notifications[0].method).toBe("turn.ask_user");
-        const sent = notifications[0].params;
-        expect(typeof sent.requestId).toBe("string");
-        expect(sent.questions).toEqual([
-            { header: "DB", question: "Which DB?", options: [{ label: "sqlite" }], multiSelect: false },
-        ]);
-        // Resolver is parked under the same requestId (this is what thread.user_response looks up).
-        expect(host.pendingAskUser.has(sent.requestId)).toBe(true);
-        host.pendingAskUser.get(sent.requestId).resolve({ "Which DB?": "sqlite" });
-        await expect(pending).resolves.toEqual({ "Which DB?": "sqlite" });
-    });
-    it("propagates a null (declined) response", async () => {
-        const host = {
-            pendingAskUser: new Map(),
-            sendNotification: () => { },
-        };
-        const ask = makeAskUserBackend(host);
-        const pending = ask([{ question: "Q?", header: "Q" }]);
-        const [requestId] = [...host.pendingAskUser.keys()];
-        host.pendingAskUser.get(requestId).resolve(null);
-        await expect(pending).resolves.toBeNull();
-    });
-});

package/dist/cli/turn-core.d.ts

@@ -1,57 +0,0 @@
-/**
- * Shared turn-execution core for the turn pipeline (`runTurnPipeline` -> `executeTurnCore`).
- * Owns the `agent.run()` event loop: side-event forwarding (`forwardTurnSideEvent`), the
- * `turn.start`/`turn.end`/`turn.error` notification skeleton, and content/usage collection.
- * Path-specific behaviour (transcript persistence, usage tracking, literal-response
- * transforms, skill auto-persist) is supplied via optional hooks.
- */
-import type { ChatMessage, TokenUsage, ToolDefinition, TurnConfig, TurnEvent } from "../agent/types.js";
-import { type TurnEventForwardHost } from "./turn-event-forwarder.js";
-export interface TurnCoreRequest {
-    turnId: string;
-    sessionId: string;
-    messages: ChatMessage[];
-    tools: ToolDefinition[];
-    systemPrompt: string;
-    config: TurnConfig;
-}
-export interface TurnCoreAgent {
-    run(request: TurnCoreRequest, signal?: AbortSignal): AsyncIterable<TurnEvent>;
-}
-export interface TurnCoreHooks {
-    /** Invoked for every side event handled by `forwardTurnSideEvent` (e.g. tool-call accounting). */
-    onSideEvent?: (event: TurnEvent) => void;
-    /** Transform assistant content before it is emitted in `turn.end` (e.g. literal-response requirements). */
-    transformContent?: (content: string) => string;
-    /** Extra work after `turn.end` is emitted (usage tracking, `turn.usage_update`, transcript persistence). */
-    onEnd?: (event: Extract<TurnEvent, {
-        type: "end";
-    }>, finalContent: string) => void;
-    /** Extra work after `turn.error` is emitted (e.g. usage tracking on the error path). */
-    onError?: (event: Extract<TurnEvent, {
-        type: "error";
-    }>) => void;
-    /** Handle a `skill_instruction` event (notify + auto-persist). */
-    onSkillInstruction?: (event: Extract<TurnEvent, {
-        type: "skill_instruction";
-    }>) => void;
-}
-export interface TurnCoreResult {
-    content: string;
-    usage?: TokenUsage;
-    /** Captured mid-turn error event, surfaced in-band by callers (e.g. ACP session/prompt). */
-    error?: {
-        message: string;
-        code?: string;
-        recoverable?: boolean;
-    };
-    /** Resolved model/provider that actually ran the turn (for the caller's turn.end). */
-    model?: string;
-    provider?: string;
-}
-/**
- * Drive a single agent turn to completion, emitting the shared notification stream.
- * The caller is responsible for emitting `turn.start` (for the early-lifecycle
- * contract) before invoking this, and for all pre/post-turn pipeline work.
- */
-export declare function executeTurnCore(host: TurnEventForwardHost, agent: TurnCoreAgent, request: TurnCoreRequest, signal: AbortSignal, hooks?: TurnCoreHooks): Promise<TurnCoreResult>;

package/dist/cli/turn-core.js

@@ -1,58 +0,0 @@
-import { forwardTurnSideEvent } from "./turn-event-forwarder.js";
-/**
- * Drive a single agent turn to completion, emitting the shared notification stream.
- * The caller is responsible for emitting `turn.start` (for the early-lifecycle
- * contract) before invoking this, and for all pre/post-turn pipeline work.
- */
-export async function executeTurnCore(host, agent, request, signal, hooks = {}) {
-    const { turnId } = request;
-    let content = "";
-    let usage;
-    let error;
-    let model;
-    let provider;
-    for await (const event of agent.run(request, signal)) {
-        const now = new Date().toISOString();
-        if (forwardTurnSideEvent({ event, turnId, now, host })) {
-            hooks.onSideEvent?.(event);
-            continue;
-        }
-        switch (event.type) {
-            case "start":
-                // `turn.start` is emitted by the caller before the loop; agent.run() also
-                // yields a start event for internal bookkeeping — skip the duplicate.
-                break;
-            case "end": {
-                const finalContent = hooks.transformContent
-                    ? hooks.transformContent(event.content)
-                    : (event.content ?? "");
-                host.sendNotification("turn.end", {
-                    turnId: event.turnId,
-                    content: finalContent,
-                    usage: event.usage,
-                    model: event.model,
-                    provider: event.provider,
-                    item: { id: `${turnId}-end`, type: "message", role: "assistant", text: finalContent, createdAt: now },
-                });
-                content = finalContent;
-                usage = event.usage;
-                model = event.model;
-                provider = event.provider;
-                hooks.onEnd?.(event, finalContent);
-                break;
-            }
-            case "error":
-                host.sendNotification("turn.error", {
-                    turnId: event.turnId,
-                    error: { message: event.error, code: event.code },
-                });
-                error = { message: event.error, code: event.code };
-                hooks.onError?.(event);
-                break;
-            case "skill_instruction":
-                hooks.onSkillInstruction?.(event);
-                break;
-        }
-    }
-    return { content, usage, error, model, provider };
-}

package/dist/cli/turn-event-forwarder.d.ts

@@ -1,10 +0,0 @@
-import type { TurnEvent } from "../agent/types.js";
-export interface TurnEventForwardHost {
-    sendNotification(method: string, params: unknown): void;
-}
-export declare function forwardTurnSideEvent(params: {
-    event: TurnEvent;
-    turnId: string;
-    now: string;
-    host: TurnEventForwardHost;
-}): boolean;

package/dist/cli/turn-event-forwarder.js

@@ -1,136 +0,0 @@
-import { randomUUID } from "node:crypto";
-export function forwardTurnSideEvent(params) {
-    const { event, turnId, now, host } = params;
-    switch (event.type) {
-        case "delta":
-            host.sendNotification("turn.delta", {
-                turnId: event.turnId,
-                text: event.text,
-                item: { id: `${turnId}-delta`, type: "message", role: "assistant", text: event.text, createdAt: now },
-            });
-            return true;
-        case "tool_call":
-            host.sendNotification("turn.tool_call", {
-                turnId: event.turnId,
-                callId: event.callId,
-                name: event.name,
-                arguments: event.arguments,
-                ...(event.inputSummary ? { inputSummary: event.inputSummary } : {}),
-                item: { id: event.callId, type: "tool_call", role: "assistant", toolName: event.name, toolCallId: event.callId, arguments: event.arguments, createdAt: now },
-            });
-            return true;
-        case "tool_result":
-            host.sendNotification("turn.tool_result", {
-                turnId: event.turnId,
-                callId: event.callId,
-                name: event.name,
-                ok: event.ok,
-                ...(event.error ? { error: event.error } : {}),
-                ...(event.outputPreview ? { outputPreview: event.outputPreview } : {}),
-                ...(event.durationMs !== undefined ? { durationMs: event.durationMs } : {}),
-                ...(event.exitCode !== undefined ? { exitCode: event.exitCode } : {}),
-                ...(event.stdout ? { stdout: event.stdout } : {}),
-                ...(event.stderr ? { stderr: event.stderr } : {}),
-                ...(event.details ? { details: event.details } : {}),
-                item: { id: `${event.callId}-result`, type: "tool_result", role: "assistant", toolName: event.name, toolCallId: event.callId, output: event.ok ? (event.outputPreview ?? "") : event.error, approved: event.ok, createdAt: now },
-            });
-            return true;
-        case "tool_blocked":
-            host.sendNotification("turn.tool_blocked", {
-                turnId: event.turnId,
-                callId: event.callId,
-                name: event.name,
-                reason: event.reason,
-                item: { id: `${event.callId}-blocked`, type: "tool_blocked", role: "system", toolName: event.name, toolCallId: event.callId, text: event.reason, approved: false, createdAt: now },
-            });
-            return true;
-        case "recovery":
-            host.sendNotification("turn.recovery", {
-                turnId: event.turnId,
-                action: event.action,
-                ...(event.detail ? { detail: event.detail } : {}),
-                item: { id: `${turnId}-recovery-${randomUUID().slice(0, 8)}`, type: "recovery", role: "system", strategy: event.action, text: event.detail, createdAt: now },
-            });
-            return true;
-        case "plan_update":
-            host.sendNotification("turn.plan_update", {
-                turnId: event.turnId,
-                slug: event.slug,
-                content: event.content,
-                item: { id: `${turnId}-plan-${randomUUID().slice(0, 8)}`, type: "plan_update", role: "assistant", text: event.content, createdAt: now },
-            });
-            return true;
-        case "reasoning_delta":
-            host.sendNotification("turn.reasoning_delta", {
-                turnId: event.turnId,
-                text: event.text,
-            });
-            return true;
-        case "suggestions":
-            host.sendNotification("turn.suggestions", {
-                turnId: event.turnId,
-                items: event.items,
-            });
-            return true;
-        case "media_result":
-            host.sendNotification("turn.media_result", {
-                turnId: event.turnId,
-                mediaType: event.mediaType,
-                url: event.url,
-                ...(event.model ? { model: event.model } : {}),
-                ...(event.provider ? { provider: event.provider } : {}),
-                ...(event.taskId ? { taskId: event.taskId } : {}),
-            });
-            return true;
-        case "artifact":
-            host.sendNotification("turn.artifact", {
-                turnId: event.turnId,
-                artifactId: event.artifactId,
-                type: event.artifactType,
-                title: event.title,
-                ...(event.filePath ? { filePath: event.filePath } : {}),
-                ...(event.language ? { language: event.language } : {}),
-                ...(event.content ? { content: event.content } : {}),
-                ...(event.mimeType ? { mimeType: event.mimeType } : {}),
-            });
-            return true;
-        case "subagent_started":
-            host.sendNotification("turn.subagent_started", {
-                turnId: event.turnId,
-                subagentId: event.subagentId,
-                agentType: event.agentType,
-                ...(event.prompt ? { prompt: event.prompt } : {}),
-            });
-            return true;
-        case "subagent_ended":
-            host.sendNotification("turn.subagent_ended", {
-                turnId: event.turnId,
-                subagentId: event.subagentId,
-                agentType: event.agentType,
-                ok: event.ok,
-                ...(event.outputPreview ? { outputPreview: event.outputPreview } : {}),
-                ...(event.error ? { error: event.error } : {}),
-            });
-            return true;
-        case "annotations":
-            host.sendNotification("turn.annotations", {
-                turnId: event.turnId,
-                annotations: event.annotations,
-            });
-            return true;
-        case "heartbeat":
-            host.sendNotification("turn.heartbeat", {
-                turnId: event.turnId,
-                message: event.message,
-            });
-            return true;
-        case "tool_use_summary":
-            host.sendNotification("turn.tool_use_summary", {
-                turnId: event.turnId,
-                summary: event.summary,
-            });
-            return true;
-        default:
-            return false;
-    }
-}

package/dist/cli/turn-lifecycle.d.ts

@@ -1,19 +0,0 @@
-import type { HookRegistry } from "../contracts/hooks.js";
-import { type MemoryPrefetchState } from "../runtime/hooks/memory-hooks.js";
-import { SessionState } from "../runtime/session/session-state.js";
-export interface TurnLifecycleHost {
-    activeTurn: AbortController | null;
-    turnDone: Promise<void>;
-    currentSessionId: string;
-    currentHooks: HookRegistry | null;
-    sessionState: SessionState | null;
-    sessionTaskDomain: unknown;
-    memoryPrefetchState: MemoryPrefetchState;
-    enableIdleDream(): void;
-}
-export interface PreparedTurnLifecycle {
-    abortController: AbortController;
-    resolveTurnDone(): void;
-}
-export declare function prepareTurnLifecycle(host: TurnLifecycleHost, sessionId: string): Promise<PreparedTurnLifecycle>;
-export declare function finishTurnLifecycle(host: TurnLifecycleHost, lifecycle: PreparedTurnLifecycle): void;

package/dist/cli/turn-lifecycle.js

@@ -1,53 +0,0 @@
-import { createMemoryPrefetchState } from "../runtime/hooks/memory-hooks.js";
-import { clearSystemPromptSections } from "../runtime/prompt/system-prompt-sections.js";
-import { SessionState } from "../runtime/session/session-state.js";
-const SUPERSEDED_TURN_WAIT_MS = 250;
-export async function prepareTurnLifecycle(host, sessionId) {
-    const abortController = new AbortController();
-    if (host.activeTurn) {
-        host.activeTurn.abort();
-        await waitForPreviousTurn(host.turnDone);
-    }
-    host.activeTurn = abortController;
-    let resolveTurnDone;
-    host.turnDone = new Promise((resolve) => {
-        resolveTurnDone = resolve;
-    });
-    if (sessionId && sessionId !== host.currentSessionId) {
-        if (host.currentSessionId && host.currentHooks) {
-            host.currentHooks.invoke("session.ended", { sessionId: host.currentSessionId }).catch(() => { });
-            clearSystemPromptSections();
-        }
-        host.currentSessionId = sessionId;
-        host.sessionState = new SessionState(sessionId);
-        host.sessionTaskDomain = undefined;
-        host.memoryPrefetchState = createMemoryPrefetchState();
-        host.enableIdleDream();
-    }
-    return {
-        abortController,
-        resolveTurnDone,
-    };
-}
-async function waitForPreviousTurn(done) {
-    let timer;
-    try {
-        await Promise.race([
-            done,
-            new Promise((resolve) => {
-                timer = setTimeout(resolve, SUPERSEDED_TURN_WAIT_MS);
-                timer.unref?.();
-            }),
-        ]);
-    }
-    finally {
-        if (timer)
-            clearTimeout(timer);
-    }
-}
-export function finishTurnLifecycle(host, lifecycle) {
-    if (host.activeTurn === lifecycle.abortController) {
-        host.activeTurn = null;
-    }
-    lifecycle.resolveTurnDone();
-}

package/dist/cli/turn-lifecycle.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/cli/turn-lifecycle.test.js

@@ -1,32 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createMemoryPrefetchState } from "../runtime/hooks/memory-hooks.js";
-import { prepareTurnLifecycle, finishTurnLifecycle } from "./turn-lifecycle.js";
-function createHost(overrides = {}) {
-    return {
-        activeTurn: null,
-        turnDone: Promise.resolve(),
-        currentSessionId: "session-1",
-        currentHooks: null,
-        sessionState: null,
-        sessionTaskDomain: undefined,
-        memoryPrefetchState: createMemoryPrefetchState(),
-        enableIdleDream() { },
-        ...overrides,
-    };
-}
-describe("turn lifecycle", () => {
-    it("does not wait forever when a superseded turn ignores abort", async () => {
-        const previous = new AbortController();
-        const host = createHost({
-            activeTurn: previous,
-            turnDone: new Promise(() => { }),
-        });
-        const startedAt = Date.now();
-        const lifecycle = await prepareTurnLifecycle(host, "session-1");
-        expect(previous.signal.aborted).toBe(true);
-        expect(Date.now() - startedAt).toBeLessThan(1000);
-        expect(host.activeTurn).toBe(lifecycle.abortController);
-        finishTurnLifecycle(host, lifecycle);
-        expect(host.activeTurn).toBeNull();
-    });
-});

package/dist/cli/turn-media-setup.d.ts

@@ -1,19 +0,0 @@
-import type { TurnConfig } from "../agent/types.js";
-import { type ModelRegistry } from "../runtime/infra/model-registry.js";
-import { type MediaClient } from "./provider-core-facade.js";
-interface MediaUsageRecorder {
-    addMediaUsage(model: string, billingUnit: string, quantity: number): void;
-}
-export interface TurnMediaSetupHost {
-    mediaClient: MediaClient;
-    currentMediaApiKeys: Record<string, string> | null;
-    sessionState?: MediaUsageRecorder | null;
-    sendNotification(method: string, params: Record<string, unknown>): void;
-}
-export declare function deriveMediaProvidersFromBindings(registry: Pick<ModelRegistry, "getBinding">): TurnConfig["mediaProviders"];
-export declare function configureTurnMedia(params: {
-    host: TurnMediaSetupHost;
-    config?: Record<string, unknown>;
-    turnId: string;
-}): void;
-export {};