@kafca/agentdock 0.1.44 → 0.1.46

package/dist-electron/services/local-ai-core/src/acp/local-core-acp-session-coordinator.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalCoreAcpSessionCoordinator = void 0;
+exports.buildAgentPath = buildAgentPath;
 const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
 const scheduled_job_route_js_1 = require("../scheduler/scheduled-job-route.js");
 class LocalCoreAcpSessionCoordinator {
     options;
@@ -14,6 +16,7 @@ class LocalCoreAcpSessionCoordinator {
     }
     closeAll() {
         for (const session of this.sessions.values()) {
+            this.clearIdleClose(session);
             this.options.transport.closeSession(session);
         }
         this.sessions.clear();
@@ -23,9 +26,21 @@ class LocalCoreAcpSessionCoordinator {
         if (!session) {
             return;
         }
+        this.clearIdleClose(session);
         this.options.transport.closeSession(session);
         this.sessions.delete(threadId);
     }
+    releaseThreadSession(threadId, config) {
+        if (!config.sandbox?.enabled || config.sandbox.lifecycle === 'per_run' || config.sandbox.stateScope === 'run') {
+            this.closeThreadSession(threadId);
+            return;
+        }
+        const session = this.sessions.get(threadId);
+        if (!session || session.closed) {
+            return;
+        }
+        this.scheduleIdleClose(session, config.sandbox.idleSeconds);
+    }
     async ensureSession(threadId, bridgeSessionKey, config, options = {}) {
         const existing = this.sessions.get(threadId);
         const permissionMode = this.resolveLaunchPermissionMode(threadId, options.permissionMode);
@@ -37,11 +52,15 @@ class LocalCoreAcpSessionCoordinator {
             && existing.launchPermissionMode === permissionMode
             && existing.launchConfigKey === configKey
             && existing.launchRuntimeEnvKey === runtimeEnvKey) {
+            this.clearIdleClose(existing);
+            this.options.log?.(`[acp.session:${threadId}] reuse existing session mode=${config.sandbox?.enabled ? 'sandbox' : 'local'}`);
             return existing;
         }
         if (existing) {
             this.closeThreadSession(threadId);
         }
+        const startedAt = Date.now();
+        this.options.log?.(`[acp.session:${threadId}] spawn mode=${config.sandbox?.enabled ? 'sandbox' : 'local'} transport=${config.execution?.transport || 'stdio'}`);
         const baseEnv = {
             ...process.env,
             ...config.env,
@@ -50,20 +69,21 @@ class LocalCoreAcpSessionCoordinator {
             threadId,
             bridgeSessionKey,
             config,
-            runtimeEnv: this.buildAgentRuntimeEnv(threadId, String(baseEnv.PATH || ''), options.runtimeEnv),
+            runtimeEnv: this.buildAgentRuntimeEnv(threadId, String(baseEnv.PATH || ''), options.runtimeEnv, options.runId),
         });
         session.launchPermissionMode = permissionMode;
         session.launchConfigKey = configKey;
         session.launchRuntimeEnvKey = runtimeEnvKey;
         this.sessions.set(threadId, session);
         await this.options.transport.initializeSession(session);
+        this.options.log?.(`[acp.session:${threadId}] initialize done in ${Date.now() - startedAt}ms`);
         const row = this.options.store.getThreadRow(threadId);
         if (row?.acp_session_id && row.acp_supports_load && session.supportsLoad) {
             try {
                 session.loadReplayMode = true;
                 await this.options.transport.request(session, 'session/load', {
                     sessionId: row.acp_session_id,
-                    cwd: config.workDir,
+                    cwd: acpSessionCwd(config),
                     mcpServers: [],
                 }, 30000);
                 session.sessionId = row.acp_session_id;
@@ -78,7 +98,7 @@ class LocalCoreAcpSessionCoordinator {
         if (!session.sessionId) {
             try {
                 const created = await this.options.transport.request(session, 'session/new', {
-                    cwd: config.workDir,
+                    cwd: acpSessionCwd(config),
                     mcpServers: [],
                     _meta: this.buildSessionMeta(threadId, permissionMode),
                 }, 30000);
@@ -87,12 +107,14 @@ class LocalCoreAcpSessionCoordinator {
                     throw new Error('ACP session/new did not return a sessionId');
                 }
                 this.options.store.updateThreadSession(threadId, session.sessionId, session.supportsLoad);
+                this.options.log?.(`[acp.session:${threadId}] session/new done in ${Date.now() - startedAt}ms`);
             }
             catch (error) {
                 this.closeThreadSession(threadId);
                 throw error;
             }
         }
+        this.options.log?.(`[acp.session:${threadId}] ready in ${Date.now() - startedAt}ms`);
         return session;
     }
     async setThreadMode(threadId, mode) {
@@ -152,6 +174,7 @@ class LocalCoreAcpSessionCoordinator {
             return;
         }
         const activeRunId = session.currentRunId;
+        this.clearIdleClose(session);
         this.options.transport.closeSessionWithError(session, error);
         if (activeRunId) {
             this.options.store.updateRun(activeRunId, session.threadId, 'failed');
@@ -166,13 +189,31 @@ class LocalCoreAcpSessionCoordinator {
             this.sessions.delete(session.threadId);
         }
     }
+    scheduleIdleClose(session, idleSeconds) {
+        this.clearIdleClose(session);
+        const seconds = Number.isFinite(idleSeconds) && idleSeconds > 0 ? idleSeconds : 900;
+        this.options.log?.(`[acp.session:${session.threadId}] keep sandbox session warm for ${seconds}s`);
+        session.idleCloseTimer = setTimeout(() => {
+            if (this.sessions.get(session.threadId) === session && !session.closed && !session.currentRunId) {
+                this.options.log?.(`[acp.session:${session.threadId}] idle timeout reached; closing sandbox session`);
+                this.closeThreadSession(session.threadId);
+            }
+        }, seconds * 1000);
+        session.idleCloseTimer.unref?.();
+    }
+    clearIdleClose(session) {
+        if (session.idleCloseTimer) {
+            clearTimeout(session.idleCloseTimer);
+            session.idleCloseTimer = undefined;
+        }
+    }
     buildRuntimeEnvKey(runtimeEnv = {}) {
         return Object.keys(runtimeEnv)
             .sort()
             .map((key) => `${key}=${runtimeEnv[key]}`)
             .join('\n');
     }
-    buildAgentRuntimeEnv(threadId, existingPath, runtimeEnv = {}) {
+    buildAgentRuntimeEnv(threadId, existingPath, runtimeEnv = {}, runId = '') {
         const row = this.options.store.getThreadRow(threadId);
         if (!row) {
             return {};
@@ -182,6 +223,7 @@ class LocalCoreAcpSessionCoordinator {
             LOCAL_AI_CORE_BASE: this.options.localCoreBase || 'http://127.0.0.1:9831/api/local/v1',
             LOCAL_AI_WORKSPACE_ID: row.workspace_id,
             LOCAL_AI_THREAD_ID: threadId,
+            ...(runId ? { AGENTDOCK_SANDBOX_RUN_ID: runId } : {}),
         };
         const workspace = this.options.store.getWorkspaceRegistryEntry(row.workspace_id);
         if (workspace?.path) {
@@ -198,9 +240,10 @@ class LocalCoreAcpSessionCoordinator {
             env.LOCAL_AI_PLATFORM_USER_ID = binding.platform_user_id;
         }
         if (this.options.cliBinDir) {
-            env.PATH = existingPath
-                ? `${this.options.cliBinDir}${node_path_1.delimiter}${existingPath}`
-                : this.options.cliBinDir;
+            env.PATH = buildAgentPath(existingPath, this.options.cliBinDir);
+        }
+        else {
+            env.PATH = buildAgentPath(existingPath);
         }
         return {
             ...env,
@@ -215,6 +258,8 @@ class LocalCoreAcpSessionCoordinator {
             args: config.args || [],
             env: config.env || {},
             model: config.model || '',
+            execution: config.execution || null,
+            sandbox: config.sandbox || null,
         });
     }
     resolveLaunchPermissionMode(threadId, permissionModeOverride = '') {
@@ -241,3 +286,31 @@ class LocalCoreAcpSessionCoordinator {
     }
 }
 exports.LocalCoreAcpSessionCoordinator = LocalCoreAcpSessionCoordinator;
+function acpSessionCwd(config) {
+    return config.sandbox?.enabled ? config.sandbox.workspaceMountPath : config.workDir;
+}
+function buildAgentPath(existingPath, cliBinDir) {
+    const entries = [
+        cliBinDir,
+        ...userBinDirs(),
+        ...String(existingPath || '').split(node_path_1.delimiter),
+    ];
+    const seen = new Set();
+    return entries
+        .map((entry) => String(entry || '').trim())
+        .filter((entry) => {
+        if (!entry || seen.has(entry)) {
+            return false;
+        }
+        seen.add(entry);
+        return true;
+    })
+        .join(node_path_1.delimiter);
+}
+function userBinDirs() {
+    if (process.platform === 'win32') {
+        return [];
+    }
+    const home = process.env.HOME || (0, node_os_1.homedir)();
+    return home ? [`${home}/.local/bin`, `${home}/bin`] : [];
+}

package/dist-electron/services/local-ai-core/src/acp/local-core-acp-transport.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalCoreAcpTransport = void 0;
 const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const local_core_errors_js_1 = require("../kernel/local-core-errors.js");
 class LocalCoreAcpTransport {
     options;
     constructor(options) {
@@ -12,8 +14,9 @@ class LocalCoreAcpTransport {
             ...process.env,
             ...input.config.env,
         };
+        const cwd = resolveTransportCwd(input.config);
         const child = (0, node_child_process_1.spawn)(input.config.command, input.config.args, {
-            cwd: input.config.workDir,
+            cwd,
             env: {
                 ...baseEnv,
                 ...input.runtimeEnv,
@@ -51,7 +54,37 @@ class LocalCoreAcpTransport {
             this.handlePipeFailure(session, error);
         });
         child.on('exit', (code, signal) => {
-            this.options.onSessionClosed(session, new Error(`ACP agent exited with code ${code ?? 'unknown'}${signal ? ` (${signal})` : ''}`));
+            if (session.closed) {
+                return;
+            }
+            this.options.onSessionClosed(session, new local_core_errors_js_1.LocalCoreError('runtime_exited', `ACP agent exited with code ${code ?? 'unknown'}${signal ? ` (${signal})` : ''}`, {
+                details: {
+                    code: code ?? 'unknown',
+                    signal: signal || '',
+                    threadId: input.threadId,
+                    runtimeId: input.config.agentType,
+                },
+            }));
+        });
+        child.on('error', (error) => {
+            this.options.onSessionClosed(session, error.code === 'ENOENT'
+                ? new local_core_errors_js_1.LocalCoreError('runtime_not_found', `ACP agent command not found: ${input.config.command}`, {
+                    details: {
+                        command: input.config.command,
+                        cwd,
+                        threadId: input.threadId,
+                        runtimeId: input.config.agentType,
+                    },
+                })
+                : new local_core_errors_js_1.LocalCoreError('runtime_start_failed', `ACP agent failed to start: ${error.message}`, {
+                    cause: error.code,
+                    details: {
+                        command: input.config.command,
+                        cwd,
+                        threadId: input.threadId,
+                        runtimeId: input.config.agentType,
+                    },
+                }));
         });
         return session;
     }
@@ -79,7 +112,14 @@ class LocalCoreAcpTransport {
         return new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
                 session.pending.delete(id);
-                reject(new Error(`Timed out waiting for ACP ${method} after ${timeoutMs}ms`));
+                reject(new local_core_errors_js_1.LocalCoreError('runtime_protocol_timeout', `Timed out waiting for ACP ${method} after ${timeoutMs}ms`, {
+                    details: {
+                        method,
+                        timeoutMs,
+                        threadId: session.threadId,
+                        runtimeId: session.currentTurn?.agentType || '',
+                    },
+                }));
             }, timeoutMs);
             session.pending.set(id, {
                 resolve: (value) => {
@@ -175,7 +215,15 @@ class LocalCoreAcpTransport {
                 }
                 session.pending.delete(payload.id);
                 if (payload.error) {
-                    pending.reject(new Error(payload.error.message || `ACP request failed: ${payload.id}`));
+                    pending.reject(new local_core_errors_js_1.LocalCoreError(errorCodeForAcpError(payload.error), payload.error.message || `ACP request failed: ${payload.id}`, {
+                        details: {
+                            payloadId: payload.id,
+                            errorCode: payload.error.code,
+                            errorData: payload.error.data,
+                            threadId: session.threadId,
+                            runtimeId: session.currentTurn?.agentType || '',
+                        },
+                    }));
                 }
                 else {
                     pending.resolve(payload.result);
@@ -184,9 +232,34 @@ class LocalCoreAcpTransport {
         }
     }
     handlePipeFailure(session, error) {
+        if (session.closed) {
+            return;
+        }
         const message = error instanceof Error ? error.message : String(error);
         this.options.log?.(`[localcore-acp:${session.threadId}] stdin failure: ${message}`);
-        this.options.onSessionClosed(session, new Error(message));
+        this.options.onSessionClosed(session, new local_core_errors_js_1.LocalCoreError('runtime_protocol_error', message, {
+            details: {
+                threadId: session.threadId,
+                runtimeId: session.currentTurn?.agentType || '',
+            },
+        }));
     }
 }
 exports.LocalCoreAcpTransport = LocalCoreAcpTransport;
+function resolveTransportCwd(config) {
+    if (config.sandbox?.enabled) {
+        const proxyCwd = String(config.sandbox.proxyCwd || '').trim();
+        if (proxyCwd && (0, node_fs_1.existsSync)(proxyCwd)) {
+            return proxyCwd;
+        }
+        return process.cwd();
+    }
+    return config.workDir;
+}
+function errorCodeForAcpError(error) {
+    const message = String(error?.message || '').toLowerCase();
+    if (message.includes('authentication required') || message.includes('api key') || message.includes('oauth')) {
+        return 'provider_auth_failed';
+    }
+    return 'runtime_protocol_error';
+}

package/dist-electron/services/local-ai-core/src/acp/store/external-store.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalExternalStore = void 0;
+const utils_js_1 = require("./utils.js");
+class LocalExternalStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    getProject(userId, externalProjectId) {
+        const row = this.db.prepare(`
+      SELECT user_id, external_project_id, workspace_id, workspace_path, display_name, agent_type, provider_id, metadata_json, created_at, updated_at
+      FROM external_projects
+      WHERE user_id = ? AND external_project_id = ?
+    `).get(userId, externalProjectId);
+        return row ? this.toProject(row) : undefined;
+    }
+    upsertProject(input) {
+        const now = new Date().toISOString();
+        const existing = this.getProject(input.userId, input.externalProjectId);
+        this.db.prepare(`
+      INSERT INTO external_projects (
+        user_id, external_project_id, workspace_id, workspace_path, display_name, agent_type, provider_id,
+        metadata_json, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(user_id, external_project_id) DO UPDATE SET
+        workspace_id = excluded.workspace_id,
+        workspace_path = excluded.workspace_path,
+        display_name = excluded.display_name,
+        agent_type = excluded.agent_type,
+        provider_id = excluded.provider_id,
+        metadata_json = excluded.metadata_json,
+        updated_at = excluded.updated_at
+    `).run(input.userId, input.externalProjectId, input.workspaceId, input.workspacePath, input.displayName, input.agentType, input.providerId, JSON.stringify(input.metadata || existing?.metadata || {}), existing?.createdAt || input.createdAt || now, now);
+        return this.getProject(input.userId, input.externalProjectId);
+    }
+    getThread(userId, externalProjectId, externalThreadId) {
+        const row = this.db.prepare(`
+      SELECT user_id, external_project_id, external_thread_id, workspace_id, thread_id, workspace_path, metadata_json, created_at, updated_at
+      FROM external_threads
+      WHERE user_id = ? AND external_project_id = ? AND external_thread_id = ?
+    `).get(userId, externalProjectId, externalThreadId);
+        return row ? this.toThread(row) : undefined;
+    }
+    getThreadByThreadId(threadId) {
+        const row = this.db.prepare(`
+      SELECT user_id, external_project_id, external_thread_id, workspace_id, thread_id, workspace_path, metadata_json, created_at, updated_at
+      FROM external_threads
+      WHERE thread_id = ?
+    `).get(threadId);
+        return row ? this.toThread(row) : undefined;
+    }
+    upsertThread(input) {
+        const now = new Date().toISOString();
+        const existing = this.getThread(input.userId, input.externalProjectId, input.externalThreadId);
+        this.db.prepare(`
+      INSERT INTO external_threads (
+        user_id, external_project_id, external_thread_id, workspace_id, thread_id, workspace_path,
+        metadata_json, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(user_id, external_project_id, external_thread_id) DO UPDATE SET
+        workspace_id = excluded.workspace_id,
+        thread_id = excluded.thread_id,
+        workspace_path = excluded.workspace_path,
+        metadata_json = excluded.metadata_json,
+        updated_at = excluded.updated_at
+    `).run(input.userId, input.externalProjectId, input.externalThreadId, input.workspaceId, input.threadId, input.workspacePath, JSON.stringify(input.metadata || existing?.metadata || {}), existing?.createdAt || input.createdAt || now, now);
+        return this.getThread(input.userId, input.externalProjectId, input.externalThreadId);
+    }
+    toProject(row) {
+        return {
+            userId: row.user_id,
+            externalProjectId: row.external_project_id,
+            workspaceId: row.workspace_id,
+            workspacePath: row.workspace_path,
+            displayName: row.display_name,
+            agentType: row.agent_type,
+            providerId: row.provider_id,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            metadata: (0, utils_js_1.parseJson)(row.metadata_json, {}),
+        };
+    }
+    toThread(row) {
+        return {
+            userId: row.user_id,
+            externalProjectId: row.external_project_id,
+            externalThreadId: row.external_thread_id,
+            workspaceId: row.workspace_id,
+            threadId: row.thread_id,
+            workspacePath: row.workspace_path,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+            metadata: (0, utils_js_1.parseJson)(row.metadata_json, {}),
+        };
+    }
+}
+exports.LocalExternalStore = LocalExternalStore;

package/dist-electron/services/local-ai-core/src/acp/store/local-core-acp-store.js

@@ -13,6 +13,8 @@ const scheduler_store_js_1 = require("./scheduler-store.js");
 const security_store_js_1 = require("./security-store.js");
 const thread_store_js_1 = require("./thread-store.js");
 const workspace_registry_store_js_1 = require("./workspace-registry-store.js");
+const model_provider_store_js_1 = require("./model-provider-store.js");
+const external_store_js_1 = require("./external-store.js");
 class LocalCoreAcpStore {
     db;
     threads;
@@ -22,6 +24,8 @@ class LocalCoreAcpStore {
     scheduler;
     automationMonitors;
     platform;
+    modelProviders;
+    external;
     constructor(userDataPath) {
         const dbPath = (0, node_path_1.join)(userDataPath, 'runtime', 'local-core.db');
         (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(dbPath), { recursive: true });
@@ -37,6 +41,8 @@ class LocalCoreAcpStore {
         this.scheduler = new scheduler_store_js_1.LocalSchedulerStore(this.db);
         this.automationMonitors = new automation_monitor_store_js_1.LocalAutomationMonitorStore(this.db);
         this.platform = new platform_store_js_1.LocalPlatformStore(this.db);
+        this.modelProviders = new model_provider_store_js_1.LocalModelProviderStore(this.db);
+        this.external = new external_store_js_1.LocalExternalStore(this.db);
         (0, schema_js_1.ensureLocalCoreAcpSchema)(this.db);
     }
     close() {
@@ -95,6 +101,33 @@ class LocalCoreAcpStore {
     touchWorkspaceRegistryEntry(workspaceId) {
         this.workspaceRegistry.touch(workspaceId);
     }
+    listModelProviders() {
+        return this.modelProviders.list();
+    }
+    getModelProvider(providerId) {
+        return this.modelProviders.get(providerId);
+    }
+    upsertModelProvider(input) {
+        return this.modelProviders.upsert(input);
+    }
+    deleteModelProvider(providerId) {
+        return this.modelProviders.delete(providerId);
+    }
+    getExternalProject(userId, externalProjectId) {
+        return this.external.getProject(userId, externalProjectId);
+    }
+    upsertExternalProject(input) {
+        return this.external.upsertProject(input);
+    }
+    getExternalThread(userId, externalProjectId, externalThreadId) {
+        return this.external.getThread(userId, externalProjectId, externalThreadId);
+    }
+    getExternalThreadByThreadId(threadId) {
+        return this.external.getThreadByThreadId(threadId);
+    }
+    upsertExternalThread(input) {
+        return this.external.upsertThread(input);
+    }
     getWorkspaceSecuritySettings(workspaceId) {
         return this.security.getWorkspaceSecuritySettings(workspaceId);
     }

package/dist-electron/services/local-ai-core/src/acp/store/model-provider-store.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalModelProviderStore = void 0;
+exports.slugifyProviderId = slugifyProviderId;
+const utils_js_1 = require("./utils.js");
+class LocalModelProviderStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    list() {
+        const rows = this.db.prepare(`
+      SELECT id, name, api_key, base_url, model, models_json, thinking, env_json, created_at, updated_at
+      FROM model_providers
+      ORDER BY name ASC, id ASC
+    `).all();
+        return rows.map((row) => this.toProvider(row));
+    }
+    get(providerId) {
+        const row = this.db.prepare(`
+      SELECT id, name, api_key, base_url, model, models_json, thinking, env_json, created_at, updated_at
+      FROM model_providers
+      WHERE id = ?
+    `).get(providerId);
+        return row ? this.toProvider(row) : undefined;
+    }
+    upsert(input) {
+        const now = new Date().toISOString();
+        const requestedId = String(input.id || '').trim();
+        const id = requestedId || this.allocateProviderId(input.name);
+        const existing = this.get(id);
+        this.db.prepare(`
+      INSERT INTO model_providers (
+        id, name, api_key, base_url, model, models_json, thinking, env_json, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        name = excluded.name,
+        api_key = excluded.api_key,
+        base_url = excluded.base_url,
+        model = excluded.model,
+        models_json = excluded.models_json,
+        thinking = excluded.thinking,
+        env_json = excluded.env_json,
+        updated_at = excluded.updated_at
+    `).run(id, String(input.name || id).trim() || id, stringOrNull(input.api_key), stringOrNull(input.base_url), stringOrNull(input.model), JSON.stringify(Array.isArray(input.models) ? input.models : []), stringOrNull(input.thinking), JSON.stringify(input.env && typeof input.env === 'object' ? input.env : {}), existing?.createdAt || now, now);
+        return this.get(id);
+    }
+    delete(providerId) {
+        this.db.prepare('DELETE FROM model_providers WHERE id = ?').run(providerId);
+        return { deleted: true };
+    }
+    allocateProviderId(name) {
+        const base = slugifyProviderId(name, 'provider');
+        let candidate = base;
+        let index = 2;
+        while (this.get(candidate)) {
+            candidate = `${base}-${index}`;
+            index += 1;
+        }
+        return candidate;
+    }
+    toProvider(row) {
+        return {
+            id: row.id,
+            name: row.name,
+            api_key: row.api_key || undefined,
+            base_url: row.base_url || undefined,
+            model: row.model || undefined,
+            models: (0, utils_js_1.parseJson)(row.models_json, []),
+            thinking: row.thinking || undefined,
+            env: (0, utils_js_1.parseJson)(row.env_json, {}),
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        };
+    }
+}
+exports.LocalModelProviderStore = LocalModelProviderStore;
+function slugifyProviderId(value, fallback) {
+    return String(value || '')
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '') || fallback;
+}
+function stringOrNull(value) {
+    const normalized = String(value || '').trim();
+    return normalized || null;
+}

package/dist-electron/services/local-ai-core/src/acp/store/schema.js

@@ -176,6 +176,49 @@ function ensureLocalCoreAcpSchema(db) {
       last_opened_at TEXT
     );
     CREATE INDEX IF NOT EXISTS idx_workspace_registry_updated ON workspace_registry (updated_at DESC);
+    CREATE TABLE IF NOT EXISTS model_providers (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      api_key TEXT,
+      base_url TEXT,
+      model TEXT,
+      models_json TEXT NOT NULL DEFAULT '[]',
+      thinking TEXT,
+      env_json TEXT NOT NULL DEFAULT '{}',
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_model_providers_name ON model_providers (name);
+    CREATE TABLE IF NOT EXISTS external_projects (
+      user_id TEXT NOT NULL,
+      external_project_id TEXT NOT NULL,
+      workspace_id TEXT NOT NULL,
+      workspace_path TEXT NOT NULL,
+      display_name TEXT NOT NULL,
+      agent_type TEXT NOT NULL,
+      provider_id TEXT NOT NULL,
+      metadata_json TEXT NOT NULL DEFAULT '{}',
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY (user_id, external_project_id),
+      UNIQUE(workspace_id)
+    );
+    CREATE TABLE IF NOT EXISTS external_threads (
+      user_id TEXT NOT NULL,
+      external_project_id TEXT NOT NULL,
+      external_thread_id TEXT NOT NULL,
+      workspace_id TEXT NOT NULL,
+      thread_id TEXT NOT NULL,
+      workspace_path TEXT NOT NULL,
+      metadata_json TEXT NOT NULL DEFAULT '{}',
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY (user_id, external_project_id, external_thread_id),
+      UNIQUE(thread_id),
+      FOREIGN KEY (thread_id) REFERENCES threads(id) ON DELETE CASCADE
+    );
+    CREATE INDEX IF NOT EXISTS idx_external_threads_thread ON external_threads (thread_id);
+    CREATE INDEX IF NOT EXISTS idx_external_threads_workspace ON external_threads (workspace_id);
     CREATE TABLE IF NOT EXISTS agent_tasks (
       id TEXT PRIMARY KEY,
       workspace_id TEXT NOT NULL,