qlogicagent 2.13.5 → 2.13.6

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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