qlogicagent 2.13.3 → 2.13.5

package/dist/cli/tunable-store.js

@@ -0,0 +1,105 @@
+/**
+ * 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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,46 @@
+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

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

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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,57 @@
+/**
+ * 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

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,136 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,53 @@
+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

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

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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,19 @@
+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 {};