@kafca/agentdock 0.1.7

package/dist-electron/services/local-ai-core/src/kernel/bootstrap.js

@@ -0,0 +1,291 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bootstrapLocalCoreKernel = bootstrapLocalCoreKernel;
+exports.bootstrapLocalCoreRuntime = bootstrapLocalCoreRuntime;
+const local_core_acp_store_js_1 = require("../acp/local-core-acp-store.js");
+const capability_registry_js_1 = require("./capability-registry.js");
+const diagnostics_js_1 = require("./diagnostics.js");
+const event_bus_js_1 = require("./event-bus.js");
+const lifecycle_manager_js_1 = require("./lifecycle-manager.js");
+const plugin_registry_js_1 = require("./plugin-registry.js");
+const agent_localcore_acp_plugin_js_1 = require("../plugins/builtin/agent-localcore-acp-plugin.js");
+const channel_lark_plugin_js_1 = require("../plugins/builtin/channel-lark-plugin.js");
+const channel_weixin_plugin_js_1 = require("../plugins/builtin/channel-weixin-plugin.js");
+const knowledge_ai_vector_plugin_js_1 = require("../plugins/builtin/knowledge-ai-vector-plugin.js");
+const knowledge_noop_plugin_js_1 = require("../plugins/builtin/knowledge-noop-plugin.js");
+const scheduler_cron_plugin_js_1 = require("../plugins/builtin/scheduler-cron-plugin.js");
+const scheduler_lark_plugin_js_1 = require("../plugins/builtin/scheduler-lark-plugin.js");
+const scheduler_weixin_plugin_js_1 = require("../plugins/builtin/scheduler-weixin-plugin.js");
+const workspace_router_js_1 = require("../router/workspace-router.js");
+const local_core_runtime_state_js_1 = require("../runtime/local-core-runtime-state.js");
+const scheduler_service_js_1 = require("../scheduler/scheduler-service.js");
+function bootstrapLocalCoreKernel(options) {
+    const capabilities = new capability_registry_js_1.LocalCoreCapabilityRegistry();
+    const plugins = new plugin_registry_js_1.LocalCorePluginRegistry(options?.disabledPluginIds);
+    const context = {
+        bus: new event_bus_js_1.LocalCoreEventBus(),
+        capabilities,
+        logger: {
+            log(message) {
+                options?.log?.(message);
+            },
+        },
+    };
+    const lifecycle = new lifecycle_manager_js_1.LocalCoreLifecycleManager(plugins, context);
+    const diagnostics = new diagnostics_js_1.LocalCoreDiagnostics(plugins, lifecycle);
+    const builtIns = [
+        ...['codex', 'cursor', 'gemini', 'qoder', 'iflow'].map((agentType) => (0, agent_localcore_acp_plugin_js_1.createBuiltinStaticAgentCapabilityPlugin)(agentType)),
+        (0, agent_localcore_acp_plugin_js_1.createBuiltinLocalCoreAcpAgentPlugin)(),
+        (0, scheduler_cron_plugin_js_1.createBuiltinCronSchedulerPlugin)(),
+    ];
+    for (const plugin of builtIns) {
+        plugins.register(plugin);
+        options?.log?.(`[plugin:${plugin.manifest.id}] registered`);
+        if (plugin.capabilities && plugins.isEnabled(plugin.manifest.id)) {
+            logCapabilityContributions(plugin, options?.log);
+            capabilities.registerContributions(plugin.capabilities);
+        }
+        else if (!plugins.isEnabled(plugin.manifest.id)) {
+            options?.log?.(`[plugin:${plugin.manifest.id}] disabled by runtime settings`);
+        }
+    }
+    return {
+        context,
+        plugins,
+        capabilities,
+        lifecycle,
+        diagnostics,
+        getCapabilitySnapshot() {
+            const snapshot = capabilities.snapshot();
+            return {
+                adapters: {
+                    channels: snapshot.channels.map((capability) => capability.platform),
+                    agents: snapshot.agents.map((capability) => capability.agentType),
+                    knowledge: snapshot.knowledge.some((capability) => capability.enabled !== false),
+                    knowledgeProviders: [...new Set(snapshot.knowledge
+                            .filter((capability) => capability.enabled !== false)
+                            .map((capability) => capability.sourceType))],
+                },
+                scheduler: {
+                    enabled: snapshot.schedulers.some((capability) => capability.enabled !== false),
+                    triggerTypes: [...new Set(snapshot.schedulers.flatMap((capability) => capability.triggerTypes))],
+                    deliveryTargets: [...new Set(snapshot.schedulers.flatMap((capability) => capability.deliveryTargets || capability.deliveryPlatforms || []))],
+                    platforms: [...new Set(snapshot.schedulers.flatMap((capability) => capability.deliveryTargets || capability.deliveryPlatforms || []))],
+                },
+                snapshot,
+            };
+        },
+    };
+}
+function registerPlugin(kernel, plugin) {
+    kernel.plugins.register(plugin);
+    kernel.context.logger.log(`[plugin:${plugin.manifest.id}] registered`);
+    if (plugin.capabilities && kernel.plugins.isEnabled(plugin.manifest.id)) {
+        logCapabilityContributions(plugin, kernel.context.logger.log);
+        kernel.capabilities.registerContributions(plugin.capabilities);
+    }
+    else if (!kernel.plugins.isEnabled(plugin.manifest.id)) {
+        kernel.context.logger.log(`[plugin:${plugin.manifest.id}] disabled by runtime settings`);
+    }
+}
+function logCapabilityContributions(plugin, log) {
+    if (!log || !plugin.capabilities) {
+        return;
+    }
+    const capabilityIds = [
+        ...(plugin.capabilities.agents || []).map((capability) => capability.id),
+        ...(plugin.capabilities.channels || []).map((capability) => capability.id),
+        ...(plugin.capabilities.knowledge || []).map((capability) => capability.id),
+        ...(plugin.capabilities.schedulers || []).map((capability) => capability.id),
+        ...(plugin.capabilities.ui || []).map((capability) => capability.id),
+    ];
+    for (const capabilityId of capabilityIds) {
+        log(`[plugin:${plugin.manifest.id}][capability:${capabilityId}] registered`);
+    }
+}
+function resolveKnowledgeRuntime(plugin, context) {
+    if (!plugin.createRuntime) {
+        throw new Error(`Knowledge plugin ${plugin.manifest.id} does not provide a runtime factory.`);
+    }
+    const runtime = plugin.createRuntime(context);
+    if (runtime instanceof Promise) {
+        throw new Error(`Knowledge plugin ${plugin.manifest.id} returned an async runtime factory during synchronous bootstrap.`);
+    }
+    return runtime;
+}
+function resolveChannelRuntime(plugin, context) {
+    if (!plugin.createRuntime) {
+        throw new Error(`Channel plugin ${plugin.manifest.id} does not provide a runtime factory.`);
+    }
+    const runtime = plugin.createRuntime(context);
+    if (runtime instanceof Promise) {
+        throw new Error(`Channel plugin ${plugin.manifest.id} returned an async runtime factory during synchronous bootstrap.`);
+    }
+    return runtime;
+}
+function resolveAgentRuntime(plugin, context) {
+    if (!plugin.createRuntime) {
+        throw new Error(`Agent plugin ${plugin.manifest.id} does not provide a runtime factory.`);
+    }
+    const runtime = plugin.createRuntime(context);
+    if (runtime instanceof Promise) {
+        throw new Error(`Agent plugin ${plugin.manifest.id} returned an async runtime factory during synchronous bootstrap.`);
+    }
+    return runtime;
+}
+function resolveSchedulerRuntime(plugin, context) {
+    if (!plugin.createRuntime) {
+        throw new Error(`Scheduler plugin ${plugin.manifest.id} does not provide a runtime factory.`);
+    }
+    const runtime = plugin.createRuntime(context);
+    if (runtime instanceof Promise) {
+        throw new Error(`Scheduler plugin ${plugin.manifest.id} returned an async runtime factory during synchronous bootstrap.`);
+    }
+    return runtime;
+}
+function bootstrapLocalCoreRuntime(options) {
+    const state = (0, local_core_runtime_state_js_1.createLocalCoreRuntimeState)({
+        userDataPath: options.userDataPath,
+        onLog: options.log,
+    });
+    const disabledPluginIds = Object.entries(state.getSettings().plugins)
+        .filter(([, settings]) => settings.enabled === false)
+        .map(([pluginId]) => pluginId);
+    const kernel = bootstrapLocalCoreKernel({
+        log: options.log,
+        disabledPluginIds,
+    });
+    const store = new local_core_acp_store_js_1.LocalCoreAcpStore(options.userDataPath);
+    const localCoreAgentPlugin = kernel.plugins.get('builtin.agent-localcore-acp');
+    if (!localCoreAgentPlugin) {
+        throw new Error('Missing built-in LocalCore ACP agent plugin.');
+    }
+    const agentPlugins = [
+        localCoreAgentPlugin,
+        (0, agent_localcore_acp_plugin_js_1.createBuiltinOpencodeAgentPlugin)(),
+        (0, agent_localcore_acp_plugin_js_1.createBuiltinClaudeCodeAgentPlugin)(),
+    ];
+    let workspaceRouter;
+    let weixinChannelRuntime;
+    const channelPlugin = (0, channel_lark_plugin_js_1.createBuiltinLarkChannelPlugin)({
+        store,
+        readConfig: async () => (await state.readConfigFile()).parsed,
+        getWorkspaceRouter: () => workspaceRouter,
+        log: options.log,
+    });
+    const weixinChannelPlugin = (0, channel_weixin_plugin_js_1.createBuiltinWeixinChannelPlugin)({
+        store,
+        readConfig: async () => (await state.readConfigFile()).parsed,
+        getWorkspaceRouter: () => workspaceRouter,
+        log: options.log,
+    });
+    const knowledgePlugin = options.enableKnowledge === false
+        ? (0, knowledge_noop_plugin_js_1.createBuiltinNoopKnowledgePlugin)()
+        : (0, knowledge_ai_vector_plugin_js_1.createBuiltinAiVectorKnowledgePlugin)({
+            userDataPath: options.userDataPath,
+            getConfig: () => state.getKnowledgeConfig(),
+            setConfig: (input) => state.updateKnowledgeConfig(input),
+        });
+    const schedulerPlugins = [
+        (0, scheduler_lark_plugin_js_1.createBuiltinLarkSchedulerPlugin)({
+            store,
+            getWorkspaceRouter: () => workspaceRouter,
+            getChannelRuntime: () => channelRuntime,
+            log: options.log,
+        }),
+        (0, scheduler_weixin_plugin_js_1.createBuiltinWeixinSchedulerPlugin)({
+            store,
+            getWorkspaceRouter: () => workspaceRouter,
+            getChannelRuntime: () => weixinChannelRuntime,
+            log: options.log,
+        }),
+    ];
+    for (const plugin of agentPlugins.filter((plugin) => plugin !== localCoreAgentPlugin)) {
+        registerPlugin(kernel, plugin);
+    }
+    registerPlugin(kernel, channelPlugin);
+    registerPlugin(kernel, weixinChannelPlugin);
+    registerPlugin(kernel, knowledgePlugin);
+    for (const plugin of schedulerPlugins) {
+        registerPlugin(kernel, plugin);
+    }
+    const agentRuntimes = agentPlugins
+        .filter((plugin) => kernel.plugins.isEnabled(plugin.manifest.id))
+        .map((plugin) => resolveAgentRuntime(plugin, kernel.context).runtime);
+    const channelRuntime = resolveChannelRuntime(channelPlugin, kernel.context).channel;
+    weixinChannelRuntime = resolveChannelRuntime(weixinChannelPlugin, kernel.context).channel;
+    const knowledgeRuntime = kernel.plugins.isEnabled(knowledgePlugin.manifest.id)
+        ? resolveKnowledgeRuntime(knowledgePlugin, kernel.context)
+        : resolveKnowledgeRuntime((0, knowledge_noop_plugin_js_1.createBuiltinNoopKnowledgePlugin)(), kernel.context);
+    const cronSchedulerPlugin = (0, scheduler_cron_plugin_js_1.createBuiltinCronSchedulerPlugin)();
+    const schedulerRuntimes = [
+        ...(kernel.plugins.isEnabled(cronSchedulerPlugin.manifest.id)
+            ? [resolveSchedulerRuntime(cronSchedulerPlugin, kernel.context)]
+            : []),
+        ...schedulerPlugins
+            .filter((plugin) => kernel.plugins.isEnabled(plugin.manifest.id))
+            .map((plugin) => resolveSchedulerRuntime(plugin, kernel.context)),
+    ];
+    const schedulerTriggers = schedulerRuntimes.flatMap((runtime) => runtime.triggers || []);
+    const schedulerExecutors = schedulerRuntimes.flatMap((runtime) => runtime.executors || []);
+    const knowledgeProvider = knowledgeRuntime.provider;
+    const knowledgeAttachments = knowledgeRuntime.attachments;
+    workspaceRouter = (0, workspace_router_js_1.createWorkspaceRouter)({
+        store,
+        cliBinDir: state.cliBinDir,
+        localCoreBase: options.localCoreBase,
+        readConfigState: () => state.readConfigFile(),
+        getCapabilities: () => kernel.getCapabilitySnapshot(),
+        getAgentRuntimes: () => agentRuntimes,
+        eventBus: kernel.context.bus,
+        knowledgeProvider,
+        knowledgeAttachments,
+        log: options.log,
+    });
+    const scheduler = new scheduler_service_js_1.SchedulerService({
+        store,
+        triggers: schedulerTriggers,
+        executors: schedulerExecutors,
+        eventBus: kernel.context.bus,
+        log: options.log,
+    });
+    workspaceRouter.setSchedulerBridge({
+        createJob: async ({ workspaceId, platform, route, name, schedule, scheduleDescription, message }) => scheduler.createJob({
+            workspaceId,
+            platform,
+            route,
+            triggerType: 'cron',
+            cronExpr: schedule,
+            promptTemplate: message,
+            description: `${name} · ${scheduleDescription}`,
+            enabled: true,
+        }),
+        listJobsForThread: async (threadId) => scheduler
+            .listJobs()
+            .filter((job) => job.route.threadId === threadId),
+        deleteJob: async (jobId) => {
+            scheduler.deleteJob(jobId);
+        },
+    });
+    return {
+        kernel,
+        state,
+        store,
+        agentRuntimes,
+        channelRuntime,
+        weixinChannelRuntime,
+        knowledgeProvider,
+        knowledgeAttachments,
+        workspaceRouter,
+        scheduler,
+        async start() {
+            await kernel.lifecycle.startAll();
+            await scheduler.start();
+        },
+        async stop() {
+            await scheduler.stop();
+            await kernel.lifecycle.stopAll();
+            workspaceRouter.close();
+        },
+    };
+}

package/dist-electron/services/local-ai-core/src/kernel/capability-registry.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalCoreCapabilityRegistry = void 0;
+class LocalCoreCapabilityRegistry {
+    agents = new Map();
+    channels = new Map();
+    knowledge = new Map();
+    schedulers = new Map();
+    ui = new Map();
+    registerAgent(capability) {
+        this.agents.set(capability.id, capability);
+    }
+    registerChannel(capability) {
+        this.channels.set(capability.id, capability);
+    }
+    registerKnowledge(capability) {
+        this.knowledge.set(capability.id, capability);
+    }
+    registerScheduler(capability) {
+        this.schedulers.set(capability.id, capability);
+    }
+    registerUi(capability) {
+        this.ui.set(capability.id, capability);
+    }
+    registerContributions(contributions) {
+        for (const capability of contributions.agents || []) {
+            this.registerAgent(capability);
+        }
+        for (const capability of contributions.channels || []) {
+            this.registerChannel(capability);
+        }
+        for (const capability of contributions.knowledge || []) {
+            this.registerKnowledge(capability);
+        }
+        for (const capability of contributions.schedulers || []) {
+            this.registerScheduler(capability);
+        }
+        for (const capability of contributions.ui || []) {
+            this.registerUi(capability);
+        }
+    }
+    listAgents() {
+        return [...this.agents.values()];
+    }
+    listChannels() {
+        return [...this.channels.values()];
+    }
+    listKnowledge() {
+        return [...this.knowledge.values()];
+    }
+    listSchedulers() {
+        return [...this.schedulers.values()];
+    }
+    listUi() {
+        return [...this.ui.values()];
+    }
+    snapshot() {
+        return {
+            agents: this.listAgents(),
+            channels: this.listChannels(),
+            knowledge: this.listKnowledge(),
+            schedulers: this.listSchedulers(),
+            ui: this.listUi(),
+        };
+    }
+}
+exports.LocalCoreCapabilityRegistry = LocalCoreCapabilityRegistry;

package/dist-electron/services/local-ai-core/src/kernel/diagnostics.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalCoreDiagnostics = void 0;
+class LocalCoreDiagnostics {
+    registry;
+    lifecycle;
+    constructor(registry, lifecycle) {
+        this.registry = registry;
+        this.lifecycle = lifecycle;
+    }
+    async snapshot() {
+        const plugins = this.registry.list();
+        const health = await this.lifecycle.healthCheckAll();
+        const healthByPlugin = new Map(health.map((entry) => [entry.pluginId, entry.health]));
+        return {
+            pluginCount: plugins.length,
+            enabledPluginCount: plugins.filter((plugin) => this.registry.isEnabled(plugin.manifest.id)).length,
+            plugins: plugins.map((plugin) => ({
+                pluginId: plugin.manifest.id,
+                enabled: this.registry.isEnabled(plugin.manifest.id),
+                manifest: plugin.manifest,
+                health: healthByPlugin.get(plugin.manifest.id) || { status: 'healthy' },
+            })),
+        };
+    }
+}
+exports.LocalCoreDiagnostics = LocalCoreDiagnostics;

package/dist-electron/services/local-ai-core/src/kernel/event-bus.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalCoreEventBus = void 0;
+class LocalCoreEventBus {
+    listeners = new Map();
+    emit(event) {
+        const listeners = this.listeners.get(event.type);
+        if (!listeners) {
+            return;
+        }
+        for (const listener of listeners) {
+            listener(event.payload);
+        }
+    }
+    on(type, listener) {
+        const listeners = this.listeners.get(type) || new Set();
+        listeners.add(listener);
+        this.listeners.set(type, listeners);
+        return () => {
+            listeners.delete(listener);
+            if (!listeners.size) {
+                this.listeners.delete(type);
+            }
+        };
+    }
+}
+exports.LocalCoreEventBus = LocalCoreEventBus;

package/dist-electron/services/local-ai-core/src/kernel/lifecycle-manager.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalCoreLifecycleManager = void 0;
+class LocalCoreLifecycleManager {
+    registry;
+    context;
+    initialized = false;
+    started = false;
+    constructor(registry, context) {
+        this.registry = registry;
+        this.context = context;
+    }
+    async initAll() {
+        if (this.initialized) {
+            return;
+        }
+        for (const plugin of this.registry.listEnabled()) {
+            try {
+                await plugin.init?.(this.context);
+            }
+            catch (error) {
+                this.context.logger.log(`[plugin:${plugin.manifest.id}] init failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        this.initialized = true;
+    }
+    async startAll() {
+        if (this.started) {
+            return;
+        }
+        await this.initAll();
+        for (const plugin of this.registry.listEnabled()) {
+            try {
+                await plugin.start?.();
+            }
+            catch (error) {
+                this.context.logger.log(`[plugin:${plugin.manifest.id}] start failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        this.started = true;
+    }
+    async stopAll() {
+        if (!this.initialized) {
+            return;
+        }
+        const plugins = this.registry.listEnabled().slice().reverse();
+        for (const plugin of plugins) {
+            try {
+                await plugin.stop?.();
+            }
+            catch (error) {
+                this.context.logger.log(`[plugin:${plugin.manifest.id}] stop failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        this.started = false;
+    }
+    async healthCheckAll() {
+        const results = [];
+        for (const plugin of this.registry.list()) {
+            if (!this.registry.isEnabled(plugin.manifest.id)) {
+                results.push({
+                    pluginId: plugin.manifest.id,
+                    health: { status: 'degraded', summary: 'Plugin is disabled by runtime settings.' },
+                });
+                continue;
+            }
+            let health;
+            try {
+                health = await plugin.healthCheck?.() || { status: 'healthy' };
+            }
+            catch (error) {
+                health = {
+                    status: 'failed',
+                    summary: error instanceof Error ? error.message : String(error),
+                };
+            }
+            results.push({
+                pluginId: plugin.manifest.id,
+                health,
+            });
+        }
+        return results;
+    }
+}
+exports.LocalCoreLifecycleManager = LocalCoreLifecycleManager;

package/dist-electron/services/local-ai-core/src/kernel/plugin-registry.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalCorePluginRegistry = void 0;
+class LocalCorePluginRegistry {
+    plugins = new Map();
+    disabledPluginIds = new Set();
+    registrationOrder = new Map();
+    nextRegistrationOrder = 0;
+    constructor(disabledPluginIds = []) {
+        for (const pluginId of disabledPluginIds) {
+            this.disabledPluginIds.add(pluginId);
+        }
+    }
+    register(plugin) {
+        if (this.plugins.has(plugin.manifest.id)) {
+            throw new Error(`Plugin already registered: ${plugin.manifest.id}`);
+        }
+        this.plugins.set(plugin.manifest.id, plugin);
+        this.registrationOrder.set(plugin.manifest.id, this.nextRegistrationOrder++);
+    }
+    get(pluginId) {
+        return this.plugins.get(pluginId) || null;
+    }
+    list() {
+        const sorted = [];
+        const visiting = new Set();
+        const visited = new Set();
+        const visit = (plugin) => {
+            const pluginId = plugin.manifest.id;
+            if (visited.has(pluginId)) {
+                return;
+            }
+            if (visiting.has(pluginId)) {
+                throw new Error(`Plugin dependency cycle detected at: ${pluginId}`);
+            }
+            visiting.add(pluginId);
+            for (const dependencyId of plugin.manifest.dependsOn || []) {
+                const dependency = this.plugins.get(dependencyId);
+                if (!dependency) {
+                    throw new Error(`Plugin dependency missing: ${pluginId} depends on ${dependencyId}`);
+                }
+                visit(dependency);
+            }
+            visiting.delete(pluginId);
+            visited.add(pluginId);
+            sorted.push(plugin);
+        };
+        for (const plugin of [...this.plugins.values()].sort((a, b) => (this.registrationOrder.get(a.manifest.id) ?? 0) - (this.registrationOrder.get(b.manifest.id) ?? 0))) {
+            visit(plugin);
+        }
+        return sorted;
+    }
+    isEnabled(pluginId) {
+        return !this.disabledPluginIds.has(pluginId);
+    }
+    listEnabled() {
+        return this.list().filter((plugin) => this.isEnabled(plugin.manifest.id));
+    }
+}
+exports.LocalCorePluginRegistry = LocalCorePluginRegistry;

package/dist-electron/services/local-ai-core/src/plugins/builtin/agent-localcore-acp-plugin.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuiltinLocalCoreAcpAgentPlugin = createBuiltinLocalCoreAcpAgentPlugin;
+exports.createBuiltinOpencodeAgentPlugin = createBuiltinOpencodeAgentPlugin;
+exports.createBuiltinClaudeCodeAgentPlugin = createBuiltinClaudeCodeAgentPlugin;
+exports.createBuiltinStaticAgentCapabilityPlugin = createBuiltinStaticAgentCapabilityPlugin;
+const desktop_js_1 = require("../../../../../shared/desktop.js");
+const workspace_route_config_js_1 = require("../../router/workspace-route-config.js");
+function createRuntime(agentType, match) {
+    return {
+        agentType,
+        transport: desktop_js_1.LOCALCORE_ACP_AGENT_TYPE,
+        displayName: agentType,
+        matchesProject(project) {
+            const normalizedAgentType = String(project.agent?.type || '').trim().toLowerCase();
+            return match(normalizedAgentType);
+        },
+        createRoute(configState, project) {
+            if (!this.matchesProject(project)) {
+                return null;
+            }
+            return {
+                kind: desktop_js_1.LOCALCORE_ACP_AGENT_TYPE,
+                agentType,
+                transport: desktop_js_1.LOCALCORE_ACP_AGENT_TYPE,
+                config: {
+                    ...(0, workspace_route_config_js_1.toLocalCoreProjectConfig)(configState, project),
+                    agentType,
+                },
+                supportsStreamingProbe: true,
+            };
+        },
+    };
+}
+function createBuiltinAgentPlugin(options) {
+    let runtime = null;
+    return {
+        manifest: {
+            id: options.pluginId,
+            kind: 'agent',
+            version: '0.1.0',
+            provides: [`agent:${options.agentType}`],
+        },
+        capabilities: {
+            agents: [
+                {
+                    id: `agent.${options.agentType}`,
+                    agentType: options.agentType,
+                    displayName: options.displayName || options.agentType,
+                },
+            ],
+        },
+        createRuntime(_ctx) {
+            if (!runtime) {
+                runtime = createRuntime(options.agentType, options.match);
+            }
+            return { runtime };
+        },
+    };
+}
+function createBuiltinLocalCoreAcpAgentPlugin() {
+    const plugin = createBuiltinAgentPlugin({
+        pluginId: 'builtin.agent-localcore-acp',
+        agentType: desktop_js_1.LOCALCORE_ACP_AGENT_TYPE,
+        match: (normalizedAgentType) => !normalizedAgentType || normalizedAgentType === 'acp' || normalizedAgentType === desktop_js_1.LOCALCORE_ACP_AGENT_TYPE,
+        displayName: 'LocalCore ACP',
+    });
+    plugin.capabilities = {
+        ...plugin.capabilities,
+        channels: [
+            {
+                id: `channel.${desktop_js_1.LOCALCORE_ACP_AGENT_TYPE}`,
+                platform: desktop_js_1.LOCALCORE_ACP_AGENT_TYPE,
+                displayName: 'LocalCore ACP',
+            },
+        ],
+    };
+    return plugin;
+}
+function createBuiltinOpencodeAgentPlugin() {
+    return createBuiltinAgentPlugin({
+        pluginId: 'builtin.agent-opencode',
+        agentType: 'opencode',
+        match: (normalizedAgentType) => normalizedAgentType === 'opencode',
+        displayName: 'OpenCode',
+    });
+}
+function createBuiltinClaudeCodeAgentPlugin() {
+    return createBuiltinAgentPlugin({
+        pluginId: 'builtin.agent-claudecode',
+        agentType: 'claudecode',
+        match: (normalizedAgentType) => normalizedAgentType === 'claudecode',
+        displayName: 'Claude Code',
+    });
+}
+function createBuiltinStaticAgentCapabilityPlugin(agentType) {
+    return {
+        manifest: {
+            id: `builtin.agent-${agentType}`,
+            kind: 'agent',
+            version: '0.1.0',
+            provides: [`agent:${agentType}`],
+        },
+        capabilities: {
+            agents: [
+                {
+                    id: `agent.${agentType}`,
+                    agentType,
+                    displayName: agentType,
+                },
+            ],
+        },
+    };
+}