@kafca/agentdock 0.1.55 → 0.1.57

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

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWeixinTurnState = createWeixinTurnState;
+exports.getOrCreateWeixinTurnState = getOrCreateWeixinTurnState;
+exports.consumeWeixinBridgeEvent = consumeWeixinBridgeEvent;
+exports.renderWeixinTurnText = renderWeixinTurnText;
+exports.isTerminalWeixinBridgeMessage = isTerminalWeixinBridgeMessage;
+function renderBridgeContent(event) {
+    const toolCall = event.toolCall;
+    if (!toolCall) {
+        return String(event.content || '').trim();
+    }
+    const name = String(toolCall.name || '').trim() || 'Tool update';
+    const status = String(toolCall.status || '').trim();
+    if (name === 'Tool update' && status === 'completed')
+        return '';
+    return [name, status].filter(Boolean).join(' - ');
+}
+function bridgeEventKind(event) {
+    return event.bridgeKind || (event.type === 'status' ? 'status' : 'assistant');
+}
+function pushUnique(target, value) {
+    const normalized = value.trim();
+    if (!normalized || target[target.length - 1] === normalized)
+        return;
+    target.push(normalized);
+    if (target.length > 8)
+        target.splice(0, target.length - 8);
+}
+function flushPendingThought(turn) {
+    const text = String(turn.pendingThoughtText || '').trim();
+    if (!text)
+        return;
+    pushUnique(turn.thinkingSteps, text);
+    turn.pendingThoughtText = undefined;
+}
+function createWeixinTurnState(sessionKey) {
+    return {
+        sessionKey,
+        sentCount: 0,
+        foldedProgressCount: 0,
+        awaitingPermission: false,
+        processing: false,
+        previewText: '',
+        finalText: '',
+        thinkingSteps: [],
+        pendingThoughtText: undefined,
+        statusLines: [],
+        buttonRows: [],
+        lastSentAt: 0,
+        lastSentText: '',
+    };
+}
+function getOrCreateWeixinTurnState(turns, sessionKey) {
+    const existing = turns.get(sessionKey);
+    if (existing)
+        return existing;
+    const turn = createWeixinTurnState(sessionKey);
+    turns.set(sessionKey, turn);
+    return turn;
+}
+function consumeWeixinBridgeEvent(turn, event) {
+    const content = renderBridgeContent(event);
+    const bridgeKind = bridgeEventKind(event);
+    if (event.type === 'typing_start') {
+        Object.assign(turn, {
+            processing: true,
+            previewText: '',
+            finalText: '',
+            thinkingSteps: [],
+            pendingThoughtText: undefined,
+            statusLines: [],
+            buttonRows: [],
+        });
+        return;
+    }
+    if (event.type === 'typing_stop') {
+        turn.processing = false;
+        return;
+    }
+    if (event.type === 'preview_start' || event.type === 'update_message') {
+        if (bridgeKind === 'thought') {
+            turn.pendingThoughtText = content;
+        }
+        else {
+            turn.previewText = content;
+        }
+        return;
+    }
+    if (bridgeKind !== 'thought')
+        flushPendingThought(turn);
+    if (event.type === 'status') {
+        if (content) {
+            pushUnique(turn.statusLines, content);
+            turn.finalText = content;
+            turn.previewText = content;
+        }
+        return;
+    }
+    if (event.type === 'buttons') {
+        turn.awaitingPermission = true;
+        turn.buttonRows = Array.isArray(event.buttonRows)
+            ? event.buttonRows
+                .map((row) => Array.isArray(row)
+                ? row.filter((button) => Boolean(button?.text && button?.data))
+                    .map((button) => ({ text: button.text, data: button.data }))
+                : [])
+                .filter((row) => row.length > 0)
+            : [];
+        return;
+    }
+    if (!content)
+        return;
+    if (bridgeKind === 'thought' || bridgeKind === 'plan') {
+        pushUnique(turn.thinkingSteps, content);
+    }
+    else if (bridgeKind === 'tool' || bridgeKind === 'status') {
+        pushUnique(turn.statusLines, content);
+    }
+    else {
+        turn.finalText = content;
+        turn.previewText = content;
+    }
+}
+function renderWeixinTurnText(turn) {
+    const sections = [];
+    if (turn.thinkingSteps.length > 0) {
+        sections.push(`**中间过程**\n${turn.thinkingSteps.map((step) => `• ${step.replace(/\s+/g, ' ').trim()}`).join('\n')}`);
+    }
+    if (turn.finalText) {
+        sections.push(turn.finalText);
+    }
+    else if (turn.previewText) {
+        sections.push(turn.previewText);
+    }
+    else if (turn.statusLines.length > 0) {
+        sections.push(`**处理中**\n${turn.statusLines.slice(-3).map((line) => `• ${line.replace(/\s+/g, ' ').trim()}`).join('\n')}`);
+    }
+    else if (turn.processing) {
+        sections.push('**处理中**\n正在思考...');
+    }
+    if (turn.awaitingPermission) {
+        sections.push('\n回复：`allow` / `allow all` / `deny`');
+    }
+    return sections.join('\n\n').trim();
+}
+function isTerminalWeixinBridgeMessage(event, rendered) {
+    if (event.type === 'buttons')
+        return true;
+    if (event.type !== 'reply')
+        return false;
+    const kind = bridgeEventKind(event);
+    if (kind === 'tool' || kind === 'thought' || kind === 'plan' || kind === 'status')
+        return false;
+    return Boolean(rendered.trim());
+}

package/dist-electron/services/local-ai-core/src/channel/weixin/text-utils.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripWeixinHtml = stripWeixinHtml;
+exports.formatWeixinError = formatWeixinError;
+exports.waitForWeixinRetry = waitForWeixinRetry;
+exports.utf8ByteLength = utf8ByteLength;
+exports.splitTextByUtf8Bytes = splitTextByUtf8Bytes;
+exports.truncateTextByUtf8Bytes = truncateTextByUtf8Bytes;
+function stripWeixinHtml(html) {
+    let result = html;
+    let previous;
+    do {
+        previous = result;
+        result = result.replace(/<[^>]*>/g, '');
+    } while (result !== previous);
+    return result
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&nbsp;/g, ' ');
+}
+function formatWeixinError(error) {
+    if (error instanceof Error) {
+        const cause = error.cause;
+        return cause !== undefined ? `${error.message}: ${String(cause)}` : error.message;
+    }
+    return String(error);
+}
+function waitForWeixinRetry(ms, signal) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(resolve, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(new Error('aborted'));
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}
+function utf8ByteLength(value) {
+    return Buffer.byteLength(value, 'utf-8');
+}
+function splitTextByUtf8Bytes(text, maxBytes) {
+    const normalized = String(text || '').replace(/\r\n/g, '\n').trim();
+    if (!normalized)
+        return [];
+    if (utf8ByteLength(normalized) <= maxBytes)
+        return [normalized];
+    const chunks = [];
+    let current = '';
+    const pushCurrent = () => {
+        const trimmed = current.trim();
+        if (trimmed)
+            chunks.push(trimmed);
+        current = '';
+    };
+    const appendPart = (part) => {
+        if (!part.trim())
+            return;
+        const separator = current ? '\n\n' : '';
+        if (current && utf8ByteLength(`${current}${separator}${part}`) <= maxBytes) {
+            current = `${current}${separator}${part}`;
+            return;
+        }
+        if (current)
+            pushCurrent();
+        if (utf8ByteLength(part) <= maxBytes) {
+            current = part;
+            return;
+        }
+        let segment = '';
+        for (const character of Array.from(part)) {
+            if (segment && utf8ByteLength(`${segment}${character}`) > maxBytes) {
+                chunks.push(segment);
+                segment = '';
+            }
+            segment += character;
+        }
+        current = segment;
+    };
+    for (const part of normalized.split(/\n{2,}/))
+        appendPart(part);
+    pushCurrent();
+    return chunks;
+}
+function truncateTextByUtf8Bytes(text, maxBytes) {
+    const normalized = String(text || '').replace(/\r\n/g, '\n').trim();
+    if (utf8ByteLength(normalized) <= maxBytes)
+        return normalized;
+    const suffix = '\n\n（内容过长，已截断以保证微信送达）';
+    const budget = Math.max(0, maxBytes - utf8ByteLength(suffix));
+    let result = '';
+    for (const character of Array.from(normalized)) {
+        if (utf8ByteLength(`${result}${character}`) > budget)
+            break;
+        result += character;
+    }
+    return `${result.trim()}${suffix}`;
+}

package/dist-electron/services/local-ai-core/src/cli/lac.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCli = runCli;
 const node_process_1 = __importDefault(require("node:process"));
-const index_js_1 = require("../../../../packages/contracts/src/index.js");
+const superai_contracts_1 = require("../../../../packages/contracts/src/index.js");
 const job_id_js_1 = require("../scheduler/job-id.js");
 const scheduled_job_route_js_1 = require("../scheduler/scheduled-job-route.js");
 const monitor_id_js_1 = require("../automation/monitor-id.js");
@@ -148,7 +148,7 @@ async function handleMonitorEdit(monitorId, flags, env, io, json) {
     if (typeof enabled === 'boolean')
         input.enabled = enabled;
     if (executionMode)
-        input.executionMode = (0, index_js_1.normalizeScheduledJobExecutionMode)(executionMode);
+        input.executionMode = (0, superai_contracts_1.normalizeScheduledJobExecutionMode)(executionMode);
     if (cooldown)
         input.cooldownMs = (0, monitor_cli_parsers_js_1.parseDurationMs)(cooldown);
     if (Object.keys(input).length === 0) {
@@ -181,7 +181,7 @@ async function handleChannelSendFile(flags, env, io, json) {
     const context = resolveContext(flags, env);
     const filePath = getRequiredFlag(flags, 'path');
     const rawPlatform = getFlag(flags, 'platform') || context.platform;
-    const platform = rawPlatform ? (0, index_js_1.normalizeChannelPlatform)(rawPlatform) : '';
+    const platform = rawPlatform ? (0, superai_contracts_1.normalizeChannelPlatform)(rawPlatform) : '';
     if (!platform) {
         throw new Error('channel send-file requires a platform. Set LOCAL_AI_PLATFORM or pass --platform.');
     }
@@ -284,7 +284,7 @@ async function handleEdit(jobId, flags, env, io, json) {
         input.enabled = enabled;
     }
     if (executionMode) {
-        input.executionMode = (0, index_js_1.normalizeScheduledJobExecutionMode)(executionMode);
+        input.executionMode = (0, superai_contracts_1.normalizeScheduledJobExecutionMode)(executionMode);
     }
     if (Object.keys(input).length === 0) {
         throw new Error('scheduler edit requires at least one editable field.');
@@ -406,10 +406,10 @@ function normalizeMaybeBooleanFlag(value) {
     return value === 'true' ? '' : value;
 }
 function getExecutionMode(flags) {
-    return (0, index_js_1.normalizeScheduledJobExecutionMode)(getFlag(flags, 'execution-mode'));
+    return (0, superai_contracts_1.normalizeScheduledJobExecutionMode)(getFlag(flags, 'execution-mode'));
 }
 function getMonitorExecutionMode(flags) {
-    return (0, index_js_1.normalizeScheduledJobExecutionMode)(getFlag(flags, 'execution-mode') || 'side-thread');
+    return (0, superai_contracts_1.normalizeScheduledJobExecutionMode)(getFlag(flags, 'execution-mode') || 'side-thread');
 }
 function buildSourceConfig(sourceType, flags) {
     const config = {};

package/dist-electron/services/local-ai-core/src/cli/monitor-cli-parsers.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMonitorCondition = parseMonitorCondition;
 exports.parseDurationMs = parseDurationMs;
-const index_js_1 = require("../../../../packages/contracts/src/index.js");
+const superai_contracts_1 = require("../../../../packages/contracts/src/index.js");
 function parseMonitorCondition(value) {
     const expression = String(value || '').trim();
     if (expression.includes('&&') || expression.includes('||')) {
@@ -21,7 +21,7 @@ function parseMonitorCondition(value) {
     const numeric = Number(rawValue);
     return {
         metric: String(match[1] || '').trim(),
-        operator: (0, index_js_1.normalizeAutomationMonitorConditionOperator)(match[2]),
+        operator: (0, superai_contracts_1.normalizeAutomationMonitorConditionOperator)(match[2]),
         value: Number.isFinite(numeric) && rawValue !== '' ? numeric : rawValue,
     };
 }

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

@@ -28,17 +28,7 @@ function bootstrapLocalCoreKernel(options) {
     };
     const lifecycle = new lifecycle_manager_js_1.LocalCoreLifecycleManager(plugins, context);
     const diagnostics = new diagnostics_js_1.LocalCoreDiagnostics(plugins, lifecycle);
-    for (const plugin of (0, catalog_js_1.createKernelBuiltinPlugins)()) {
-        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`);
-        }
-    }
+    registerPluginSet(plugins, capabilities, context, (0, catalog_js_1.createKernelBuiltinPlugins)());
     return {
         context,
         plugins,
@@ -77,14 +67,19 @@ function bootstrapLocalCoreKernel(options) {
     };
 }
 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`);
+    registerPluginSet(kernel.plugins, kernel.capabilities, kernel.context, [plugin]);
+}
+function registerPluginSet(plugins, capabilities, context, pluginSet) {
+    for (const plugin of pluginSet) {
+        plugins.register(plugin);
+        context.logger.log(`[plugin:${plugin.manifest.id}] registered`);
+        if (plugin.capabilities && plugins.isEnabled(plugin.manifest.id)) {
+            logCapabilityContributions(plugin, context.logger.log);
+            capabilities.registerContributions(plugin.capabilities);
+        }
+        else if (!plugins.isEnabled(plugin.manifest.id)) {
+            context.logger.log(`[plugin:${plugin.manifest.id}] disabled by runtime settings`);
+        }
     }
 }
 function logCapabilityContributions(plugin, log) {
@@ -103,55 +98,18 @@ function logCapabilityContributions(plugin, log) {
         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) {
+function resolveRuntime(plugin, context) {
     if (!plugin.createRuntime) {
-        throw new Error(`Channel plugin ${plugin.manifest.id} does not provide a runtime factory.`);
+        throw new Error(`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.`);
+        throw new Error(`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 resolveMonitorRuntime(plugin, context) {
-    if (!plugin.createRuntime) {
-        throw new Error(`Monitor plugin ${plugin.manifest.id} does not provide a runtime factory.`);
-    }
-    const runtime = plugin.createRuntime(context);
-    if (runtime instanceof Promise) {
-        throw new Error(`Monitor plugin ${plugin.manifest.id} returned an async runtime factory during synchronous bootstrap.`);
-    }
-    return runtime;
+function isAgentPlugin(plugin) {
+    return Boolean(plugin && (plugin.manifest.kind === 'agent' || plugin.manifest.kind === 'composite'));
 }
 function bootstrapLocalCoreRuntime(options) {
     const state = (0, local_core_runtime_state_js_1.createLocalCoreRuntimeState)({
@@ -167,7 +125,7 @@ function bootstrapLocalCoreRuntime(options) {
     });
     const store = new local_core_acp_store_js_1.LocalCoreAcpStore(options.userDataPath);
     const localCoreAgentPlugin = kernel.plugins.get('builtin.agent-localcore-acp');
-    if (!localCoreAgentPlugin) {
+    if (!isAgentPlugin(localCoreAgentPlugin)) {
         throw new Error('Missing built-in LocalCore ACP agent plugin.');
     }
     const agentPlugins = (0, catalog_js_1.createRuntimeAgentPlugins)(localCoreAgentPlugin);
@@ -209,30 +167,30 @@ function bootstrapLocalCoreRuntime(options) {
     }
     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;
+        .map((plugin) => resolveRuntime(plugin, kernel.context).runtime);
+    const channelRuntime = resolveRuntime(channelPlugin, kernel.context).channel;
+    weixinChannelRuntime = resolveRuntime(weixinChannelPlugin, kernel.context).channel;
     const channelRuntimes = [
         channelRuntime,
         weixinChannelRuntime,
     ];
     const knowledgeRuntime = kernel.plugins.isEnabled(knowledgePlugin.manifest.id)
-        ? resolveKnowledgeRuntime(knowledgePlugin, kernel.context)
-        : resolveKnowledgeRuntime((0, catalog_js_1.createBuiltinNoopKnowledgePlugin)(), kernel.context);
+        ? resolveRuntime(knowledgePlugin, kernel.context)
+        : resolveRuntime((0, catalog_js_1.createBuiltinNoopKnowledgePlugin)(), kernel.context);
     const cronSchedulerPlugin = (0, catalog_js_1.createBuiltinCronSchedulerPlugin)();
     const schedulerRuntimes = [
         ...(kernel.plugins.isEnabled(cronSchedulerPlugin.manifest.id)
-            ? [resolveSchedulerRuntime(cronSchedulerPlugin, kernel.context)]
+            ? [resolveRuntime(cronSchedulerPlugin, kernel.context)]
             : []),
         ...schedulerPlugins
             .filter((plugin) => kernel.plugins.isEnabled(plugin.manifest.id))
-            .map((plugin) => resolveSchedulerRuntime(plugin, kernel.context)),
+            .map((plugin) => resolveRuntime(plugin, kernel.context)),
     ];
     const schedulerTriggers = schedulerRuntimes.flatMap((runtime) => runtime.triggers || []);
     const schedulerExecutors = schedulerRuntimes.flatMap((runtime) => runtime.executors || []);
     const monitorRuntimes = monitorPlugins
         .filter((plugin) => kernel.plugins.isEnabled(plugin.manifest.id))
-        .map((plugin) => resolveMonitorRuntime(plugin, kernel.context));
+        .map((plugin) => resolveRuntime(plugin, kernel.context));
     const monitorProviders = monitorRuntimes.flatMap((runtime) => runtime.providers || []);
     const knowledgeProvider = knowledgeRuntime.provider;
     const knowledgeAttachments = knowledgeRuntime.attachments;

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

@@ -137,11 +137,12 @@ class LocalCoreError extends Error {
     info;
     constructor(code, message, input = {}) {
         const defaults = DEFAULTS[code];
-        super(message || defaults.userMessage);
+        const messageStr = coerceErrorMessage(message) || defaults.userMessage;
+        super(messageStr);
         this.name = 'LocalCoreError';
         this.info = {
             code,
-            message: message || defaults.userMessage,
+            message: messageStr,
             userMessage: input.userMessage || defaults.userMessage,
             severity: input.severity || defaults.severity,
             retryable: input.retryable ?? defaults.retryable,
@@ -158,9 +159,9 @@ function toLocalCoreErrorInfo(error, fallbackCode = 'internal_error', details =
     }
     const maybeInfo = error?.info;
     if (maybeInfo?.code && maybeInfo.message) {
-        return mergeDetails(maybeInfo, details);
+        return mergeDetails(ensureInfoMessageString(maybeInfo), details);
     }
-    const message = error instanceof Error ? error.message : String(error || '');
+    const message = coerceErrorMessage(error instanceof Error ? error.message : error);
     const classifiedCode = classifyErrorMessage(message, fallbackCode);
     return new LocalCoreError(classifiedCode, message || DEFAULTS[classifiedCode].userMessage, {
         details: Object.keys(details).length ? details : undefined,
@@ -171,7 +172,8 @@ function formatUserError(info) {
 }
 function formatLogError(info) {
     const suffix = info.cause ? ` cause=${info.cause}` : '';
-    return `${info.code}: ${info.message}${suffix}`;
+    const message = typeof info.message === 'string' ? info.message : safeStringify(info.message);
+    return `${info.code}: ${message}${suffix}`;
 }
 function errorInfoToHttpBody(info) {
     return {
@@ -253,3 +255,29 @@ function mergeDetails(info, details) {
         },
     };
 }
+function ensureInfoMessageString(info) {
+    if (typeof info.message === 'string') {
+        return info;
+    }
+    return { ...info, message: safeStringify(info.message) };
+}
+function coerceErrorMessage(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (value === null || value === undefined) {
+        return '';
+    }
+    return safeStringify(value);
+}
+function safeStringify(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}

package/dist-electron/services/local-ai-core/src/plugins/builtin/knowledge-ai-vector-plugin.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createBuiltinAiVectorKnowledgePlugin = createBuiltinAiVectorKnowledgePlugin;
-const index_js_1 = require("../../../../../packages/knowledge-api/src/index.js");
+const knowledge_api_1 = require("../../../../../packages/knowledge-api/src/index.js");
 function createBuiltinAiVectorKnowledgePlugin(options) {
-    return (0, index_js_1.createAiVectorKnowledgePlugin)(options);
+    return (0, knowledge_api_1.createAiVectorKnowledgePlugin)(options);
 }

package/dist-electron/services/local-ai-core/src/plugins/builtin/knowledge-noop-plugin.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createBuiltinNoopKnowledgePlugin = createBuiltinNoopKnowledgePlugin;
-const index_js_1 = require("../../../../../packages/knowledge-api/src/index.js");
+const knowledge_api_1 = require("../../../../../packages/knowledge-api/src/index.js");
 function createBuiltinNoopKnowledgePlugin() {
-    return (0, index_js_1.createNoopKnowledgePlugin)();
+    return (0, knowledge_api_1.createNoopKnowledgePlugin)();
 }

package/dist-electron/services/local-ai-core/src/router/workspace-bridge-event-stream.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceBridgeEventStream = void 0;
+class WorkspaceBridgeEventStream {
+    eventBus;
+    subscribers = new Set();
+    constructor(eventBus) {
+        this.eventBus = eventBus;
+    }
+    emit(event) {
+        this.eventBus.emit({
+            type: 'platform.bridge.updated',
+            payload: event,
+        });
+        for (const subscriber of this.subscribers) {
+            subscriber(event);
+        }
+    }
+    subscribe(subscriber) {
+        this.subscribers.add(subscriber);
+        return () => {
+            this.subscribers.delete(subscriber);
+        };
+    }
+    clear() {
+        this.subscribers.clear();
+    }
+}
+exports.WorkspaceBridgeEventStream = WorkspaceBridgeEventStream;

package/dist-electron/services/local-ai-core/src/router/workspace-route-config.js

@@ -4,25 +4,25 @@ exports.normalizePlatformTypes = normalizePlatformTypes;
 exports.isLocalCoreNativeAcpProject = isLocalCoreNativeAcpProject;
 exports.toLocalCoreProjectConfig = toLocalCoreProjectConfig;
 const node_path_1 = require("node:path");
-const desktop_js_1 = require("../../../../shared/desktop.js");
+const superai_contracts_1 = require("../../../../packages/contracts/src/index.js");
 const index_js_1 = require("../agents/index.js");
 const launch_utils_js_1 = require("../agents/shared/launch-utils.js");
 const agent_execution_backend_js_1 = require("../execution/agent-execution-backend.js");
 function normalizePlatformTypes(project) {
     return Array.isArray(project?.platforms)
-        ? project.platforms.map((platform) => (0, desktop_js_1.normalizeDesktopPlatformType)(platform?.type)).filter(Boolean)
+        ? project.platforms.map((platform) => (0, superai_contracts_1.normalizeDesktopPlatformType)(platform?.type)).filter(Boolean)
         : [];
 }
 function isLocalCoreNativeAcpProject(project) {
     const agentType = String(project?.agent?.type || '').trim().toLowerCase();
     return !agentType
         || agentType === 'acp'
-        || agentType === desktop_js_1.LOCALCORE_ACP_AGENT_TYPE;
+        || agentType === superai_contracts_1.LOCALCORE_ACP_AGENT_TYPE;
 }
 function resolveAgentModel(project, providers, definition) {
     const agentType = String(project.agent?.type || '').trim().toLowerCase();
     const rawModel = String(project.agent?.options?.model || '').trim();
-    const normalizedModel = (0, desktop_js_1.normalizeDesktopAgentModel)(agentType, rawModel);
+    const normalizedModel = (0, superai_contracts_1.normalizeDesktopAgentModel)(agentType, rawModel);
     return definition?.resolveModel?.({
         project,
         providers,
@@ -63,7 +63,7 @@ function toLocalCoreProjectConfig(configState, project) {
     }
     const defaultArgs = launchDefaults.args || [];
     const launchConfig = {
-        workspaceId: project.name,
+        workspaceId: project.workspace_id || project.name,
         agentType,
         workDir,
         command,