@kafca/agentdock 0.1.29 → 0.1.31

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));
+}

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

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProviderDefaultModelId = getProviderDefaultModelId;
+exports.getFirstProviderModelId = getFirstProviderModelId;
+exports.collectProviderEnv = collectProviderEnv;
+exports.normalizeProviderId = normalizeProviderId;
+exports.splitProviderModelRef = splitProviderModelRef;
+exports.ensurePrivateDir = ensurePrivateDir;
+exports.writeJsonFile = writeJsonFile;
+exports.projectLocalStateDir = projectLocalStateDir;
+exports.resolveBundledAcpCommand = resolveBundledAcpCommand;
+exports.resolveBundledPackageJsonPath = resolveBundledPackageJsonPath;
+const node_module_1 = require("node:module");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+function getProviderDefaultModelId(provider) {
+    const directModel = String(provider.model || '').trim();
+    if (directModel) {
+        return directModel;
+    }
+    const firstModel = Array.isArray(provider.models)
+        ? provider.models.find((entry) => String(entry?.model || '').trim())
+        : null;
+    return String(firstModel?.model || '').trim();
+}
+function getFirstProviderModelId(providers) {
+    for (const provider of providers) {
+        const modelId = getProviderDefaultModelId(provider);
+        if (modelId) {
+            return modelId;
+        }
+    }
+    return '';
+}
+function collectProviderEnv(providers) {
+    const env = {};
+    for (const provider of providers) {
+        if (!provider.env || typeof provider.env !== 'object') {
+            continue;
+        }
+        for (const [key, value] of Object.entries(provider.env)) {
+            const envKey = key.trim();
+            if (envKey) {
+                env[envKey] = String(value ?? '');
+            }
+        }
+    }
+    return env;
+}
+function normalizeProviderId(value) {
+    return String(value || '')
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+function splitProviderModelRef(value) {
+    const trimmed = value.trim();
+    const slashIndex = trimmed.indexOf('/');
+    if (slashIndex <= 0 || slashIndex >= trimmed.length - 1) {
+        return ['', trimmed];
+    }
+    return [trimmed.slice(0, slashIndex), trimmed.slice(slashIndex + 1)];
+}
+function ensurePrivateDir(path) {
+    (0, node_fs_1.mkdirSync)(path, { recursive: true, mode: 0o700 });
+    (0, node_fs_1.chmodSync)(path, 0o700);
+}
+function writeJsonFile(path, value, mode = 0o600) {
+    (0, node_fs_1.writeFileSync)(path, `${JSON.stringify(value, null, 2)}\n`, { encoding: 'utf8', mode });
+    (0, node_fs_1.chmodSync)(path, mode);
+}
+function projectLocalStateDir(configState, folderName, projectName) {
+    const configDir = (0, node_path_1.dirname)(configState.path);
+    const safeProjectName = String(projectName || 'workspace')
+        .trim()
+        .replace(/[^a-zA-Z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '') || 'workspace';
+    return (0, node_path_1.resolve)(configDir, folderName, safeProjectName);
+}
+function resolveBundledAcpCommand(packageName, binName) {
+    const require = (0, node_module_1.createRequire)(__filename);
+    const packageJsonPath = resolveBundledPackageJsonPath(packageName);
+    const packageJson = require(packageJsonPath);
+    const binField = packageJson.bin;
+    const relativeBinPath = typeof binField === 'string'
+        ? binField
+        : binField?.[binName];
+    if (!relativeBinPath) {
+        throw new Error(`Bundled package "${packageName}" does not declare the ${binName} bin.`);
+    }
+    return {
+        command: process.execPath,
+        args: [(0, node_path_1.resolve)((0, node_path_1.dirname)(packageJsonPath), relativeBinPath)],
+    };
+}
+function resolveBundledPackageJsonPath(packageName) {
+    const require = (0, node_module_1.createRequire)(__filename);
+    try {
+        return require.resolve(`${packageName}/package.json`);
+    }
+    catch (error) {
+        if (error?.code !== 'ERR_PACKAGE_PATH_NOT_EXPORTED') {
+            throw error;
+        }
+    }
+    for (const basePath of require.resolve.paths(packageName) || []) {
+        const packageJsonPath = (0, node_path_1.resolve)(basePath, ...packageName.split('/'), 'package.json');
+        if ((0, node_fs_1.existsSync)(packageJsonPath)) {
+            return packageJsonPath;
+        }
+    }
+    let current = (0, node_path_1.dirname)(require.resolve(packageName));
+    while (current && current !== (0, node_path_1.dirname)(current)) {
+        const packageJsonPath = (0, node_path_1.resolve)(current, 'package.json');
+        if ((0, node_fs_1.existsSync)(packageJsonPath)) {
+            return packageJsonPath;
+        }
+        current = (0, node_path_1.dirname)(current);
+    }
+    throw new Error(`Bundled package "${packageName}" package.json could not be resolved.`);
+}

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasPriorProgressMessage = hasPriorProgressMessage;
+function hasPriorProgressMessage(input) {
+    const content = normalizeProgressContent(input.content);
+    if (!content) {
+        return false;
+    }
+    const kind = input.kind;
+    return input.priorProgressMessages.some((message) => {
+        if (kind && message.kind && message.kind !== kind) {
+            return false;
+        }
+        return normalizeProgressContent(message.content) === content;
+    });
+}
+function normalizeProgressContent(content) {
+    return String(content || '').replace(/\r\n/g, '\n').trim();
+}

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripAssistantReplayPrefix = stripAssistantReplayPrefix;
+function stripAssistantReplayPrefix(rawText, priorAssistantMessages) {
+    const replayPrefix = priorAssistantMessages.join('');
+    if (!replayPrefix || !rawText) {
+        return rawText;
+    }
+    if (replayPrefix.startsWith(rawText)) {
+        return '';
+    }
+    if (priorAssistantMessages.some((message) => message.startsWith(rawText))) {
+        return '';
+    }
+    if (rawText.startsWith(replayPrefix)) {
+        return rawText.slice(replayPrefix.length);
+    }
+    const anchoredText = stripAfterLatestPriorMessageAnchor(rawText, priorAssistantMessages);
+    if (anchoredText !== null) {
+        return anchoredText;
+    }
+    const overlap = longestSuffixPrefixOverlap(replayPrefix, rawText);
+    if (overlap > 0 && overlap === rawText.length) {
+        return '';
+    }
+    return rawText;
+}
+function stripAfterLatestPriorMessageAnchor(rawText, priorAssistantMessages) {
+    let latestMatch = null;
+    for (const message of priorAssistantMessages) {
+        for (const anchor of createPriorMessageAnchors(message)) {
+            const index = rawText.lastIndexOf(anchor);
+            if (index < 0) {
+                continue;
+            }
+            const match = { index, length: anchor.length };
+            if (!latestMatch || match.index + match.length > latestMatch.index + latestMatch.length) {
+                latestMatch = match;
+            }
+        }
+    }
+    if (!latestMatch) {
+        return null;
+    }
+    return rawText.slice(latestMatch.index + latestMatch.length);
+}
+function createPriorMessageAnchors(message) {
+    const trimmed = message.trim();
+    if (trimmed.length < 32) {
+        return [];
+    }
+    const anchors = [];
+    for (const length of [240, 160, 96, 48, 32]) {
+        if (trimmed.length >= length) {
+            anchors.push(trimmed.slice(-length));
+        }
+    }
+    return anchors;
+}
+function longestSuffixPrefixOverlap(prefix, value) {
+    const max = Math.min(prefix.length, value.length);
+    for (let size = max; size > 0; size -= 1) {
+        if (prefix.endsWith(value.slice(0, size))) {
+            return size;
+        }
+    }
+    return 0;
+}

package/dist-electron/services/local-ai-core/src/channel/lark/local-core-lark-gateway.js

@@ -395,7 +395,6 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
         const sessionKey = event.sessionKey;
         const route = this.threadRouting.get(sessionKey);
         if (!route) {
-            this.options.log?.(`localcore-lark bridge route miss for sessionKey=${sessionKey} type=${event.type}`);
             return;
         }
         const routeInstanceId = route.instanceId || 'default';
@@ -481,7 +480,6 @@ class LocalCoreLarkGateway extends node_events_1.EventEmitter {
                     const shouldThrottle = event.type === 'update_message' &&
                         existingMessageId &&
                         Date.now() - (turn.lastPatchedAtByMessageId[existingMessageId] || 0) < (renderedMessage.isFinal ? LARK_FINAL_PATCH_INTERVAL_MS : LARK_PROGRESS_PATCH_INTERVAL_MS);
-                    this.options.log?.(`localcore-lark bridge event type=${event.type} sessionKey=${sessionKey} hasMessageId=${Boolean(existingMessageId)} throttle=${shouldThrottle}`);
                     if (shouldThrottle) {
                         continue;
                     }

package/dist-electron/services/local-ai-core/src/channel/lark/runtime-state.js

@@ -188,7 +188,7 @@ function takePendingLarkThoughtRender(turn) {
 }
 function getLarkRenderedMessageId(turn, rendered) {
     if (rendered.isFinal) {
-        return turn.finalMessageId || turn.replyMessageId;
+        return undefined;
     }
     return turn.progressMessageIds[rendered.key];
 }