qlogicagent 2.13.3 → 2.13.5

package/dist/cli/idle-dream-coordinator.d.ts

@@ -0,0 +1,47 @@
+import { type DreamState } from "../agent/runtime-vars.js";
+import type { AgentRpcRequest } from "../protocol/wire/index.js";
+type TimerHandle = {
+    unref?: () => void;
+};
+export interface IdleDreamTimers {
+    setTimeout(callback: () => void, delayMs: number): TimerHandle;
+    clearTimeout(timerId: TimerHandle): void;
+}
+export interface IdleDreamClient {
+    model: string;
+    apiKey: string;
+}
+export interface IdleDreamCoordinatorOptions {
+    dreamState?: DreamState;
+    now?: () => number;
+    randomId?: () => string;
+    timers?: IdleDreamTimers;
+    log(message: string): void;
+    sendNotification(method: string, params: Record<string, unknown>): void;
+    getCurrentSessionId(): string;
+    getCurrentTurnCount(): number;
+    getActiveTurn(): AbortController | null;
+    resolveDreamClient(): IdleDreamClient | null;
+    resolveMemoryRoot(): string;
+    resolveTranscriptDir(): string;
+    listRecentSessions(): Promise<Array<{
+        sessionId: string;
+    }>>;
+    runDream(message: AgentRpcRequest): Promise<void>;
+}
+export declare class IdleDreamCoordinator {
+    private readonly options;
+    private readonly dreamState;
+    private readonly now;
+    private readonly randomId;
+    private readonly timers;
+    private idleTimer;
+    constructor(options: IdleDreamCoordinatorOptions);
+    applyEnvOverrides(env: Record<string, string | undefined>): void;
+    enable(minutes?: number): void;
+    handleTurnNotification(method: string): void;
+    cancelTimer(): void;
+    resetTimer(): void;
+    triggerIdleDream(): Promise<void>;
+}
+export {};

package/dist/cli/idle-dream-coordinator.js

@@ -0,0 +1,126 @@
+import { randomUUID } from "node:crypto";
+import { runtimeVars } from "../agent/runtime-vars.js";
+const DEFAULT_TIMERS = {
+    setTimeout: (callback, delayMs) => setTimeout(callback, delayMs),
+    clearTimeout: (timerId) => clearTimeout(timerId),
+};
+export class IdleDreamCoordinator {
+    options;
+    dreamState;
+    now;
+    randomId;
+    timers;
+    idleTimer = null;
+    constructor(options) {
+        this.options = options;
+        this.dreamState = options.dreamState ?? runtimeVars.dream;
+        this.now = options.now ?? (() => Date.now());
+        this.randomId = options.randomId ?? (() => randomUUID().slice(0, 8));
+        this.timers = options.timers ?? DEFAULT_TIMERS;
+    }
+    applyEnvOverrides(env) {
+        const envIdleMs = Number(env.QLOGICAGENT_IDLE_DREAM_MS);
+        if (envIdleMs > 0)
+            this.dreamState.idleMinutes = envIdleMs / 60_000;
+        const envCooldown = Number(env.QLOGICAGENT_DREAM_COOLDOWN_MS);
+        if (envCooldown >= 0)
+            this.dreamState.cooldownMs = envCooldown;
+    }
+    enable(minutes) {
+        this.dreamState.enabled = true;
+        if (minutes && minutes > 0)
+            this.dreamState.idleMinutes = minutes;
+        this.resetTimer();
+    }
+    handleTurnNotification(method) {
+        if (method === "turn.end")
+            this.resetTimer();
+        if (method === "turn.start")
+            this.cancelTimer();
+    }
+    cancelTimer() {
+        if (!this.idleTimer)
+            return;
+        this.timers.clearTimeout(this.idleTimer);
+        this.idleTimer = null;
+    }
+    resetTimer() {
+        this.cancelTimer();
+        if (!this.dreamState.enabled)
+            return;
+        if (!this.options.getCurrentSessionId())
+            return;
+        this.idleTimer = this.timers.setTimeout(() => {
+            void this.triggerIdleDream();
+        }, this.dreamState.idleMinutes * 60_000);
+        this.idleTimer.unref?.();
+    }
+    async triggerIdleDream() {
+        if (this.now() - this.dreamState.lastDreamAt < this.dreamState.cooldownMs) {
+            this.options.log("[dream:idle] Skipped - cooldown not elapsed");
+            return;
+        }
+        const dreamClient = this.options.resolveDreamClient();
+        if (!dreamClient) {
+            this.options.log("[dream:idle] Skipped - no LLM transport configured");
+            return;
+        }
+        if (this.options.getActiveTurn()) {
+            this.options.log("[dream:idle] Skipped - turn in progress");
+            return;
+        }
+        this.options.log("[dream:idle] Triggering idle dream consolidation");
+        this.dreamState.lastDreamAt = this.now();
+        this.options.sendNotification("system.activity", {
+            category: "dream",
+            level: "info",
+            title: "空闲梦境整理触发",
+            detail: `空闲 ${this.dreamState.idleMinutes} 分钟后自动触发`,
+        });
+        const durationTimeout = this.timers.setTimeout(() => {
+            const activeTurn = this.options.getActiveTurn();
+            if (activeTurn) {
+                this.options.log("[dream:idle] Aborting - max duration reached");
+                activeTurn.abort();
+            }
+        }, this.dreamState.maxDurationMs);
+        durationTimeout.unref?.();
+        const memoryRoot = this.options.resolveMemoryRoot();
+        const transcriptDir = this.options.resolveTranscriptDir();
+        const currentSessionId = this.options.getCurrentSessionId();
+        let recentSessionIds = [];
+        try {
+            const sessions = await this.options.listRecentSessions();
+            recentSessionIds = sessions
+                .filter(session => session.sessionId !== currentSessionId)
+                .map(session => session.sessionId);
+        }
+        catch {
+            // Non-fatal: empty list means the dream gate will not pass naturally.
+        }
+        const syntheticMsg = {
+            jsonrpc: "2.0",
+            method: "memory.dream",
+            params: {
+                turnId: `idle-dream-${this.randomId()}`,
+                sessionId: currentSessionId,
+                config: {
+                    memoryRoot,
+                    transcriptDir,
+                    dreamSessionIds: recentSessionIds,
+                    currentSessionTurnCount: this.options.getCurrentTurnCount(),
+                    model: dreamClient.model,
+                    apiKey: dreamClient.apiKey,
+                    force: false,
+                },
+            },
+        };
+        try {
+            await this.options.runDream(syntheticMsg);
+        }
+        finally {
+            this.timers.clearTimeout(durationTimeout);
+        }
+        this.resetTimer();
+    }
+}

package/dist/cli/idle-dream-coordinator.test.d.ts

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

package/dist/cli/idle-dream-coordinator.test.js

@@ -0,0 +1,125 @@
+import { describe, expect, it, vi } from "vitest";
+import { IdleDreamCoordinator } from "./idle-dream-coordinator.js";
+function createHarness(overrides = {}) {
+    const dreamState = {
+        enabled: false,
+        idleMinutes: 0.001,
+        lastDreamAt: 0,
+        cooldownMs: 1000,
+        maxDurationMs: 5000,
+        ...overrides,
+    };
+    const timers = [];
+    const cleared = [];
+    let nowMs = 10_000;
+    let currentSessionId = "session-current";
+    let activeTurn = null;
+    const notifications = [];
+    const dreamRequests = [];
+    const logs = [];
+    const coordinator = new IdleDreamCoordinator({
+        dreamState,
+        now: () => nowMs,
+        randomId: () => "dream1234",
+        timers: {
+            setTimeout(callback, delayMs) {
+                const handle = { callback, delayMs, unref: vi.fn() };
+                timers.push(handle);
+                return handle;
+            },
+            clearTimeout(timerId) {
+                cleared.push(timerId);
+            },
+        },
+        log: (message) => logs.push(message),
+        sendNotification: (method, params) => notifications.push({ method, params }),
+        getCurrentSessionId: () => currentSessionId,
+        getCurrentTurnCount: () => 7,
+        getActiveTurn: () => activeTurn,
+        resolveDreamClient: () => ({ model: "model-a", apiKey: "key-a" }),
+        resolveMemoryRoot: () => "C:/workspace/.qlogicagent/memory",
+        resolveTranscriptDir: () => "C:/workspace/.qlogicagent/sessions",
+        listRecentSessions: async () => [
+            { sessionId: "session-old" },
+            { sessionId: "session-current" },
+        ],
+        runDream: async (message) => {
+            dreamRequests.push(message);
+        },
+    });
+    return {
+        coordinator,
+        dreamState,
+        timers,
+        cleared,
+        notifications,
+        dreamRequests,
+        logs,
+        setNow: (value) => { nowMs = value; },
+        setCurrentSessionId: (value) => { currentSessionId = value; },
+        setActiveTurn: (value) => { activeTurn = value; },
+    };
+}
+describe("IdleDreamCoordinator", () => {
+    it("enables idle dream and schedules an unrefed timer for the active session", () => {
+        const { coordinator, dreamState, timers } = createHarness();
+        coordinator.enable(2);
+        expect(dreamState.enabled).toBe(true);
+        expect(dreamState.idleMinutes).toBe(2);
+        expect(timers).toHaveLength(1);
+        expect(timers[0].delayMs).toBe(120_000);
+        expect(timers[0].unref).toHaveBeenCalledTimes(1);
+    });
+    it("cancels while a turn is active and reschedules after turn end", () => {
+        const { coordinator, timers, cleared } = createHarness();
+        coordinator.enable();
+        coordinator.handleTurnNotification("turn.start");
+        coordinator.handleTurnNotification("turn.end");
+        expect(cleared).toEqual([timers[0]]);
+        expect(timers).toHaveLength(2);
+    });
+    it("skips trigger when cooldown or active turn prevents a safe dream", async () => {
+        const cooldown = createHarness({ lastDreamAt: 9500, cooldownMs: 1000 });
+        await cooldown.coordinator.triggerIdleDream();
+        expect(cooldown.dreamRequests).toHaveLength(0);
+        expect(cooldown.logs).toContain("[dream:idle] Skipped - cooldown not elapsed");
+        const active = createHarness({ cooldownMs: 0 });
+        active.setActiveTurn(new AbortController());
+        await active.coordinator.triggerIdleDream();
+        expect(active.dreamRequests).toHaveLength(0);
+        expect(active.logs).toContain("[dream:idle] Skipped - turn in progress");
+    });
+    it("runs dream through a synthetic memory.dream request and reschedules afterwards", async () => {
+        const { coordinator, dreamState, timers, notifications, dreamRequests } = createHarness({ cooldownMs: 0 });
+        coordinator.enable();
+        await coordinator.triggerIdleDream();
+        expect(dreamState.lastDreamAt).toBe(10_000);
+        expect(notifications[0]).toMatchObject({
+            method: "system.activity",
+            params: {
+                category: "dream",
+                level: "info",
+                title: "空闲梦境整理触发",
+            },
+        });
+        expect(dreamRequests).toHaveLength(1);
+        expect(dreamRequests[0]).toMatchObject({
+            jsonrpc: "2.0",
+            method: "memory.dream",
+            params: {
+                turnId: "idle-dream-dream1234",
+                sessionId: "session-current",
+                config: {
+                    memoryRoot: "C:/workspace/.qlogicagent/memory",
+                    transcriptDir: "C:/workspace/.qlogicagent/sessions",
+                    dreamSessionIds: ["session-old"],
+                    currentSessionTurnCount: 7,
+                    model: "model-a",
+                    apiKey: "key-a",
+                    force: false,
+                },
+            },
+        });
+        expect(timers.at(-1)?.delayMs).toBe(60);
+    });
+});

package/dist/cli/main.d.ts

@@ -0,0 +1,15 @@
+/**
+ * qlogicagent CLI — Agent subprocess entry point.
+ *
+ * Communicates with host applications via JSON-RPC over pluggable transports.
+ * Default transport: line-delimited JSON over stdin/stdout.
+ * All log/debug output goes to stderr (never pollutes the protocol).
+ *
+ * Usage:
+ *   qlogicagent [--verbose] [--acp]
+ *
+ * Flags:
+ *  verbose  Enable debug logging to stderr
+ *  acp      Enable ACP (Agent-Client Protocol) server alongside legacy protocol
+ */
+export {};

package/dist/cli/main.js

@@ -0,0 +1,112 @@
+/**
+ * qlogicagent CLI — Agent subprocess entry point.
+ *
+ * Communicates with host applications via JSON-RPC over pluggable transports.
+ * Default transport: line-delimited JSON over stdin/stdout.
+ * All log/debug output goes to stderr (never pollutes the protocol).
+ *
+ * Usage:
+ *   qlogicagent [--verbose] [--acp]
+ *
+ * Flags:
+ *  verbose  Enable debug logging to stderr
+ *  acp      Enable ACP (Agent-Client Protocol) server alongside legacy protocol
+ */
+import { StdioServer } from "./stdio-server.js";
+import { StdioTransport } from "./transport.js";
+import { disposeAllPooledAgents } from "../runtime/infra/external-agent-pool.js";
+import { parseCliArgs } from "../config/config.js";
+import { writeFileSync, appendFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+// ── File-based debug log (persists even if stderr is lost) ──────────
+const debugLogDir = join(process.env.QLOGICAGENT_HOME || join(homedir(), ".qlogicagent"), "debug-logs");
+try {
+    mkdirSync(debugLogDir, { recursive: true });
+}
+catch { }
+const debugLogPath = join(debugLogDir, "acp-session.log");
+try {
+    writeFileSync(debugLogPath, "");
+}
+catch { } // truncate on each startup
+function diagLog(msg) {
+    const line = `[${new Date().toISOString()}] ${msg}\n`;
+    origStderrWrite.call(process.stderr, line);
+    try {
+        appendFileSync(debugLogPath, line);
+    }
+    catch { }
+}
+// Intercept ALL stderr writes so they also go to the file log
+const origStderrWrite = process.stderr.write.bind(process.stderr);
+process.stderr.write = ((chunk, ...args) => {
+    const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString();
+    try {
+        appendFileSync(debugLogPath, text);
+    }
+    catch { }
+    return origStderrWrite(chunk, ...args);
+});
+// Emit startup banner immediately so AionUI stderr captures it
+diagLog(`PID=${process.pid} argv=${JSON.stringify(process.argv.slice(1))} cwd=${process.cwd()} HOME=${process.env.QLOGICAGENT_HOME ?? "(unset)"} NODE=${process.version}`);
+const config = parseCliArgs(process.argv);
+// ACP mode is the default — always enable unless explicitly disabled.
+// AionUI may passexperimental-acp,acp, or nothing at all (empty acpArgs).
+const acpMode = !process.argv.includes("--no-acp");
+const transport = new StdioTransport({ verbose: config.verbose });
+const server = new StdioServer({ verbose: config.verbose, transport });
+// Initialize ACP server (always on by default)
+if (acpMode) {
+    server.initAcpServer();
+    diagLog("ACP server initialized, waiting for messages");
+}
+// Prevent unhandled rejections from crashing the process (ACP hosts interpret
+// an unexpected exit as "agent disconnected"). Log to stderr for diagnosis.
+process.on("unhandledRejection", (reason) => {
+    diagLog(`unhandledRejection: ${reason instanceof Error ? reason.stack ?? reason.message : String(reason)}`);
+});
+// Prevent uncaught exceptions from crashing silently
+process.on("uncaughtException", (err) => {
+    diagLog(`uncaughtException: ${err.stack ?? err.message}`);
+});
+// Diagnostic: log when stdin closes (often indicates parent killed the pipe)
+process.stdin.on("end", () => {
+    diagLog("stdin END received");
+});
+process.stdin.on("close", () => {
+    diagLog("stdin CLOSE received");
+});
+// Diagnostic: stdout events
+process.stdout.on("error", (err) => {
+    diagLog(`stdout ERROR: ${err.message}`);
+});
+process.stdout.on("close", () => {
+    diagLog("stdout CLOSE");
+});
+// Diagnostic: log on process exit with reason
+process.on("exit", (code) => {
+    diagLog(`process.exit code=${code}`);
+});
+// Signals
+let signalShutdownStarted = false;
+async function shutdownFromSignal(signal) {
+    if (signalShutdownStarted)
+        return;
+    signalShutdownStarted = true;
+    diagLog(`${signal} received`);
+    try {
+        disposeAllPooledAgents(); // kill resident external-agent processes so none are orphaned
+        await server.stop();
+    }
+    finally {
+        process.exit(0);
+    }
+}
+process.on("SIGTERM", () => { void shutdownFromSignal("SIGTERM"); });
+process.on("SIGINT", () => { void shutdownFromSignal("SIGINT"); });
+process.on("SIGHUP", () => { diagLog("SIGHUP received"); });
+// Start the JSON-RPC stdio server
+diagLog("calling server.start()");
+server.start();
+diagLog("server.start() returned, event loop active");

package/dist/cli/mcp-bootstrap.d.ts

@@ -0,0 +1,20 @@
+import { McpManager } from "../skills/mcp/mcp-manager.js";
+import type { RuntimeLogger } from "../runtime/hooks/hook-registry.js";
+import type { PathService, ToolCatalog } from "../runtime/ports/index.js";
+export interface McpBootstrapDeps {
+    config: Record<string, unknown>;
+    projectRoot: string;
+    log: RuntimeLogger;
+    pathService: PathService;
+    toolCatalog: ToolCatalog;
+    currentManager: McpManager | null;
+    setManager(manager: McpManager | null): void;
+    setReady(ready: Promise<void>): void;
+}
+export declare const mcpToolRegistrationModule: import("../runtime/ports/tool-contracts.js").ToolRegistrationModule<McpBootstrapDeps>;
+export declare function configureMcpBootstrap(deps: McpBootstrapDeps): void;
+export declare function buildMcpBootstrapEntries(params: {
+    turnMcpConfig?: unknown;
+    userMcpConfig?: unknown;
+    projectRoot: string;
+}): import("../skills/mcp/mcp-manager.js").McpServerEntry[];

package/dist/cli/mcp-bootstrap.js

@@ -0,0 +1,66 @@
+import * as fs from "node:fs";
+import { McpManager, parseMcpConfig } from "../skills/mcp/mcp-manager.js";
+import { registerCleanup } from "../runtime/infra/cleanup-registry.js";
+import { defineToolRegistrationModule } from "../runtime/ports/index.js";
+export const mcpToolRegistrationModule = defineToolRegistrationModule({
+    id: "mcp-tools",
+    kind: "mcp",
+    register: configureMcpBootstrapInternal,
+});
+export function configureMcpBootstrap(deps) {
+    mcpToolRegistrationModule.register(deps);
+}
+// MCP exposes exactly ONE surface to the agent: the servers' own tools,
+// injected dynamically as `mcp__{server}__{tool}`. Connection management
+// lives in the MCP services page (a user decision, not an agent action),
+// and the resources/prompts facets are intentionally not bridged — restore
+// them via mcporter's listResources/readResource if a real need appears.
+function configureMcpBootstrapInternal(deps) {
+    const mcpEntries = buildMcpBootstrapEntries({
+        turnMcpConfig: deps.config.mcpServers ?? {},
+        userMcpConfig: readUserMcpConfig(deps.pathService),
+        projectRoot: deps.projectRoot,
+    });
+    if (mcpEntries.length === 0)
+        return;
+    deps.currentManager?.disconnectAll().catch(() => { });
+    const manager = new McpManager({
+        servers: mcpEntries,
+        log: deps.log,
+        workspaceRoot: deps.projectRoot,
+        toolCatalog: deps.toolCatalog,
+    });
+    deps.setManager(manager);
+    registerCleanup(async () => { await manager.disconnectAll(); });
+    deps.setReady(manager.connectAll().then(() => {
+        manager.injectTools();
+        deps.log.info(`[mcp] ${manager.getToolCount()} tools from ${manager.getConnectedServers().length} servers`);
+    }).catch((err) => {
+        deps.log.warn(`[mcp] connection error: ${err instanceof Error ? err.message : err}`);
+    }));
+}
+function readUserMcpConfig(pathService) {
+    const userMcpPath = pathService.getUserMcpConfigPath();
+    try {
+        if (fs.existsSync(userMcpPath)) {
+            return JSON.parse(fs.readFileSync(userMcpPath, "utf8"));
+        }
+    }
+    catch {
+        // User MCP config unreadable; skip.
+    }
+    return undefined;
+}
+export function buildMcpBootstrapEntries(params) {
+    const turnEntries = withDefaultStdioCwd(parseMcpConfig(params.turnMcpConfig ?? {}), params.projectRoot);
+    const userEntries = withDefaultStdioCwd(parseMcpConfig(params.userMcpConfig ?? {}), params.projectRoot);
+    const existingNames = new Set(turnEntries.map(e => e.name));
+    return [...turnEntries, ...userEntries.filter(e => !existingNames.has(e.name))];
+}
+function withDefaultStdioCwd(entries, projectRoot) {
+    return entries.map(entry => {
+        if ((entry.type ?? "stdio") !== "stdio" || entry.cwd)
+            return entry;
+        return { ...entry, cwd: projectRoot };
+    });
+}

package/dist/cli/mcp-plugin-bootstrap.d.ts

@@ -0,0 +1,2 @@
+export { buildMcpBootstrapEntries, configureMcpBootstrap, type McpBootstrapDeps, } from "./mcp-bootstrap.js";
+export { configurePluginBootstrap, type PluginBootstrapDeps, } from "./plugin-bootstrap.js";

package/dist/cli/mcp-plugin-bootstrap.js

@@ -0,0 +1,2 @@
+export { buildMcpBootstrapEntries, configureMcpBootstrap, } from "./mcp-bootstrap.js";
+export { configurePluginBootstrap, } from "./plugin-bootstrap.js";

package/dist/cli/mcp-plugin-bootstrap.test.d.ts

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

package/dist/cli/mcp-plugin-bootstrap.test.js

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+import { buildMcpBootstrapEntries } from "./mcp-plugin-bootstrap.js";
+describe("buildMcpBootstrapEntries", () => {
+    it("uses the active project root as the default cwd for stdio MCP servers", () => {
+        const entries = buildMcpBootstrapEntries({
+            turnMcpConfig: {
+                filesystem: {
+                    command: "npx",
+                    args: ["-y", "@modelcontextprotocol/server-filesystem", "F:\\xiaozhiclaw"],
+                },
+            },
+            projectRoot: "F:\\xiaozhiclaw\\test_qlogicagent\\.tmp\\workspaces\\perm-rules-abc",
+        });
+        expect(entries).toHaveLength(1);
+        expect(entries[0]).toMatchObject({
+            name: "filesystem",
+            type: "stdio",
+            cwd: "F:\\xiaozhiclaw\\test_qlogicagent\\.tmp\\workspaces\\perm-rules-abc",
+        });
+    });
+    it("keeps an explicit stdio cwd and leaves HTTP MCP servers unchanged", () => {
+        const entries = buildMcpBootstrapEntries({
+            turnMcpConfig: {
+                explicit: {
+                    command: "node",
+                    args: ["server.js"],
+                    cwd: "F:\\explicit",
+                },
+                remote: {
+                    url: "https://example.test/mcp",
+                },
+            },
+            projectRoot: "F:\\project",
+        });
+        expect(entries.find((entry) => entry.name === "explicit")?.cwd).toBe("F:\\explicit");
+        expect(entries.find((entry) => entry.name === "remote")).not.toHaveProperty("cwd");
+    });
+});

package/dist/cli/mcp-tool-proxy.d.ts

@@ -0,0 +1,7 @@
+import type { ToolCatalog } from "../runtime/ports/index.js";
+export declare function handleMcpToolProxyCall(params: {
+    toolCatalog: ToolCatalog;
+    memberId: string;
+    toolName: string;
+    args: Record<string, unknown>;
+}): Promise<string>;

package/dist/cli/mcp-tool-proxy.js

@@ -0,0 +1,15 @@
+import { randomUUID } from "node:crypto";
+export async function handleMcpToolProxyCall(params) {
+    const tool = params.toolCatalog.findTool(params.toolName);
+    if (!tool?.execute) {
+        return `Error: Unknown tool "${params.toolName}"`;
+    }
+    const callId = `mcp_${params.memberId}_${randomUUID().slice(0, 8)}`;
+    try {
+        const result = await tool.execute(callId, params.args);
+        return result.content.map(content => content.text ?? "").join("\n") || "OK";
+    }
+    catch (err) {
+        return `Error: ${err instanceof Error ? err.message : String(err)}`;
+    }
+}

package/dist/cli/media-capability-schema.d.ts

@@ -0,0 +1,49 @@
+import type { MediaCapability, MediaRequest } from "./provider-core-facade.js";
+export type MediaMode = "text2image" | "img2img" | "inpainting" | "outpainting" | "text2video" | "img2video" | "first_last_frame" | "video2video" | "multimodal_reference" | "edit" | "merge" | "upscale" | "extend" | "text2music" | "cover" | "realtime" | "text2speech" | "voice_clone" | "text2_3d" | "img2_3d" | "speech2text";
+export interface MediaCapabilityLimits {
+    sizes?: string[];
+    resolutions?: string[];
+    aspectRatios?: string[];
+    fps?: number[];
+    durationSeconds?: {
+        min?: number;
+        max?: number;
+    };
+    maxReferenceImages?: number;
+    maxReferenceVideos?: number;
+    maxReferenceAudios?: number;
+    maxSourceVideos?: number;
+    maxOutputs?: number;
+    voices?: string[];
+    maxCharacters?: number;
+    formats?: string[];
+    outputFormats?: string[];
+}
+export interface MediaCapabilityFeatures {
+    transparentBackground?: boolean;
+    generateAudio?: boolean;
+    returnLastFrame?: boolean;
+    serviceTiers?: string[];
+    videoTools?: string[];
+}
+export interface NormalizedMediaCapabilitySchema {
+    mediaType: MediaCapability;
+    modes: MediaMode[];
+    declaredModes: MediaMode[];
+    limits: MediaCapabilityLimits;
+    features: MediaCapabilityFeatures;
+    source: "declared" | "fallback";
+    raw?: Record<string, unknown>;
+}
+export type MediaCapabilityDecision = {
+    allowed: true;
+    mode: MediaMode;
+    reason?: undefined;
+} | {
+    allowed: false;
+    mode: MediaMode;
+    reason: string;
+};
+export declare function normalizeMediaCapabilitySchema(mediaType: MediaCapability, rawCapabilities: unknown): NormalizedMediaCapabilitySchema;
+export declare function resolveMediaCapabilityDecision(request: MediaRequest, schema: NormalizedMediaCapabilitySchema): MediaCapabilityDecision;
+export declare function buildMediaToolParameterSchema(toolName: string, baseSchema: Record<string, unknown>, capability: NormalizedMediaCapabilitySchema): Record<string, unknown>;