qlogicagent 2.13.3 → 2.13.5

package/dist/runtime/infra/llmrouter-catalog.js

@@ -0,0 +1,287 @@
+import { createProcessConfigPort } from "./process-config-port.js";
+export const LLMROUTER_CATALOG_UNAVAILABLE_MESSAGE = "无法连接 llmrouter 模型目录";
+export const LLMROUTER_PROVIDER_ID = "llmrouter";
+export const LLMROUTER_PROVIDER_NAME = "LLMRouter";
+const CATALOG_CLIENT_CACHE_TTL_MS = 60_000;
+const catalogCache = new Map();
+const catalogInflight = new Map();
+export class LlmrouterCatalogUnavailableError extends Error {
+    constructor(message = LLMROUTER_CATALOG_UNAVAILABLE_MESSAGE) {
+        super(message);
+        this.name = "LlmrouterCatalogUnavailableError";
+    }
+}
+function getCatalogBaseUrl(configPort = createProcessConfigPort()) {
+    const value = configPort.get("QLOGIC_LLMROUTER_BASE_URL")?.trim().replace(/\/+$/, "");
+    if (!value)
+        throw new LlmrouterCatalogUnavailableError();
+    return value;
+}
+export function getLlmrouterBaseUrl(configPort) {
+    return getCatalogBaseUrl(configPort);
+}
+function catalogHeaders(configPort = createProcessConfigPort()) {
+    const headers = { accept: "application/json" };
+    const token = configPort.get("QLOGIC_LLMROUTER_ACCESS_TOKEN")?.trim();
+    if (token)
+        headers.authorization = `Bearer ${token}`;
+    return headers;
+}
+async function getJsonArray(path, configPort) {
+    const baseUrl = getCatalogBaseUrl(configPort);
+    const headers = catalogHeaders(configPort);
+    const cacheKey = `${baseUrl}\n${path}\n${headers.authorization ?? ""}`;
+    const cached = catalogCache.get(cacheKey);
+    if (cached && Date.now() < cached.expiresAt)
+        return cached.value;
+    const inflight = catalogInflight.get(cacheKey);
+    if (inflight)
+        return await inflight;
+    const request = fetchJsonArray(baseUrl, path, headers)
+        .then((value) => {
+        catalogCache.set(cacheKey, { value, expiresAt: Date.now() + CATALOG_CLIENT_CACHE_TTL_MS });
+        return value;
+    })
+        .finally(() => {
+        catalogInflight.delete(cacheKey);
+    });
+    catalogInflight.set(cacheKey, request);
+    return request;
+}
+async function getJsonArrayFresh(path, configPort) {
+    const baseUrl = getCatalogBaseUrl(configPort);
+    const headers = catalogHeaders(configPort);
+    const cacheKey = `${baseUrl}\n${path}\n${headers.authorization ?? ""}`;
+    const value = await fetchJsonArray(baseUrl, path, headers);
+    catalogCache.set(cacheKey, { value, expiresAt: Date.now() + CATALOG_CLIENT_CACHE_TTL_MS });
+    return value;
+}
+async function fetchJsonArray(baseUrl, path, headers) {
+    let response;
+    try {
+        response = await fetch(`${baseUrl}${path}`, {
+            method: "GET",
+            headers,
+            signal: AbortSignal.timeout(10_000),
+        });
+    }
+    catch {
+        throw new LlmrouterCatalogUnavailableError();
+    }
+    if (!response.ok)
+        throw new LlmrouterCatalogUnavailableError();
+    const body = await response.json().catch(() => null);
+    const data = Array.isArray(body)
+        ? body
+        : isRecord(body) && Array.isArray(body.data)
+            ? body.data
+            : null;
+    if (!data)
+        throw new LlmrouterCatalogUnavailableError();
+    return data;
+}
+export function getLlmrouterModelsUrl(baseUrl) {
+    const normalized = baseUrl.trim().replace(/\/+$/, "");
+    return normalized.endsWith("/v1") ? `${normalized}/models` : `${normalized}/v1/models`;
+}
+async function getJsonArrayWithApiKey(url, apiKey) {
+    let response;
+    try {
+        response = await fetch(url, {
+            method: "GET",
+            headers: {
+                accept: "application/json",
+                authorization: `Bearer ${apiKey}`,
+            },
+            signal: AbortSignal.timeout(10_000),
+        });
+    }
+    catch {
+        throw new LlmrouterCatalogUnavailableError();
+    }
+    if (!response.ok)
+        throw new LlmrouterCatalogUnavailableError();
+    const body = await response.json().catch(() => null);
+    const data = Array.isArray(body)
+        ? body
+        : isRecord(body) && Array.isArray(body.data)
+            ? body.data
+            : null;
+    if (!data)
+        throw new LlmrouterCatalogUnavailableError();
+    return data;
+}
+export async function listLlmrouterCatalogProviders(configPort, options = {}) {
+    return options.force
+        ? getJsonArrayFresh("/ext/model-catalog/providers", configPort)
+        : getJsonArray("/ext/model-catalog/providers", configPort);
+}
+export async function listLlmrouterCatalogModels(configPort, options = {}) {
+    return options.force
+        ? getJsonArrayFresh("/ext/model-catalog/models", configPort)
+        : getJsonArray("/ext/model-catalog/models", configPort);
+}
+export async function listLlmrouterModelsByApiKey(baseUrl, apiKey) {
+    return getJsonArrayWithApiKey(getLlmrouterModelsUrl(baseUrl), apiKey);
+}
+export function providerDisplayName(provider) {
+    const canonicalNames = {
+        zhipu: "Zhipu GLM",
+        "zhipu-openai": "Zhipu GLM OpenAI",
+        "zhipu-coding": "Zhipu GLM Coding",
+        qwen: "Alibaba Qwen (DashScope)",
+        "qwen-coding": "Alibaba Qwen (Coding Plan)",
+        volcengine: "Doubao / Volcengine",
+        "volcengine-plan": "Doubao / Volcengine Plan",
+    };
+    if (canonicalNames[provider.id])
+        return canonicalNames[provider.id];
+    return provider.displayName ?? provider.name ?? provider.id;
+}
+export function providerBaseUrl(provider) {
+    return provider.baseUrl ?? provider.base_url;
+}
+export async function getLlmrouterCatalogProvider(providerId, configPort, options = {}) {
+    const providers = await listLlmrouterCatalogProviders(configPort, options);
+    return providers.find(provider => provider.id === providerId) ?? null;
+}
+export async function refreshRegistryFromLlmrouterCatalog(registry, configPort, options = {}) {
+    const [providers, models] = await Promise.all([
+        listLlmrouterCatalogProviders(configPort, options),
+        listLlmrouterCatalogModels(configPort, options),
+    ]);
+    registry.replaceCatalogProviders(providers.map(toProviderDef));
+    const entries = models.flatMap(toModelEntries);
+    registry.replaceCatalogModels(entries);
+    return entries;
+}
+export async function refreshRegistryFromLlmrouterApiKey(registry, options) {
+    const models = await listLlmrouterModelsByApiKey(options.baseUrl, options.apiKey);
+    if (models.length === 0)
+        return [];
+    const visibleModelIds = new Set(models.map(publicModelId).filter((id) => !!id));
+    const catalogEntries = await refreshRegistryFromLlmrouterCatalog(registry, options.configPort, { force: options.forceCatalog });
+    const entries = catalogEntries
+        .filter(entry => entry.provider === LLMROUTER_PROVIDER_ID && visibleModelIds.has(entry.model))
+        .map(entry => ({ ...entry, baseUrl: options.baseUrl }));
+    registry.replaceProviderModels(LLMROUTER_PROVIDER_ID, entries);
+    return entries;
+}
+export function resetLlmrouterCatalogClientCache() {
+    catalogCache.clear();
+    catalogInflight.clear();
+}
+/**
+ * 零配置默认模型:全新安装(无 textGeneration binding)且网关注入了设备账号推理 key 时,
+ * 自动把默认文本模型设为一个 DeepSeek(经 llmrouter)。调用方需先刷新过目录(this.models 里要有
+ * `llmrouter:deepseek-*` 条目)。已有 binding 则尊重用户配置、不覆盖。返回是否设置了默认。
+ *
+ * key 不在此注册 —— ModelRegistry 取 llmrouter key 时会回退到 QLOGIC_LLMROUTER_INFERENCE_KEY env。
+ */
+export function ensureLlmrouterDefaultBinding(registry, configPort = createProcessConfigPort()) {
+    if (registry.getBinding("textGeneration"))
+        return false; // 已有 active 模型,尊重
+    const inferenceKey = configPort.get("QLOGIC_LLMROUTER_INFERENCE_KEY")?.trim();
+    if (!inferenceKey)
+        return false; // 无注入 key → 不零配置(联网/签发后下次启动再来)
+    const candidates = registry.listModels({ purpose: "textGeneration", provider: LLMROUTER_PROVIDER_ID, enabledOnly: true });
+    const deepseek = candidates.find(entry => entry.model.toLowerCase().includes("deepseek"));
+    const chosen = deepseek ?? candidates[0]; // 没 DeepSeek 时退而求其次,选目录里第一个文本模型
+    if (!chosen)
+        return false;
+    registry.setBinding("textGeneration", chosen.id);
+    return true;
+}
+export function toModelEntry(model) {
+    return toDirectProviderModelEntry(model);
+}
+export function toModelEntries(model) {
+    return [toDirectProviderModelEntry(model), toLlmrouterProviderModelEntry(model)]
+        .filter((entry) => !!entry);
+}
+function toDirectProviderModelEntry(model) {
+    const provider = model.provider ?? model.owned_by;
+    const publicModel = model.public_model ?? model.publicModel ?? model.id;
+    const nativeModelId = model.native_model_id ?? model.nativeModelId ?? model.id;
+    if (!provider || !publicModel || !nativeModelId)
+        return null;
+    return {
+        id: `${provider}:${publicModel}`,
+        provider,
+        model: publicModel,
+        displayName: model.display_name ?? model.displayName ?? model.name ?? model.id,
+        purposes: normalizePurposes(model.purposes, model.category),
+        baseUrl: model.baseUrl ?? model.base_url,
+        enabled: true,
+        nativeModelId,
+        transport: model.provider_transport ?? model.providerTransport,
+        contextWindow: model.context_window ?? model.contextWindow,
+        maxOutput: model.max_output ?? model.maxOutput,
+        streamRequired: model.stream_required ?? model.streamRequired,
+        toolCall: model.tool_call ?? model.toolCall,
+        mediaType: model.media_type !== undefined ? model.media_type : model.mediaType,
+        reasoningMode: model.reasoning_mode ?? model.reasoningMode,
+        capabilities: model.capabilities,
+        pricing: model.pricing,
+    };
+}
+function toLlmrouterProviderModelEntry(model) {
+    const publicModel = model.public_model ?? model.publicModel ?? model.id;
+    if (!publicModel)
+        return null;
+    return {
+        id: `${LLMROUTER_PROVIDER_ID}:${publicModel}`,
+        provider: LLMROUTER_PROVIDER_ID,
+        model: publicModel,
+        displayName: model.display_name ?? model.displayName ?? model.name ?? model.id,
+        purposes: normalizePurposes(model.purposes, model.category),
+        enabled: true,
+        nativeModelId: publicModel,
+        transport: "openai-responses",
+        contextWindow: model.context_window ?? model.contextWindow,
+        maxOutput: model.max_output ?? model.maxOutput,
+        streamRequired: model.stream_required ?? model.streamRequired,
+        toolCall: model.tool_call ?? model.toolCall,
+        mediaType: model.media_type !== undefined ? model.media_type : model.mediaType,
+        reasoningMode: model.reasoning_mode ?? model.reasoningMode,
+        capabilities: model.capabilities,
+        pricing: model.pricing,
+    };
+}
+function publicModelId(model) {
+    return model.public_model ?? model.publicModel ?? model.id;
+}
+function toProviderDef(provider) {
+    return {
+        id: provider.id,
+        name: providerDisplayName(provider),
+        transport: provider.transport ?? "",
+        baseUrl: providerBaseUrl(provider) ?? "",
+        group: provider.group,
+        models: provider.models?.flatMap(model => model.id ? [{ id: model.id }] : []) ?? [],
+    };
+}
+function normalizePurposes(purposes, category) {
+    const candidates = [...(purposes ?? []), category].filter((value) => !!value);
+    const known = new Set([
+        "textGeneration",
+        "smallModel",
+        "stt",
+        "tts",
+        "imageGeneration",
+        "imageUnderstanding",
+        "videoGeneration",
+        "videoUnderstanding",
+        "threeDGeneration",
+        "embedding",
+        "voiceClone",
+        "musicGeneration",
+        "realtimeAudio",
+        "realtimeVideo",
+    ]);
+    const normalized = candidates.filter((purpose) => known.has(purpose));
+    return [...new Set(normalized.length ? normalized : ["textGeneration"])];
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}

package/dist/runtime/infra/llmrouter-catalog.test.d.ts

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

package/dist/runtime/infra/llmrouter-catalog.test.js

@@ -0,0 +1,80 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { ModelRegistry } from "./model-registry.js";
+import { refreshRegistryFromLlmrouterCatalog, resetLlmrouterCatalogClientCache, } from "./llmrouter-catalog.js";
+function configPort() {
+    return {
+        get(key) {
+            if (key === "QLOGIC_LLMROUTER_BASE_URL")
+                return "https://router.test";
+            if (key === "QLOGIC_LLMROUTER_ACCESS_TOKEN")
+                return "token-123";
+            return undefined;
+        },
+    };
+}
+function catalogFetch() {
+    const calls = [];
+    const fetch = vi.fn(async (input) => {
+        const url = String(input);
+        calls.push(url);
+        if (url === "https://router.test/ext/model-catalog/providers") {
+            return Response.json({
+                data: [{
+                        id: "llmrouter",
+                        name: "LLMRouter",
+                        baseUrl: "https://router.test",
+                        transport: "openai-responses",
+                        models: [{ id: "deepseek-v4-flash" }],
+                    }],
+            });
+        }
+        if (url === "https://router.test/ext/model-catalog/models") {
+            return Response.json({
+                data: [{
+                        id: "deepseek-v4-flash",
+                        provider: "deepseek",
+                        native_model_id: "deepseek-v4-flash",
+                        display_name: "DeepSeek V4 Flash",
+                        purposes: ["textGeneration"],
+                        provider_transport: "anthropic-messages",
+                        tool_call: true,
+                        stream_required: false,
+                        reasoning_mode: "collapsed",
+                        media_type: null,
+                    }],
+            });
+        }
+        return new Response("not found", { status: 404 });
+    });
+    vi.stubGlobal("fetch", fetch);
+    return { calls, fetch };
+}
+afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+    resetLlmrouterCatalogClientCache();
+});
+describe("llmrouter catalog client cache", () => {
+    it("reuses one catalog fetch within the ttl", async () => {
+        vi.useFakeTimers();
+        vi.setSystemTime(new Date("2026-06-08T00:00:00.000Z"));
+        const { calls } = catalogFetch();
+        const registry = new ModelRegistry();
+        await refreshRegistryFromLlmrouterCatalog(registry, configPort());
+        await refreshRegistryFromLlmrouterCatalog(registry, configPort());
+        expect(calls.filter(url => url.endsWith("/ext/model-catalog/providers"))).toHaveLength(1);
+        expect(calls.filter(url => url.endsWith("/ext/model-catalog/models"))).toHaveLength(1);
+    });
+    it("coalesces concurrent catalog refreshes and refetches only when forced", async () => {
+        const { calls } = catalogFetch();
+        const first = new ModelRegistry();
+        const second = new ModelRegistry();
+        await Promise.all([
+            refreshRegistryFromLlmrouterCatalog(first, configPort()),
+            refreshRegistryFromLlmrouterCatalog(second, configPort()),
+        ]);
+        await refreshRegistryFromLlmrouterCatalog(first, configPort(), { force: true });
+        expect(calls.filter(url => url.endsWith("/ext/model-catalog/providers"))).toHaveLength(2);
+        expect(calls.filter(url => url.endsWith("/ext/model-catalog/models"))).toHaveLength(2);
+    });
+});

package/dist/runtime/infra/llmrouter-zero-config.test.d.ts

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

package/dist/runtime/infra/llmrouter-zero-config.test.js

@@ -0,0 +1,64 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { ModelRegistry } from "./model-registry.js";
+import { ensureLlmrouterDefaultBinding } from "./llmrouter-catalog.js";
+function deepseekLlmrouterEntry() {
+    return {
+        id: "llmrouter:deepseek-v4-flash",
+        provider: "llmrouter",
+        model: "deepseek-v4-flash",
+        displayName: "DeepSeek V4 Flash",
+        purposes: ["textGeneration"],
+        enabled: true,
+        nativeModelId: "deepseek-v4-flash",
+        transport: "openai-responses",
+    };
+}
+afterEach(() => vi.unstubAllEnvs());
+describe("零配置默认 DeepSeek@llmrouter", () => {
+    it("无 binding + 注入推理 key + 目录有 DeepSeek → 默认文本模型设为 llmrouter:deepseek*", () => {
+        vi.stubEnv("QLOGIC_LLMROUTER_INFERENCE_KEY", "sk-qllm-zero");
+        const registry = new ModelRegistry();
+        registry.replaceCatalogModels([deepseekLlmrouterEntry()]);
+        expect(ensureLlmrouterDefaultBinding(registry)).toBe(true);
+        expect(registry.getBinding("textGeneration")?.id).toBe("llmrouter:deepseek-v4-flash");
+        // getActiveModel 经 env 回退拿到 sk-qllm —— keyPool 里并没有这把 key。
+        const active = registry.getActiveModel("textGeneration");
+        expect(active?.apiKey).toBe("sk-qllm-zero");
+        expect(active?.model).toBe("deepseek-v4-flash");
+        active?.keyHandle.release({ success: true });
+    });
+    it("已有 binding 时不覆盖(尊重用户配置)", () => {
+        vi.stubEnv("QLOGIC_LLMROUTER_INFERENCE_KEY", "sk-qllm-zero");
+        const registry = new ModelRegistry();
+        const other = { ...deepseekLlmrouterEntry(), id: "llmrouter:glm-4", model: "glm-4" };
+        registry.replaceCatalogModels([deepseekLlmrouterEntry(), other]);
+        registry.setBinding("textGeneration", "llmrouter:glm-4");
+        expect(ensureLlmrouterDefaultBinding(registry)).toBe(false);
+        expect(registry.getBinding("textGeneration")?.id).toBe("llmrouter:glm-4");
+    });
+    it("没有注入推理 key 时不设默认(联网/签发后下次启动再来)", () => {
+        vi.stubEnv("QLOGIC_LLMROUTER_INFERENCE_KEY", "");
+        const registry = new ModelRegistry();
+        registry.replaceCatalogModels([deepseekLlmrouterEntry()]);
+        expect(ensureLlmrouterDefaultBinding(registry)).toBe(false);
+        expect(registry.getBinding("textGeneration")).toBeNull();
+    });
+    it("手填 llmrouter key 优先于 env 注入 key", () => {
+        vi.stubEnv("QLOGIC_LLMROUTER_INFERENCE_KEY", "sk-qllm-env");
+        const registry = new ModelRegistry();
+        registry.addProvider("llmrouter", { baseUrl: "https://router.test/api" });
+        registry.addKey("llmrouter", "sk-qllm-manual");
+        registry.replaceCatalogModels([deepseekLlmrouterEntry()]);
+        registry.setBinding("textGeneration", "llmrouter:deepseek-v4-flash");
+        const active = registry.getActiveModel("textGeneration");
+        expect(active?.apiKey).toBe("sk-qllm-manual"); // keyPool 先于 env
+        active?.keyHandle.release({ success: true });
+    });
+    it("isAvailable 在仅有 env key 时也为 true", () => {
+        vi.stubEnv("QLOGIC_LLMROUTER_INFERENCE_KEY", "sk-qllm-zero");
+        const registry = new ModelRegistry();
+        registry.replaceCatalogModels([deepseekLlmrouterEntry()]);
+        ensureLlmrouterDefaultBinding(registry);
+        expect(registry.isAvailable("textGeneration")).toBe(true);
+    });
+});

package/dist/runtime/infra/mcp-bridge.d.ts

@@ -0,0 +1,166 @@
+/**
+ * MCP Bridge — exports qlogicagent tools as MCP (Model Context Protocol) servers
+ * for injection into external ACP agent sessions.
+ *
+ * When an ACP agent's session is created, we inject MCP servers that expose
+ * qlogicagent's native tools (media_generate, memory_*, web_search, etc.)
+ * so external agents can call them.
+ *
+ * Architecture:
+ *   qlogicagent ─── ACP ───→ external agent
+ *       └── MCP bridge server ◄── tools/call ── external agent
+ *
+ * The bridge server runs as a stdio child process. Each external agent
+ * session gets its own MCP bridge server instance.
+ */
+import type { McpServerConfig, AgentCapabilities } from "../../protocol/wire/acp-agent-management.js";
+/**
+ * Tools exported via MCP bridge.
+ * These represent qlogicagent capabilities that external agents can call.
+ */
+export declare const MCP_BRIDGE_TOOLS: readonly [{
+    readonly name: "media_generate";
+    readonly description: "Generate images or videos using AI models.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly prompt: {
+                readonly type: "string";
+                readonly description: "Generation prompt";
+            };
+            readonly type: {
+                readonly type: "string";
+                readonly enum: readonly ["image", "video"];
+                readonly description: "Media type";
+            };
+        };
+        readonly required: readonly ["prompt"];
+    };
+}, {
+    readonly name: "media_status";
+    readonly description: "Check status of an async media generation job.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly jobId: {
+                readonly type: "string";
+                readonly description: "Job ID to check";
+            };
+        };
+        readonly required: readonly ["jobId"];
+    };
+}, {
+    readonly name: "memory_read";
+    readonly description: "Read from persistent memory.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly key: {
+                readonly type: "string";
+                readonly description: "Memory key to read";
+            };
+        };
+        readonly required: readonly ["key"];
+    };
+}, {
+    readonly name: "memory_write";
+    readonly description: "Write to persistent memory.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly key: {
+                readonly type: "string";
+                readonly description: "Memory key";
+            };
+            readonly value: {
+                readonly type: "string";
+                readonly description: "Value to store";
+            };
+        };
+        readonly required: readonly ["key", "value"];
+    };
+}, {
+    readonly name: "memory_search";
+    readonly description: "Search persistent memory by query.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly query: {
+                readonly type: "string";
+                readonly description: "Search query";
+            };
+        };
+        readonly required: readonly ["query"];
+    };
+}, {
+    readonly name: "web_search";
+    readonly description: "Search the web for information.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly query: {
+                readonly type: "string";
+                readonly description: "Search query";
+            };
+        };
+        readonly required: readonly ["query"];
+    };
+}, {
+    readonly name: "web_fetch";
+    readonly description: "Fetch content from a URL.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly url: {
+                readonly type: "string";
+                readonly description: "URL to fetch";
+            };
+        };
+        readonly required: readonly ["url"];
+    };
+}, {
+    readonly name: "team_status";
+    readonly description: "Get status of all agent team members.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {};
+    };
+}, {
+    readonly name: "team_message";
+    readonly description: "Send a message to another team member agent.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly targetAgentId: {
+                readonly type: "string";
+                readonly description: "Target agent ID";
+            };
+            readonly message: {
+                readonly type: "string";
+                readonly description: "Message to send";
+            };
+        };
+        readonly required: readonly ["targetAgentId", "message"];
+    };
+}];
+export declare class McpBridge {
+    private bridgeScriptPath;
+    constructor(distDir: string);
+    /**
+     * Check whether an ACP agent supports MCP server injection.
+     */
+    canInjectMcp(capabilities?: AgentCapabilities): boolean;
+    /**
+     * Generate the MCP server config to inject into an ACP session.
+     * This config tells the ACP agent how to spawn our MCP bridge server.
+     *
+     * @param parentRpcPort - Port/path for the bridge to call back to qlogicagent
+     * @param sessionId - Current session ID for scoping
+     */
+    getMcpServerConfig(parentRpcPort: string, sessionId: string): McpServerConfig;
+    /**
+     * Get the list of tools that the MCP bridge will expose.
+     * Can be used for display or capability checking.
+     */
+    getExportedTools(): typeof MCP_BRIDGE_TOOLS;
+}