@kafca/agentdock 0.1.44 → 0.1.45

package/dist-electron/tests/electron/workspace-task-store.test.js

@@ -10,6 +10,7 @@ const node_path_1 = require("node:path");
 const node_os_1 = require("node:os");
 const local_core_acp_store_js_1 = require("../../services/local-ai-core/src/acp/local-core-acp-store.js");
 const local_core_acp_session_coordinator_js_1 = require("../../services/local-ai-core/src/acp/local-core-acp-session-coordinator.js");
+const local_core_acp_transport_js_1 = require("../../services/local-ai-core/src/acp/local-core-acp-transport.js");
 const local_core_acp_turn_coordinator_js_1 = require("../../services/local-ai-core/src/acp/local-core-acp-turn-coordinator.js");
 const scheduler_service_js_1 = require("../../services/local-ai-core/src/scheduler/scheduler-service.js");
 const lark_schedule_adapter_js_1 = require("../../services/local-ai-core/src/scheduler/lark-schedule-adapter.js");
@@ -40,6 +41,141 @@ const local_core_controller_js_1 = require("../../services/local-ai-core/src/run
         (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)('model providers persist independently from workspace config', () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'model-provider-store-'));
+    try {
+        const store = new local_core_acp_store_js_1.LocalCoreAcpStore(userDataPath);
+        const provider = store.upsertModelProvider({
+            name: 'deepseek',
+            api_key: 'secret',
+            base_url: 'https://api.deepseek.com',
+            model: 'deepseek-v4-flash',
+            env: { CUSTOM_PROVIDER_ENV: '1' },
+        });
+        strict_1.default.equal(provider.id, 'deepseek');
+        strict_1.default.equal(provider.api_key, 'secret');
+        strict_1.default.equal(store.listModelProviders().length, 1);
+        const reopened = new local_core_acp_store_js_1.LocalCoreAcpStore(userDataPath);
+        strict_1.default.equal(reopened.getModelProvider('deepseek')?.model, 'deepseek-v4-flash');
+        reopened.close();
+        store.close();
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)('external project and thread mappings persist with isolated workspace paths', () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'external-store-'));
+    try {
+        const store = new local_core_acp_store_js_1.LocalCoreAcpStore(userDataPath);
+        const project = store.upsertExternalProject({
+            userId: 'user-a',
+            externalProjectId: 'project-a',
+            workspaceId: 'external-user-a-project-a',
+            workspacePath: '/data/users/user-a/projects/project-a',
+            displayName: 'Project A',
+            agentType: 'pi',
+            providerId: 'deepseek',
+            metadata: { source: 'external' },
+            createdAt: '2026-05-15T00:00:00.000Z',
+            updatedAt: '2026-05-15T00:00:00.000Z',
+        });
+        const thread = store.createThread(project.workspaceId, 'Thread A', 'pi');
+        store.upsertExternalThread({
+            userId: project.userId,
+            externalProjectId: project.externalProjectId,
+            externalThreadId: 'thread-a',
+            workspaceId: project.workspaceId,
+            threadId: thread.id,
+            workspacePath: '/data/users/user-a/projects/project-a/threads/thread-a/workspace',
+            metadata: { channel: 'api' },
+            createdAt: '2026-05-15T00:00:00.000Z',
+            updatedAt: '2026-05-15T00:00:00.000Z',
+        });
+        store.close();
+        const reopened = new local_core_acp_store_js_1.LocalCoreAcpStore(userDataPath);
+        strict_1.default.equal(reopened.getExternalProject('user-a', 'project-a')?.workspacePath, '/data/users/user-a/projects/project-a');
+        strict_1.default.equal(reopened.getExternalThreadByThreadId(thread.id)?.workspacePath, '/data/users/user-a/projects/project-a/threads/thread-a/workspace');
+        reopened.close();
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)('controller migrates embedded project providers into shared provider store', async () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'model-provider-migration-'));
+    try {
+        const runtime = (0, bootstrap_js_1.bootstrapLocalCoreRuntime)({
+            userDataPath,
+            enableKnowledge: false,
+            log: () => { },
+        });
+        const controller = new local_core_controller_js_1.LocalCoreController(userDataPath, runtime);
+        await controller.saveStructuredConfigFile({
+            projects: [{
+                    name: 'workspace-a',
+                    agent: {
+                        type: 'pi',
+                        options: { work_dir: '/tmp/workspace-a' },
+                        providers: [{
+                                name: 'deepseek-v4-flash',
+                                api_key: 'secret',
+                                base_url: 'https://api.deepseek.com',
+                                model: 'deepseek-v4-flash',
+                            }],
+                    },
+                    platforms: [],
+                }],
+        });
+        const config = await controller.readConfigFile();
+        strict_1.default.equal(config.parsed?.projects?.[0]?.agent.options?.provider_id, 'deepseek');
+        strict_1.default.equal(config.parsed?.projects?.[0]?.agent.providers, undefined);
+        const providers = await controller.listModelProviders();
+        strict_1.default.equal(providers.providers[0]?.id, 'deepseek');
+        strict_1.default.equal(providers.providers[0]?.name, 'deepseek');
+        await controller.close();
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)('workspace router resolves projects that select a shared provider', async () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'workspace-provider-ref-'));
+    try {
+        const runtime = (0, bootstrap_js_1.bootstrapLocalCoreRuntime)({
+            userDataPath,
+            enableKnowledge: false,
+            log: () => { },
+        });
+        const controller = new local_core_controller_js_1.LocalCoreController(userDataPath, runtime);
+        const provider = await controller.createModelProvider({
+            name: 'deepseek',
+            api_key: 'secret',
+            base_url: 'https://api.deepseek.com',
+            model: 'deepseek-v4-flash',
+        });
+        await controller.saveStructuredConfigFile({
+            projects: [{
+                    name: 'workspace-a',
+                    agent: {
+                        type: 'pi',
+                        options: {
+                            work_dir: '/tmp/workspace-a',
+                            provider_id: provider.id,
+                        },
+                    },
+                    platforms: [],
+                }],
+        });
+        const workspaces = await controller.listWorkspaces();
+        strict_1.default.equal(workspaces[0]?.id, 'workspace-a');
+        strict_1.default.equal(workspaces[0]?.agentType, 'pi');
+        await controller.close();
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
 (0, node_test_1.default)('scheduler create resolves a Lark delivery route without binding the job to a thread', async () => {
     const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'scheduler-binding-route-'));
     try {
@@ -443,6 +579,50 @@ const local_core_controller_js_1 = require("../../services/local-ai-core/src/run
         (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)('ACP runtime PATH includes service-safe user bin directories', () => {
+    const previousHome = process.env.HOME;
+    process.env.HOME = '/home/agentdock-test';
+    try {
+        const path = (0, local_core_acp_session_coordinator_js_1.buildAgentPath)('/usr/bin:/bin', '/opt/agentdock/bin');
+        strict_1.default.equal(path, '/opt/agentdock/bin:/home/agentdock-test/.local/bin:/home/agentdock-test/bin:/usr/bin:/bin');
+    }
+    finally {
+        if (previousHome === undefined) {
+            delete process.env.HOME;
+        }
+        else {
+            process.env.HOME = previousHome;
+        }
+    }
+});
+(0, node_test_1.default)('ACP transport reports missing agent commands without an unhandled process error', async () => {
+    const closed = new Promise((resolve) => {
+        const transport = new local_core_acp_transport_js_1.LocalCoreAcpTransport({
+            log: () => { },
+            onAgentRequest: () => { },
+            onAgentNotification: () => { },
+            onSessionClosed: (_session, error) => {
+                resolve(error);
+            },
+        });
+        transport.spawnSession({
+            threadId: 'thread-missing-command',
+            bridgeSessionKey: 'session:missing-command',
+            config: {
+                workspaceId: 'workspace-a',
+                agentType: 'hermes',
+                command: 'agentdock-command-that-does-not-exist',
+                args: ['acp'],
+                env: {},
+                workDir: (0, node_os_1.tmpdir)(),
+                model: '',
+            },
+            runtimeEnv: {},
+        });
+    });
+    const error = await closed;
+    strict_1.default.equal(error.message, 'ACP agent command not found: agentdock-command-that-does-not-exist');
+});
 (0, node_test_1.default)('ACP scheduled session can override permission mode without changing thread mode', async () => {
     const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'scheduler-permission-mode-'));
     try {
@@ -515,6 +695,83 @@ const local_core_controller_js_1 = require("../../services/local-ai-core/src/run
         (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
     }
 });
+(0, node_test_1.default)('ACP sandbox sessions use container workspace cwd', async () => {
+    const userDataPath = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'sandbox-session-cwd-'));
+    try {
+        const store = new local_core_acp_store_js_1.LocalCoreAcpStore(userDataPath);
+        const thread = store.createThread('workspace-a', 'Thread');
+        let sessionNewParams;
+        const coordinator = new local_core_acp_session_coordinator_js_1.LocalCoreAcpSessionCoordinator({
+            store,
+            transport: {
+                spawnSession(input) {
+                    return {
+                        threadId: input.threadId,
+                        bridgeSessionKey: input.bridgeSessionKey,
+                        closed: false,
+                        sessionId: '',
+                        supportsLoad: false,
+                        pendingPermissionByRun: new Map(),
+                        schedulerJobCreatedByRun: new Map(),
+                        launchPermissionMode: '',
+                    };
+                },
+                initializeSession: async () => { },
+                request: async (_session, method, params) => {
+                    if (method === 'session/new') {
+                        sessionNewParams = params;
+                        return { sessionId: 'session-1' };
+                    }
+                    return {};
+                },
+                closeSession: () => { },
+                closeSessionWithError: () => { },
+                sendRaw: () => true,
+            },
+            runThreadMap: new Map(),
+            emitBridge: () => { },
+        });
+        await coordinator.ensureSession(thread.id, 'session:thread-1', {
+            workspaceId: 'workspace-a',
+            agentType: 'pi',
+            command: process.execPath,
+            args: ['/host/sandbox-stdio-proxy.js'],
+            env: {},
+            workDir: '/host/workspace-a',
+            model: '',
+            sandbox: {
+                enabled: true,
+                provider: 'opensandbox',
+                transport: 'http-ndjson',
+                serverUrl: 'http://127.0.0.1:8080',
+                apiKeyEnv: 'OPEN_SANDBOX_API_KEY',
+                image: 'agentdock/pi-acp:local',
+                acpPort: 8080,
+                entrypoint: ['node', '/opt/agentdock/acp-bridge.mjs'],
+                timeoutSeconds: 600,
+                lifecycle: 'per_thread',
+                idleSeconds: 900,
+                warmPoolSize: 0,
+                cpu: '1000m',
+                memory: '1Gi',
+                userId: 'local',
+                projectId: 'workspace-a',
+                stateScope: 'project',
+                workspaceHostPath: '/host/workspace-a',
+                workspaceMountPath: '/workspace',
+                stateHostPath: '/host/state',
+                stateMountPath: '/agent-state',
+                runtimeCommand: '/usr/local/bin/pi-acp',
+                runtimeArgs: [],
+                runtimeEnv: {},
+            },
+        });
+        strict_1.default.equal(sessionNewParams?.cwd, '/workspace');
+    }
+    finally {
+        (0, node_fs_1.rmSync)(userDataPath, { recursive: true, force: true });
+    }
+});
 (0, node_test_1.default)('ACP permission requests honor scheduled session permission override', () => {
     const sentPayloads = [];
     let approvalCreated = false;

package/dist-electron/tests/integration/lark-gateway.test.js

@@ -687,6 +687,65 @@ function findLarkPostMdText(content) {
     strict_1.default.deepEqual(patchedCards.map((card) => card.text), []);
     strict_1.default.ok(!createdCards.some((card) => /处理中|正在思考/.test(card.text)));
 });
+(0, node_test_1.default)('lark gateway records structured error state when startup fails', async () => {
+    const emittedEvents = [];
+    const gateway = new local_core_lark_gateway_js_1.LocalCoreLarkGateway({
+        store: {
+            expirePendingPairings: () => { },
+            listPendingPairings: () => [],
+            listAuthorizedUsers: () => [],
+        },
+        readConfig: async () => null,
+        getWorkspaceRouter: () => ({}),
+        eventBus: {
+            emit: (event) => emittedEvents.push(event),
+            on: () => () => { },
+        },
+    });
+    gateway.larkModulePromise = Promise.resolve({
+        AppType: { SelfBuild: 'SelfBuild' },
+        Domain: { Feishu: 'Feishu' },
+        LoggerLevel: { info: 'info' },
+        Client: class {
+            request() {
+                return Promise.resolve({ bot: { open_id: 'bot-open-id' } });
+            }
+        },
+        EventDispatcher: class {
+            register() { }
+        },
+        WSClient: class {
+            start() {
+                throw new Error('invalid app credentials');
+            }
+            on() { }
+        },
+    });
+    await gateway.startWorkspace({
+        workspaceId: 'workspace-1',
+        instanceId: 'default',
+        displayName: 'Workspace 1',
+        platformKey: 'lark',
+        appId: 'cli_a1',
+        appSecret: 'secret',
+        encryptKey: '',
+        verificationToken: '',
+        autoApprove: false,
+        cardActionsEnabled: true,
+        groupReplyAll: false,
+        enabled: true,
+        brand: 'lark',
+        project: { name: 'workspace-1' },
+    });
+    const status = gateway.getStatus('workspace-1');
+    strict_1.default.equal(status.status, 'error');
+    strict_1.default.equal(status.connected, false);
+    strict_1.default.equal(status.lastErrorInfo?.code, 'channel_auth_failed');
+    strict_1.default.equal(status.lastErrorInfo?.suggestedAction, 'Check app credentials and restart the Lark gateway.');
+    strict_1.default.match(status.lastError || '', /invalid app credentials/);
+    strict_1.default.ok(status.lastErrorAt);
+    strict_1.default.equal(emittedEvents.some((event) => event.type === 'localcore.error' && event.payload?.scope === 'channel.lark'), true);
+});
 (0, node_test_1.default)('lark permission requests render as clickable card buttons', async () => {
     const createdCards = [];
     const patchedCards = [];

package/dist-electron/tests/integration/local-core-refactor.test.js

@@ -15,10 +15,11 @@ const scheduler_run_lifecycle_js_1 = require("../../services/local-ai-core/src/s
 const lark_execution_policies_js_1 = require("../../services/local-ai-core/src/scheduler/lark-execution-policies.js");
 const local_schedule_adapter_js_1 = require("../../services/local-ai-core/src/scheduler/local-schedule-adapter.js");
 const cards_js_1 = require("../../services/local-ai-core/src/channel/lark/cards.js");
+const session_command_runtime_js_1 = require("../../services/local-ai-core/src/channel/shared/session-command-runtime.js");
 const local_core_acp_backend_js_1 = require("../../services/local-ai-core/src/acp/local-core-acp-backend.js");
 const local_core_acp_store_js_1 = require("../../services/local-ai-core/src/acp/local-core-acp-store.js");
 const session_command_service_js_1 = require("../../services/local-ai-core/src/thread/session-command-service.js");
-const thread_command_service_js_1 = require("../../services/local-ai-core/src/thread/thread-command-service.js");
+const thread_slash_command_dispatcher_js_1 = require("../../services/local-ai-core/src/thread/thread-slash-command-dispatcher.js");
 (0, node_test_1.default)('response processor derives slash fallback replies and cron system responses', async () => {
     const processor = new local_core_acp_response_processor_js_1.LocalCoreAcpResponseProcessor({
         getScheduledDeliveryBinding: (threadId) => threadId === 'thread-1'
@@ -76,7 +77,15 @@ const thread_command_service_js_1 = require("../../services/local-ai-core/src/th
         availableAgents: ['codex', 'pi', 'hermes'],
     }), /当前线程 Agent：pi/);
 });
-(0, node_test_1.default)('thread command service handles local slash commands without ACP transport', async () => {
+(0, node_test_1.default)('slash help command exposes global local command help', () => {
+    const help = (0, thread_slash_command_dispatcher_js_1.slashHelpText)();
+    strict_1.default.match(help, /`\/help`/);
+    strict_1.default.match(help, /`\/stop`/);
+    strict_1.default.match(help, /`\/mode /);
+    strict_1.default.match(help, /`\/agent /);
+    strict_1.default.match(help, /`\/list`/);
+});
+(0, node_test_1.default)('thread slash command dispatcher handles local slash commands without ACP transport', async () => {
     const row = {
         id: 'thread-1',
         workspace_id: 'workspace-a',
@@ -95,24 +104,39 @@ const thread_command_service_js_1 = require("../../services/local-ai-core/src/th
     const audits = [];
     const syncedModes = [];
     const closedThreads = [];
-    const service = new thread_command_service_js_1.ThreadCommandService({
-        getThreadRow: () => row,
-        updateThreadAgentMode: (_threadId, mode) => {
-            row.agent_mode = mode;
-        },
-        updateThreadAgentType: (_threadId, agentType) => {
-            row.agent_type = agentType;
-        },
-        getLatestRunForThread: () => undefined,
-        createAuditEvent: (input) => {
-            audits.push(input);
-        },
-        getAgentTypes: () => ['codex', 'pi', 'hermes', 'claudecode'],
-        setThreadMode: async (_threadId, mode) => {
-            syncedModes.push(mode);
+    const interruptedRuns = [];
+    let latestRun;
+    const service = new thread_slash_command_dispatcher_js_1.ThreadSlashCommandDispatcher({
+        session: {
+            listThreads: () => [],
+            getThread: () => ({ id: row.id, title: row.title, messages: [] }),
+            createThread: () => ({ id: 'created-thread', title: 'Created', messages: [] }),
+            renameThread: () => ({ id: row.id, title: 'Renamed', messages: [] }),
+            deleteThread: () => ({ deleted: true }),
         },
-        closeThreadSession: (threadId) => {
-            closedThreads.push(threadId);
+        thread: {
+            getThreadRow: () => row,
+            updateThreadAgentMode: (_threadId, mode) => {
+                row.agent_mode = mode;
+            },
+            updateThreadAgentType: (_threadId, agentType) => {
+                row.agent_type = agentType;
+            },
+            getLatestRunForThread: () => latestRun,
+            createAuditEvent: (input) => {
+                audits.push(input);
+            },
+            getAgentTypes: () => ['codex', 'pi', 'hermes', 'claudecode'],
+            setThreadMode: async (_threadId, mode) => {
+                syncedModes.push(mode);
+            },
+            closeThreadSession: (threadId) => {
+                closedThreads.push(threadId);
+            },
+            interruptRun: async (runId) => {
+                interruptedRuns.push(runId);
+                return { interrupted: true };
+            },
         },
     });
     strict_1.default.deepEqual(await service.execute({
@@ -121,6 +145,32 @@ const thread_command_service_js_1 = require("../../services/local-ai-core/src/th
         content: '/not-local',
         defaultAgentType: 'codex',
     }), { handled: false, displayText: '' });
+    const inactiveStopResult = await service.execute({
+        threadId: row.id,
+        workspaceId: row.workspace_id,
+        content: '/stop',
+        defaultAgentType: 'codex',
+    });
+    strict_1.default.equal(inactiveStopResult.handled, true);
+    strict_1.default.match(inactiveStopResult.displayText, /没有正在运行的任务/);
+    latestRun = {
+        id: 'run-active',
+        thread_id: row.id,
+        status: 'running',
+        started_at: '2026-05-11T00:00:00.000Z',
+        updated_at: '2026-05-11T00:00:00.000Z',
+    };
+    const stopResult = await service.execute({
+        threadId: row.id,
+        workspaceId: row.workspace_id,
+        content: '/stop',
+        defaultAgentType: 'codex',
+    });
+    strict_1.default.equal(stopResult.handled, true);
+    strict_1.default.match(stopResult.displayText, /已请求停止当前任务/);
+    strict_1.default.deepEqual(interruptedRuns, ['run-active']);
+    strict_1.default.equal(audits.at(-1)?.type, 'task.updated');
+    latestRun = undefined;
     const modeResult = await service.execute({
         threadId: row.id,
         workspaceId: row.workspace_id,
@@ -153,6 +203,111 @@ const thread_command_service_js_1 = require("../../services/local-ai-core/src/th
     strict_1.default.match(resetResult.displayText, /回到默认 Agent：codex/);
     strict_1.default.deepEqual(closedThreads, ['thread-1', 'thread-1']);
 });
+(0, node_test_1.default)('channel session command runtime uses unified slash dispatcher for thread commands', async () => {
+    const row = {
+        id: 'thread-1',
+        workspace_id: 'workspace-a',
+        session_id: 'session-1',
+        bridge_session_key: 'bridge-1',
+        title: 'Channel command',
+        agent_type: 'codex',
+        created_at: '2026-05-11T00:00:00.000Z',
+        updated_at: '2026-05-11T00:00:00.000Z',
+        history_count: 0,
+        excerpt: '',
+        acp_session_id: null,
+        acp_supports_load: 0,
+        agent_mode: 'default',
+    };
+    const sentResults = [];
+    const interruptedRuns = [];
+    const routes = new Map();
+    const dispatcher = new thread_slash_command_dispatcher_js_1.ThreadSlashCommandDispatcher({
+        session: {
+            listThreads: () => [],
+            getThread: (threadId) => ({ id: threadId, title: row.title, messages: [] }),
+            createThread: () => ({ id: 'created-thread', title: 'Created channel thread', messages: [] }),
+            renameThread: (threadId, title) => ({ id: threadId, title, messages: [] }),
+            deleteThread: () => ({ deleted: true }),
+        },
+        thread: {
+            getThreadRow: () => row,
+            updateThreadAgentMode: (_threadId, mode) => {
+                row.agent_mode = mode;
+            },
+            updateThreadAgentType: (_threadId, agentType) => {
+                row.agent_type = agentType;
+            },
+            getLatestRunForThread: () => ({
+                id: 'run-channel',
+                thread_id: row.id,
+                status: 'running',
+                started_at: '2026-05-11T00:00:00.000Z',
+                updated_at: '2026-05-11T00:00:00.000Z',
+            }),
+            createAuditEvent: () => { },
+            getAgentTypes: () => ['codex', 'pi'],
+            interruptRun: async (runId) => {
+                interruptedRuns.push(runId);
+                return { interrupted: true };
+            },
+        },
+    });
+    const runtime = new session_command_runtime_js_1.ChannelSessionCommandRuntime({
+        dispatcher,
+        store: {
+            getThreadRow: () => row,
+            updateThreadAgentMode: (_threadId, mode) => {
+                row.agent_mode = mode;
+            },
+            updateAuthorizedUserThread: () => { },
+            upsertPlatformThreadBinding: () => { },
+        },
+        getThreadSessionKey: (threadId) => `session:${threadId}`,
+        setThreadRoute: (sessionKey, route) => {
+            routes.set(sessionKey, route);
+        },
+        createRoute: (input, threadId) => ({
+            workspaceId: input.workspaceId,
+            instanceId: input.instanceId,
+            platformKey: input.platformKey,
+            platformUserId: input.platformUserId,
+            chatId: input.chatId,
+            threadId,
+        }),
+        sendResult: async (_input, result) => {
+            sentResults.push(result);
+        },
+    });
+    const stopResult = await runtime.execute({
+        workspaceId: 'workspace-a',
+        currentThreadId: row.id,
+        text: '/stop',
+        defaultTitle: 'Channel thread',
+        defaultAgentType: 'codex',
+        chatId: 'chat-1',
+        platformUserId: 'user-1',
+        platformKey: 'lark',
+        instanceId: 'default',
+    });
+    strict_1.default.equal(stopResult.handled, true);
+    strict_1.default.deepEqual(interruptedRuns, ['run-channel']);
+    strict_1.default.match(sentResults.at(-1)?.displayText || '', /已请求停止当前任务/);
+    const newResult = await runtime.execute({
+        workspaceId: 'workspace-a',
+        currentThreadId: row.id,
+        text: '/new Follow up',
+        defaultTitle: 'Channel thread',
+        defaultAgentType: 'codex',
+        chatId: 'chat-1',
+        platformUserId: 'user-1',
+        platformKey: 'lark',
+        instanceId: 'default',
+    });
+    strict_1.default.equal(newResult.handled, true);
+    strict_1.default.equal(newResult.threadId, 'created-thread');
+    strict_1.default.equal(routes.get('session:created-thread')?.threadId, 'created-thread');
+});
 (0, node_test_1.default)('thread agent mode persists with thread state', () => {
     const dir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'agentdock-mode-'));
     try {
@@ -193,9 +348,10 @@ const thread_command_service_js_1 = require("../../services/local-ai-core/src/th
         const thread = store.createThread('workspace-a', 'Agent command', 'codex');
         const bridgeEvents = [];
         const acceptedMessages = [];
+        const runThreadMap = new Map();
         const backend = new local_core_acp_backend_js_1.LocalCoreAcpBackend({
             store,
-            runThreadMap: new Map(),
+            runThreadMap,
             emitBridge: (event) => bridgeEvents.push(event),
             eventBus: {
                 emit: (event) => acceptedMessages.push(event),
@@ -236,6 +392,13 @@ const thread_command_service_js_1 = require("../../services/local-ai-core/src/th
         await backend.sendThreadMessage(thread.id, '/agent use hermes', config);
         strict_1.default.equal(store.getThreadRow(thread.id)?.agent_type, 'hermes');
         strict_1.default.match(store.getThread(thread.id, []).messages.at(-1)?.content || '', /下一轮开始生效/);
+        store.updateRun('run-stop', thread.id, 'running');
+        runThreadMap.set('run-stop', thread.id);
+        await backend.sendThreadMessage(thread.id, '/stop', config);
+        strict_1.default.equal(store.getRun('run-stop')?.status, 'interrupted');
+        strict_1.default.match(store.getThread(thread.id, []).messages.at(-1)?.content || '', /已将当前任务标记为停止|已请求停止当前任务/);
+        await backend.sendThreadMessage(thread.id, '/help', config);
+        strict_1.default.match(store.getThread(thread.id, []).messages.at(-1)?.content || '', /`\/stop`/);
         strict_1.default.ok(acceptedMessages.length >= 8);
         backend.close();
         store.close();

package/dist-electron/tests/integration/local-core-routes.test.js

@@ -81,6 +81,40 @@ const server_routes_js_1 = require("../../services/local-ai-core/src/runtime/ser
     strict_1.default.equal((0, server_routes_js_1.parseLocalAiCoreRoute)('POST', '/api/local/v1/workspace-security/workspace-1'), null);
     strict_1.default.equal((0, server_routes_js_1.parseLocalAiCoreRoute)('GET', '/api/local/v1/workspaces/workspace-1/streaming-probe'), null);
 });
+(0, node_test_1.default)('local core route parser handles shared model provider routes', () => {
+    strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('GET', '/api/local/v1/providers'), { name: 'providers.list' });
+    strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('POST', '/api/local/v1/providers'), { name: 'providers.create' });
+    strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('PUT', '/api/local/v1/providers/deepseek'), {
+        name: 'provider.update',
+        providerId: 'deepseek',
+    });
+    strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('DELETE', '/api/local/v1/providers/deepseek'), {
+        name: 'provider.delete',
+        providerId: 'deepseek',
+    });
+    strict_1.default.equal((0, server_routes_js_1.parseLocalAiCoreRoute)('GET', '/api/local/v1/providers/deepseek/extra'), null);
+});
+(0, node_test_1.default)('local core route parser handles external project and run routes', () => {
+    strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('POST', '/api/local/v1/external/projects'), {
+        name: 'external.project.ensure',
+    });
+    strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('POST', '/api/local/v1/external/runs'), {
+        name: 'external.run.create',
+    });
+    strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('GET', '/api/local/v1/external/runs/run%2Fone/events'), {
+        name: 'external.run.events',
+        runId: 'run/one',
+    });
+    strict_1.default.equal((0, server_routes_js_1.parseLocalAiCoreRoute)('GET', '/api/local/v1/external/projects'), null);
+    strict_1.default.equal((0, server_routes_js_1.parseLocalAiCoreRoute)('POST', '/api/local/v1/external/runs/run-1/events'), null);
+});
+(0, node_test_1.default)('local core route parser handles OpenAI-compatible chat completions route', () => {
+    strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('POST', '/api/local/v1/openai/chat/completions'), {
+        name: 'openai.chat.completions',
+    });
+    strict_1.default.equal((0, server_routes_js_1.parseLocalAiCoreRoute)('GET', '/api/local/v1/openai/chat/completions'), null);
+    strict_1.default.equal((0, server_routes_js_1.parseLocalAiCoreRoute)('POST', '/api/local/v1/openai/completions'), null);
+});
 (0, node_test_1.default)('local core route parser keeps approval resolution separate from approval detail', () => {
     strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('GET', '/api/local/v1/approvals'), { name: 'approvals.list' });
     strict_1.default.deepEqual((0, server_routes_js_1.parseLocalAiCoreRoute)('POST', '/api/local/v1/approvals'), { name: 'approvals.create' });