@kafca/agentdock 0.1.30 → 0.1.33

package/dist-electron/services/local-ai-core/src/agents/hermes/definition.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hermesAgentDefinition = void 0;
+const behavior_js_1 = require("./behavior.js");
+exports.hermesAgentDefinition = {
+    agentType: 'hermes',
+    displayName: 'Hermes',
+    behavior: behavior_js_1.hermesAcpBehavior,
+    detection: {
+        commandCandidates: ['hermes'],
+        versionArgs: ['--version'],
+    },
+    buildLaunchConfig() {
+        return {
+            command: 'hermes',
+            args: ['acp'],
+            env: {
+                HERMES_YOLO_MODE: '1',
+            },
+        };
+    },
+};

package/dist-electron/services/local-ai-core/src/agents/hermes/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hermesAgentDefinition = exports.hermesAcpBehavior = void 0;
+exports.createBuiltinHermesAgentPlugin = createBuiltinHermesAgentPlugin;
+const agent_plugin_js_1 = require("../shared/agent-plugin.js");
+const behavior_js_1 = require("./behavior.js");
+Object.defineProperty(exports, "hermesAcpBehavior", { enumerable: true, get: function () { return behavior_js_1.hermesAcpBehavior; } });
+const definition_js_1 = require("./definition.js");
+Object.defineProperty(exports, "hermesAgentDefinition", { enumerable: true, get: function () { return definition_js_1.hermesAgentDefinition; } });
+function createBuiltinHermesAgentPlugin() {
+    return (0, agent_plugin_js_1.createBuiltinAgentPlugin)({
+        definition: definition_js_1.hermesAgentDefinition,
+        match: (normalizedAgentType) => normalizedAgentType === 'hermes',
+    });
+}

package/dist-electron/services/local-ai-core/src/agents/index.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuiltinPiAgentPlugin = exports.createBuiltinOpencodeAgentPlugin = exports.createBuiltinLocalCoreAcpAgentPlugin = exports.createBuiltinHermesAgentPlugin = exports.createBuiltinClaudeCodeAgentPlugin = exports.createBuiltinCodexAgentPlugin = void 0;
+exports.getAgentRuntimeDefinitions = getAgentRuntimeDefinitions;
+exports.getStaticAgentRuntimeDefinitions = getStaticAgentRuntimeDefinitions;
+exports.resolveAgentRuntimeDefinition = resolveAgentRuntimeDefinition;
+exports.resolveAgentAcpBehavior = resolveAgentAcpBehavior;
+exports.createBuiltinStaticAgentCapabilityPlugin = createBuiltinStaticAgentCapabilityPlugin;
+const acp_behavior_js_1 = require("./shared/acp-behavior.js");
+const definition_js_1 = require("./shared/definition.js");
+const index_js_1 = require("./codex/index.js");
+const index_js_2 = require("./claudecode/index.js");
+const index_js_3 = require("./hermes/index.js");
+const index_js_4 = require("./localcore-acp/index.js");
+const index_js_5 = require("./opencode/index.js");
+const index_js_6 = require("./pi/index.js");
+const STATIC_AGENT_DEFINITIONS = [
+    {
+        agentType: 'cursor',
+        displayName: 'Cursor',
+        behavior: acp_behavior_js_1.standardAcpBehavior,
+        detection: { commandCandidates: ['cursor-agent', 'cursor'], versionArgs: ['--version'] },
+    },
+    {
+        agentType: 'gemini',
+        displayName: 'Gemini',
+        behavior: acp_behavior_js_1.standardAcpBehavior,
+        detection: { commandCandidates: ['gemini'], versionArgs: ['--version'] },
+    },
+    {
+        agentType: 'qoder',
+        displayName: 'Qoder',
+        behavior: acp_behavior_js_1.standardAcpBehavior,
+        detection: { commandCandidates: ['qoder'], versionArgs: ['--version'] },
+    },
+    {
+        agentType: 'iflow',
+        displayName: 'iFlow',
+        behavior: acp_behavior_js_1.standardAcpBehavior,
+        detection: { commandCandidates: ['iflow'], versionArgs: ['--version'] },
+    },
+];
+const AGENT_RUNTIME_DEFINITIONS = [
+    index_js_6.piAgentDefinition,
+    index_js_5.opencodeAgentDefinition,
+    index_js_1.codexAgentDefinition,
+    index_js_2.claudeCodeAgentDefinition,
+    index_js_3.hermesAgentDefinition,
+    index_js_4.localCoreAcpAgentDefinition,
+    ...STATIC_AGENT_DEFINITIONS,
+];
+const AGENT_RUNTIME_DEFINITIONS_BY_TYPE = new Map(AGENT_RUNTIME_DEFINITIONS.map((definition) => [definition.agentType, definition]));
+function getAgentRuntimeDefinitions() {
+    return [...AGENT_RUNTIME_DEFINITIONS];
+}
+function getStaticAgentRuntimeDefinitions() {
+    return [...STATIC_AGENT_DEFINITIONS];
+}
+function resolveAgentRuntimeDefinition(agentType) {
+    const normalized = (0, definition_js_1.normalizeAgentType)(agentType);
+    return AGENT_RUNTIME_DEFINITIONS_BY_TYPE.get(normalized)
+        || AGENT_RUNTIME_DEFINITIONS.find((definition) => (0, definition_js_1.agentDefinitionMatches)(definition, normalized))
+        || null;
+}
+function resolveAgentAcpBehavior(agentType) {
+    return resolveAgentRuntimeDefinition(agentType)?.behavior || acp_behavior_js_1.standardAcpBehavior;
+}
+function createBuiltinStaticAgentCapabilityPlugin(agentType, displayName = agentType) {
+    return {
+        manifest: {
+            id: `builtin.agent-${agentType}`,
+            kind: 'agent',
+            version: '0.1.0',
+            provides: [`agent:${agentType}`],
+        },
+        capabilities: {
+            agents: [
+                {
+                    id: `agent.${agentType}`,
+                    agentType,
+                    displayName,
+                },
+            ],
+        },
+    };
+}
+var index_js_7 = require("./codex/index.js");
+Object.defineProperty(exports, "createBuiltinCodexAgentPlugin", { enumerable: true, get: function () { return index_js_7.createBuiltinCodexAgentPlugin; } });
+var index_js_8 = require("./claudecode/index.js");
+Object.defineProperty(exports, "createBuiltinClaudeCodeAgentPlugin", { enumerable: true, get: function () { return index_js_8.createBuiltinClaudeCodeAgentPlugin; } });
+var index_js_9 = require("./hermes/index.js");
+Object.defineProperty(exports, "createBuiltinHermesAgentPlugin", { enumerable: true, get: function () { return index_js_9.createBuiltinHermesAgentPlugin; } });
+var index_js_10 = require("./localcore-acp/index.js");
+Object.defineProperty(exports, "createBuiltinLocalCoreAcpAgentPlugin", { enumerable: true, get: function () { return index_js_10.createBuiltinLocalCoreAcpAgentPlugin; } });
+var index_js_11 = require("./opencode/index.js");
+Object.defineProperty(exports, "createBuiltinOpencodeAgentPlugin", { enumerable: true, get: function () { return index_js_11.createBuiltinOpencodeAgentPlugin; } });
+var index_js_12 = require("./pi/index.js");
+Object.defineProperty(exports, "createBuiltinPiAgentPlugin", { enumerable: true, get: function () { return index_js_12.createBuiltinPiAgentPlugin; } });

package/dist-electron/services/local-ai-core/src/agents/localcore-acp/behavior.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localCoreAcpBehavior = void 0;
+const acp_behavior_js_1 = require("../shared/acp-behavior.js");
+exports.localCoreAcpBehavior = acp_behavior_js_1.standardAcpBehavior;

package/dist-electron/services/local-ai-core/src/agents/localcore-acp/definition.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localCoreAcpAgentDefinition = void 0;
+const desktop_js_1 = require("../../../../../shared/desktop.js");
+const behavior_js_1 = require("./behavior.js");
+exports.localCoreAcpAgentDefinition = {
+    agentType: desktop_js_1.LOCALCORE_ACP_AGENT_TYPE,
+    aliases: ['acp', ''],
+    displayName: 'LocalCore ACP',
+    behavior: behavior_js_1.localCoreAcpBehavior,
+    detection: {
+        builtin: true,
+    },
+};

package/dist-electron/services/local-ai-core/src/agents/localcore-acp/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localCoreAcpAgentDefinition = exports.localCoreAcpBehavior = void 0;
+exports.createBuiltinLocalCoreAcpAgentPlugin = createBuiltinLocalCoreAcpAgentPlugin;
+const desktop_js_1 = require("../../../../../shared/desktop.js");
+const agent_plugin_js_1 = require("../shared/agent-plugin.js");
+const behavior_js_1 = require("./behavior.js");
+Object.defineProperty(exports, "localCoreAcpBehavior", { enumerable: true, get: function () { return behavior_js_1.localCoreAcpBehavior; } });
+const definition_js_1 = require("./definition.js");
+Object.defineProperty(exports, "localCoreAcpAgentDefinition", { enumerable: true, get: function () { return definition_js_1.localCoreAcpAgentDefinition; } });
+function createBuiltinLocalCoreAcpAgentPlugin() {
+    const plugin = (0, agent_plugin_js_1.createBuiltinAgentPlugin)({
+        definition: definition_js_1.localCoreAcpAgentDefinition,
+        match: (normalizedAgentType) => !normalizedAgentType || normalizedAgentType === 'acp' || normalizedAgentType === desktop_js_1.LOCALCORE_ACP_AGENT_TYPE,
+    });
+    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;
+}

package/dist-electron/services/local-ai-core/src/agents/opencode/behavior.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opencodeAcpBehavior = void 0;
+const acp_behavior_js_1 = require("../shared/acp-behavior.js");
+exports.opencodeAcpBehavior = acp_behavior_js_1.standardAcpBehavior;

package/dist-electron/services/local-ai-core/src/agents/opencode/definition.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opencodeAgentDefinition = void 0;
+const behavior_js_1 = require("./behavior.js");
+const launch_js_1 = require("./launch.js");
+exports.opencodeAgentDefinition = {
+    agentType: 'opencode',
+    displayName: 'OpenCode',
+    behavior: behavior_js_1.opencodeAcpBehavior,
+    detection: {
+        commandCandidates: ['opencode'],
+        versionArgs: ['--version'],
+    },
+    resolveModel: launch_js_1.resolveOpencodeModel,
+    buildLaunchConfig(input) {
+        return (0, launch_js_1.buildOpencodeLaunchConfig)(input.model, input.providers);
+    },
+};

package/dist-electron/services/local-ai-core/src/agents/opencode/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opencodeAgentDefinition = exports.opencodeAcpBehavior = void 0;
+exports.createBuiltinOpencodeAgentPlugin = createBuiltinOpencodeAgentPlugin;
+const agent_plugin_js_1 = require("../shared/agent-plugin.js");
+const behavior_js_1 = require("./behavior.js");
+Object.defineProperty(exports, "opencodeAcpBehavior", { enumerable: true, get: function () { return behavior_js_1.opencodeAcpBehavior; } });
+const definition_js_1 = require("./definition.js");
+Object.defineProperty(exports, "opencodeAgentDefinition", { enumerable: true, get: function () { return definition_js_1.opencodeAgentDefinition; } });
+function createBuiltinOpencodeAgentPlugin() {
+    return (0, agent_plugin_js_1.createBuiltinAgentPlugin)({
+        definition: definition_js_1.opencodeAgentDefinition,
+        match: (normalizedAgentType) => normalizedAgentType === 'opencode',
+    });
+}

package/dist-electron/services/local-ai-core/src/agents/opencode/launch.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveOpencodeModel = resolveOpencodeModel;
+exports.buildOpencodeLaunchConfig = buildOpencodeLaunchConfig;
+const desktop_js_1 = require("../../../../../shared/desktop.js");
+const launch_utils_js_1 = require("../shared/launch-utils.js");
+function resolveOpencodeModel(input) {
+    const configuredProviderModel = getFirstProviderModelRef(input.providers);
+    if (configuredProviderModel &&
+        (!input.rawModel || input.normalizedModel === desktop_js_1.DEFAULT_DESKTOP_OPENCODE_MODEL)) {
+        return configuredProviderModel;
+    }
+    return input.normalizedModel;
+}
+function buildOpencodeLaunchConfig(model, providers) {
+    const inlineConfig = buildOpencodeInlineConfig(model, providers);
+    return {
+        command: 'opencode',
+        args: ['acp'],
+        env: {
+            ...(inlineConfig.env || {}),
+            OPENCODE_CONFIG_CONTENT: JSON.stringify(inlineConfig.config || { $schema: 'https://opencode.ai/config.json' }),
+        },
+    };
+}
+function getFirstProviderModelRef(providers) {
+    for (const provider of providers) {
+        const providerId = normalizeOpencodeProviderId(provider.name);
+        const modelId = (0, launch_utils_js_1.getProviderDefaultModelId)(provider);
+        if (providerId && modelId) {
+            return `${providerId}/${modelId}`;
+        }
+    }
+    return '';
+}
+function buildOpencodeInlineConfig(model, providers) {
+    const config = {
+        $schema: 'https://opencode.ai/config.json',
+    };
+    const env = {};
+    if (model) {
+        config.model = model;
+    }
+    const providerConfig = {};
+    for (const provider of providers) {
+        const providerId = normalizeOpencodeProviderId(provider.name);
+        if (!providerId) {
+            continue;
+        }
+        const entry = {
+            name: String(provider.name || providerId),
+        };
+        if (shouldUseOpenAiCompatibleProvider(providerId)) {
+            entry.npm = '@ai-sdk/openai-compatible';
+        }
+        const options = {};
+        const baseUrl = String(provider.base_url || '').trim();
+        if (baseUrl) {
+            options.baseURL = baseUrl;
+        }
+        const apiKey = String(provider.api_key || '').trim();
+        if (apiKey) {
+            const envName = opencodeProviderApiKeyEnvName(providerId);
+            env[envName] = apiKey;
+            options.apiKey = `{env:${envName}}`;
+        }
+        if (Object.keys(options).length > 0) {
+            entry.options = options;
+        }
+        const models = buildOpencodeProviderModels(provider);
+        if (Object.keys(models).length > 0) {
+            entry.models = models;
+        }
+        providerConfig[providerId] = entry;
+    }
+    if (Object.keys(providerConfig).length > 0) {
+        config.provider = providerConfig;
+    }
+    return {
+        config,
+        env,
+    };
+}
+function buildOpencodeProviderModels(provider) {
+    const models = {};
+    const addModel = (model, alias) => {
+        const modelId = String(model || '').trim();
+        if (!modelId || models[modelId]) {
+            return;
+        }
+        models[modelId] = {
+            name: String(alias || modelId).trim() || modelId,
+        };
+    };
+    addModel(provider.model);
+    for (const model of Array.isArray(provider.models) ? provider.models : []) {
+        addModel(model?.model, model?.alias);
+    }
+    return models;
+}
+function normalizeOpencodeProviderId(value) {
+    return String(value || '')
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+function opencodeProviderApiKeyEnvName(providerId) {
+    const suffix = providerId.toUpperCase().replace(/[^A-Z0-9]+/g, '_').replace(/^_+|_+$/g, '');
+    return `AI_WORKSTATION_OPENCODE_${suffix || 'PROVIDER'}_API_KEY`;
+}
+function shouldUseOpenAiCompatibleProvider(providerId) {
+    const builtInNonCompatibleProviders = new Set([
+        'anthropic',
+        'google',
+        'gemini',
+    ]);
+    return !builtInNonCompatibleProviders.has(providerId);
+}

package/dist-electron/services/local-ai-core/src/agents/pi/behavior.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.piAcpBehavior = void 0;
+const acp_behavior_js_1 = require("../shared/acp-behavior.js");
+exports.piAcpBehavior = acp_behavior_js_1.standardAcpBehavior;

package/dist-electron/services/local-ai-core/src/agents/pi/definition.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.piAgentDefinition = void 0;
+const desktop_js_1 = require("../../../../../shared/desktop.js");
+const behavior_js_1 = require("./behavior.js");
+const launch_js_1 = require("./launch.js");
+exports.piAgentDefinition = {
+    agentType: 'pi',
+    displayName: 'Pi',
+    behavior: behavior_js_1.piAcpBehavior,
+    detection: {
+        commandCandidates: ['pi'],
+        versionArgs: ['--version'],
+        bundledRuntimes: [
+            {
+                packageName: desktop_js_1.DESKTOP_PI_CODING_AGENT_PACKAGE,
+                candidates: ['dist/cli.js'],
+            },
+        ],
+    },
+    resolveModel: launch_js_1.resolvePiModel,
+    buildLaunchConfig: launch_js_1.buildPiLaunchConfig,
+};

package/dist-electron/services/local-ai-core/src/agents/pi/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.piAgentDefinition = exports.piAcpBehavior = void 0;
+exports.createBuiltinPiAgentPlugin = createBuiltinPiAgentPlugin;
+const agent_plugin_js_1 = require("../shared/agent-plugin.js");
+const behavior_js_1 = require("./behavior.js");
+Object.defineProperty(exports, "piAcpBehavior", { enumerable: true, get: function () { return behavior_js_1.piAcpBehavior; } });
+const definition_js_1 = require("./definition.js");
+Object.defineProperty(exports, "piAgentDefinition", { enumerable: true, get: function () { return definition_js_1.piAgentDefinition; } });
+function createBuiltinPiAgentPlugin() {
+    return (0, agent_plugin_js_1.createBuiltinAgentPlugin)({
+        definition: definition_js_1.piAgentDefinition,
+        match: (normalizedAgentType) => normalizedAgentType === 'pi',
+    });
+}

package/dist-electron/services/local-ai-core/src/agents/pi/launch.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePiModel = resolvePiModel;
+exports.buildPiLaunchConfig = buildPiLaunchConfig;
+const node_path_1 = require("node:path");
+const desktop_js_1 = require("../../../../../shared/desktop.js");
+const launch_utils_js_1 = require("../shared/launch-utils.js");
+function resolvePiModel(input) {
+    return input.rawModel || (0, launch_utils_js_1.getFirstProviderModelId)(input.providers);
+}
+function buildPiLaunchConfig(input) {
+    const bundledPiAcp = (0, launch_utils_js_1.resolveBundledAcpCommand)(desktop_js_1.DESKTOP_PI_ACP_PACKAGE, 'pi-acp');
+    const bundledPiCommand = (0, launch_utils_js_1.resolveBundledAcpCommand)(desktop_js_1.DESKTOP_PI_CODING_AGENT_PACKAGE, 'pi').args[0];
+    return {
+        command: bundledPiAcp.command,
+        args: [...bundledPiAcp.args],
+        env: {
+            ...collectPiProviderEnv(input.providers),
+            ...writePiProviderRuntimeConfig(input),
+            PI_ACP_PI_COMMAND: bundledPiCommand,
+        },
+    };
+}
+function collectPiProviderEnv(providers) {
+    const env = {};
+    for (const provider of providers) {
+        const apiKey = String(provider.api_key || '').trim();
+        const envName = piProviderApiKeyEnvName(provider.name);
+        if (apiKey && envName) {
+            env[envName] = apiKey;
+        }
+    }
+    return env;
+}
+function writePiProviderRuntimeConfig(input) {
+    if (input.providers.length === 0) {
+        return {};
+    }
+    const { providerId, modelId } = resolvePiProviderModel(input.providers, input.model);
+    const agentDir = (0, launch_utils_js_1.projectLocalStateDir)(input.configState, '.pi-agent', input.project.name);
+    (0, launch_utils_js_1.ensurePrivateDir)(agentDir);
+    const auth = {};
+    const modelProviders = {};
+    for (const provider of input.providers) {
+        const id = normalizePiProviderId(provider.name);
+        if (!id) {
+            continue;
+        }
+        const apiKey = String(provider.api_key || '').trim();
+        const baseUrl = String(provider.base_url || '').trim();
+        if (apiKey) {
+            auth[id] = { type: 'api_key', key: apiKey };
+        }
+        if (baseUrl || apiKey) {
+            modelProviders[id] = {
+                name: String(provider.name || id).trim() || id,
+                ...(baseUrl ? { baseUrl } : {}),
+                ...(apiKey ? { apiKey } : {}),
+            };
+        }
+    }
+    (0, launch_utils_js_1.writeJsonFile)((0, node_path_1.resolve)(agentDir, 'auth.json'), auth);
+    (0, launch_utils_js_1.writeJsonFile)((0, node_path_1.resolve)(agentDir, 'models.json'), { providers: modelProviders });
+    (0, launch_utils_js_1.writeJsonFile)((0, node_path_1.resolve)(agentDir, 'settings.json'), {
+        ...(providerId ? { defaultProvider: providerId } : {}),
+        ...(modelId ? { defaultModel: modelId } : {}),
+        quietStartup: true,
+    }, 0o644);
+    return {
+        PI_CODING_AGENT_DIR: agentDir,
+    };
+}
+function resolvePiProviderModel(providers, model) {
+    const [explicitProvider, explicitModel] = (0, launch_utils_js_1.splitProviderModelRef)(model);
+    if (explicitProvider && explicitModel) {
+        return {
+            providerId: normalizePiProviderId(explicitProvider),
+            modelId: explicitModel,
+        };
+    }
+    for (const provider of providers) {
+        const providerId = normalizePiProviderId(provider.name);
+        const modelId = (0, launch_utils_js_1.getProviderDefaultModelId)(provider);
+        if (providerId && modelId && (!model || model === modelId)) {
+            return { providerId, modelId };
+        }
+    }
+    const fallbackProvider = providers.find((provider) => normalizePiProviderId(provider.name));
+    return {
+        providerId: normalizePiProviderId(fallbackProvider?.name),
+        modelId: model,
+    };
+}
+function normalizePiProviderId(providerName) {
+    const providerId = (0, launch_utils_js_1.normalizeProviderId)(providerName);
+    const aliases = {
+        google: 'google',
+        gemini: 'google',
+        kimi: 'kimi-coding',
+        moonshot: 'moonshotai',
+        zhipuai: 'zai',
+    };
+    return aliases[providerId] || providerId;
+}
+function piProviderApiKeyEnvName(providerName) {
+    const providerId = (0, launch_utils_js_1.normalizeProviderId)(providerName);
+    const envNames = {
+        anthropic: 'ANTHROPIC_API_KEY',
+        'azure-openai': 'AZURE_OPENAI_API_KEY',
+        'azure-openai-responses': 'AZURE_OPENAI_API_KEY',
+        cerebras: 'CEREBRAS_API_KEY',
+        cloudflare: 'CLOUDFLARE_API_KEY',
+        'cloudflare-ai-gateway': 'CLOUDFLARE_API_KEY',
+        'cloudflare-workers-ai': 'CLOUDFLARE_API_KEY',
+        deepseek: 'DEEPSEEK_API_KEY',
+        fireworks: 'FIREWORKS_API_KEY',
+        gemini: 'GEMINI_API_KEY',
+        google: 'GEMINI_API_KEY',
+        groq: 'GROQ_API_KEY',
+        huggingface: 'HF_TOKEN',
+        kimi: 'KIMI_API_KEY',
+        'kimi-coding': 'KIMI_API_KEY',
+        minimax: 'MINIMAX_API_KEY',
+        'minimax-cn': 'MINIMAX_CN_API_KEY',
+        mistral: 'MISTRAL_API_KEY',
+        moonshot: 'KIMI_API_KEY',
+        openai: 'OPENAI_API_KEY',
+        opencode: 'OPENCODE_API_KEY',
+        'opencode-go': 'OPENCODE_API_KEY',
+        openrouter: 'OPENROUTER_API_KEY',
+        siliconflow: 'SILICONFLOW_API_KEY',
+        vercel: 'AI_GATEWAY_API_KEY',
+        'vercel-ai-gateway': 'AI_GATEWAY_API_KEY',
+        xai: 'XAI_API_KEY',
+        zai: 'ZAI_API_KEY',
+        zhipuai: 'ZAI_API_KEY',
+    };
+    return envNames[providerId] || '';
+}

package/dist-electron/services/local-ai-core/src/agents/shared/acp-behavior.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.standardAcpBehavior = void 0;
+exports.standardAcpBehavior = {
+    normalizeAssistantText(input) {
+        return input.rawText;
+    },
+    normalizeFinalAssistantText(input) {
+        return input.rawText;
+    },
+};

package/dist-electron/services/local-ai-core/src/agents/shared/agent-plugin.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuiltinAgentPlugin = createBuiltinAgentPlugin;
+const desktop_js_1 = require("../../../../../shared/desktop.js");
+const workspace_route_config_js_1 = require("../../router/workspace-route-config.js");
+function createRuntime(agentType, match, displayName) {
+    return {
+        agentType,
+        transport: desktop_js_1.LOCALCORE_ACP_AGENT_TYPE,
+        displayName: 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) {
+    const agentType = options.definition?.agentType || options.agentType || '';
+    const displayName = options.definition?.displayName || options.displayName || agentType;
+    const pluginId = options.pluginId || `builtin.agent-${agentType}`;
+    let runtime = null;
+    return {
+        manifest: {
+            id: pluginId,
+            kind: 'agent',
+            version: '0.1.0',
+            provides: [`agent:${agentType}`],
+        },
+        capabilities: {
+            agents: [
+                {
+                    id: `agent.${agentType}`,
+                    agentType,
+                    displayName,
+                },
+            ],
+        },
+        createRuntime(_ctx) {
+            if (!runtime) {
+                runtime = createRuntime(agentType, options.match, displayName);
+            }
+            return { runtime };
+        },
+    };
+}

package/dist-electron/services/local-ai-core/src/agents/shared/definition.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeAgentType = normalizeAgentType;
+exports.agentDefinitionMatches = agentDefinitionMatches;
+function normalizeAgentType(value) {
+    return String(value || '').trim().toLowerCase();
+}
+function agentDefinitionMatches(definition, agentType) {
+    const normalized = normalizeAgentType(agentType);
+    return normalized === definition.agentType
+        || Boolean(definition.aliases?.some((alias) => normalizeAgentType(alias) === normalized));
+}