@kafca/agentdock 0.1.44 → 0.1.46

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

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalCoreErrorReporter = exports.LocalCoreError = void 0;
+exports.toLocalCoreErrorInfo = toLocalCoreErrorInfo;
+exports.formatUserError = formatUserError;
+exports.formatLogError = formatLogError;
+exports.errorInfoToHttpBody = errorInfoToHttpBody;
+const DEFAULTS = {
+    runtime_not_found: {
+        severity: 'error',
+        retryable: false,
+        userMessage: 'Agent runtime is not installed or is not available on PATH.',
+        suggestedAction: 'Install the runtime or update the service PATH, then retry.',
+    },
+    runtime_start_failed: {
+        severity: 'error',
+        retryable: true,
+        userMessage: 'Agent runtime failed to start.',
+        suggestedAction: 'Check the runtime installation and logs, then retry.',
+    },
+    runtime_protocol_timeout: {
+        severity: 'error',
+        retryable: true,
+        userMessage: 'Agent runtime timed out.',
+        suggestedAction: 'Retry the request. If it repeats, restart the runtime.',
+    },
+    runtime_protocol_error: {
+        severity: 'error',
+        retryable: true,
+        userMessage: 'Agent runtime returned an invalid protocol response.',
+        suggestedAction: 'Retry the request or switch to another agent.',
+    },
+    runtime_exited: {
+        severity: 'error',
+        retryable: true,
+        userMessage: 'Agent runtime exited before finishing the task.',
+        suggestedAction: 'Retry the request. If it repeats, check the runtime logs.',
+    },
+    channel_session_expired: {
+        severity: 'error',
+        retryable: false,
+        userMessage: 'Channel login has expired.',
+        suggestedAction: 'Reconnect the channel and retry.',
+    },
+    channel_auth_failed: {
+        severity: 'error',
+        retryable: false,
+        userMessage: 'Channel authentication failed.',
+        suggestedAction: 'Check the channel credentials and reconnect.',
+    },
+    channel_rate_limited: {
+        severity: 'warning',
+        retryable: true,
+        userMessage: 'Channel is rate limited.',
+        suggestedAction: 'Wait a moment and retry.',
+    },
+    channel_delivery_failed: {
+        severity: 'error',
+        retryable: true,
+        userMessage: 'Channel message delivery failed.',
+        suggestedAction: 'Retry the message or check the channel status.',
+    },
+    channel_download_failed: {
+        severity: 'warning',
+        retryable: true,
+        userMessage: 'Channel attachment download failed.',
+        suggestedAction: 'Retry or upload the attachment again.',
+    },
+    config_invalid: {
+        severity: 'error',
+        retryable: false,
+        userMessage: 'Configuration is invalid.',
+        suggestedAction: 'Fix the configuration and retry.',
+    },
+    permission_waiting: {
+        severity: 'info',
+        retryable: true,
+        userMessage: 'Agent is waiting for permission.',
+        suggestedAction: 'Choose a permission option to continue.',
+    },
+    provider_auth_failed: {
+        severity: 'error',
+        retryable: false,
+        userMessage: 'Model provider authentication failed.',
+        suggestedAction: 'Update provider credentials and retry.',
+    },
+    scheduler_delivery_failed: {
+        severity: 'error',
+        retryable: true,
+        userMessage: 'Scheduled delivery failed.',
+        suggestedAction: 'Check the target channel and retry the scheduled job.',
+    },
+    sandbox_unavailable: {
+        severity: 'error',
+        retryable: true,
+        userMessage: 'Sandbox service is unavailable.',
+        suggestedAction: 'Start OpenSandbox with docker compose and retry.',
+    },
+    sandbox_unauthorized: {
+        severity: 'error',
+        retryable: false,
+        userMessage: 'Sandbox service rejected authentication.',
+        suggestedAction: 'Check OPEN_SANDBOX_API_KEY and retry.',
+    },
+    sandbox_request_failed: {
+        severity: 'error',
+        retryable: true,
+        userMessage: 'Sandbox service request failed.',
+        suggestedAction: 'Check OpenSandbox logs and retry.',
+    },
+    sandbox_start_failed: {
+        severity: 'error',
+        retryable: true,
+        userMessage: 'Sandbox failed to start.',
+        suggestedAction: 'Check image availability, mounts, and OpenSandbox logs.',
+    },
+    sandbox_start_timeout: {
+        severity: 'error',
+        retryable: true,
+        userMessage: 'Sandbox startup timed out.',
+        suggestedAction: 'Check Docker image startup time and OpenSandbox health.',
+    },
+    sandbox_endpoint_missing: {
+        severity: 'error',
+        retryable: true,
+        userMessage: 'Sandbox ACP endpoint is unavailable.',
+        suggestedAction: 'Check that the sandbox image exposes the configured ACP port.',
+    },
+    internal_error: {
+        severity: 'error',
+        retryable: true,
+        userMessage: 'AgentDock hit an internal error.',
+        suggestedAction: 'Retry the request. If it repeats, check the logs.',
+    },
+};
+class LocalCoreError extends Error {
+    info;
+    constructor(code, message, input = {}) {
+        const defaults = DEFAULTS[code];
+        super(message || defaults.userMessage);
+        this.name = 'LocalCoreError';
+        this.info = {
+            code,
+            message: message || defaults.userMessage,
+            userMessage: input.userMessage || defaults.userMessage,
+            severity: input.severity || defaults.severity,
+            retryable: input.retryable ?? defaults.retryable,
+            suggestedAction: input.suggestedAction ?? defaults.suggestedAction,
+            details: input.details,
+            cause: input.cause,
+        };
+    }
+}
+exports.LocalCoreError = LocalCoreError;
+function toLocalCoreErrorInfo(error, fallbackCode = 'internal_error', details = {}) {
+    if (error instanceof LocalCoreError) {
+        return mergeDetails(error.info, details);
+    }
+    const maybeInfo = error?.info;
+    if (maybeInfo?.code && maybeInfo.message) {
+        return mergeDetails(maybeInfo, details);
+    }
+    const message = error instanceof Error ? error.message : String(error || '');
+    const classifiedCode = classifyErrorMessage(message, fallbackCode);
+    return new LocalCoreError(classifiedCode, message || DEFAULTS[classifiedCode].userMessage, {
+        details: Object.keys(details).length ? details : undefined,
+    }).info;
+}
+function formatUserError(info) {
+    return [info.userMessage, info.suggestedAction].filter(Boolean).join(' ');
+}
+function formatLogError(info) {
+    const suffix = info.cause ? ` cause=${info.cause}` : '';
+    return `${info.code}: ${info.message}${suffix}`;
+}
+function errorInfoToHttpBody(info) {
+    return {
+        ok: false,
+        error: info.message,
+        code: info.code,
+        errorInfo: info,
+    };
+}
+class LocalCoreErrorReporter {
+    log;
+    windowMs;
+    summaries = new Map();
+    lastLoggedAt = new Map();
+    constructor(log, windowMs = 5 * 60 * 1000) {
+        this.log = log;
+        this.windowMs = windowMs;
+    }
+    report(scope, error, context = {}, fallbackCode = 'internal_error') {
+        const info = toLocalCoreErrorInfo(error, fallbackCode, context);
+        const now = new Date();
+        const key = [
+            scope,
+            info.code,
+            context.workspaceId,
+            context.instanceId,
+            context.runtimeId,
+            context.threadId,
+        ].filter(Boolean).join(':');
+        const existing = this.summaries.get(key);
+        const summary = existing
+            ? { ...existing, count: existing.count + 1, lastSeenAt: now.toISOString(), errorInfo: info, context }
+            : { key, count: 1, firstSeenAt: now.toISOString(), lastSeenAt: now.toISOString(), errorInfo: info, context };
+        this.summaries.set(key, summary);
+        const lastLoggedAt = this.lastLoggedAt.get(key) || 0;
+        if (!lastLoggedAt || now.getTime() - lastLoggedAt >= this.windowMs) {
+            this.lastLoggedAt.set(key, now.getTime());
+            this.log(`[${scope}] ${formatLogError(info)}${summary.count > 1 ? ` count=${summary.count}` : ''}`);
+        }
+        return info;
+    }
+    list() {
+        return [...this.summaries.values()]
+            .sort((a, b) => b.lastSeenAt.localeCompare(a.lastSeenAt));
+    }
+}
+exports.LocalCoreErrorReporter = LocalCoreErrorReporter;
+function classifyErrorMessage(message, fallbackCode) {
+    const normalized = message.toLowerCase();
+    if (normalized.includes('enoent') || normalized.includes('command not found') || normalized.includes('not found on path')) {
+        return 'runtime_not_found';
+    }
+    if (normalized.includes('timed out waiting for acp') || normalized.includes('timeout')) {
+        return 'runtime_protocol_timeout';
+    }
+    if (normalized.includes('exited with code') || normalized.includes('sigterm')) {
+        return 'runtime_exited';
+    }
+    if (normalized.includes('session timeout') || normalized.includes('login expired') || normalized.includes('errcode=-14')) {
+        return 'channel_session_expired';
+    }
+    if (normalized.includes('rate limit') || normalized.includes('too many requests')) {
+        return 'channel_rate_limited';
+    }
+    if (normalized.includes('unauthorized') || normalized.includes('forbidden') || normalized.includes('auth')) {
+        return 'channel_auth_failed';
+    }
+    return fallbackCode;
+}
+function mergeDetails(info, details) {
+    if (!Object.keys(details).length) {
+        return info;
+    }
+    return {
+        ...info,
+        details: {
+            ...(info.details || {}),
+            ...details,
+        },
+    };
+}

package/dist-electron/services/local-ai-core/src/plugins/builtin/catalog.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuiltinNoopKnowledgePlugin = exports.createBuiltinCronSchedulerPlugin = void 0;
+exports.createKernelBuiltinPlugins = createKernelBuiltinPlugins;
+exports.createRuntimeAgentPlugins = createRuntimeAgentPlugins;
+exports.createRuntimeChannelPlugins = createRuntimeChannelPlugins;
+exports.createRuntimeKnowledgePlugin = createRuntimeKnowledgePlugin;
+exports.createRuntimeSchedulerPlugins = createRuntimeSchedulerPlugins;
+exports.createRuntimeMonitorPlugins = createRuntimeMonitorPlugins;
+const index_js_1 = require("../../agents/index.js");
+const monitor_stock_plugin_js_1 = require("./monitor-stock-plugin.js");
+const channel_lark_plugin_js_1 = require("./channel-lark-plugin.js");
+const channel_weixin_plugin_js_1 = require("./channel-weixin-plugin.js");
+const knowledge_ai_vector_plugin_js_1 = require("./knowledge-ai-vector-plugin.js");
+const knowledge_noop_plugin_js_1 = require("./knowledge-noop-plugin.js");
+Object.defineProperty(exports, "createBuiltinNoopKnowledgePlugin", { enumerable: true, get: function () { return knowledge_noop_plugin_js_1.createBuiltinNoopKnowledgePlugin; } });
+const scheduler_cron_plugin_js_1 = require("./scheduler-cron-plugin.js");
+Object.defineProperty(exports, "createBuiltinCronSchedulerPlugin", { enumerable: true, get: function () { return scheduler_cron_plugin_js_1.createBuiltinCronSchedulerPlugin; } });
+const scheduler_lark_plugin_js_1 = require("./scheduler-lark-plugin.js");
+const scheduler_local_plugin_js_1 = require("./scheduler-local-plugin.js");
+const scheduler_weixin_plugin_js_1 = require("./scheduler-weixin-plugin.js");
+function createKernelBuiltinPlugins() {
+    return [
+        ...(0, index_js_1.getStaticAgentRuntimeDefinitions)().map((definition) => (0, index_js_1.createBuiltinStaticAgentCapabilityPlugin)(definition.agentType, definition.displayName)),
+        (0, index_js_1.createBuiltinLocalCoreAcpAgentPlugin)(),
+        (0, scheduler_cron_plugin_js_1.createBuiltinCronSchedulerPlugin)(),
+    ];
+}
+function createRuntimeAgentPlugins(localCoreAgentPlugin) {
+    return [
+        localCoreAgentPlugin,
+        (0, index_js_1.createBuiltinPiAgentPlugin)(),
+        (0, index_js_1.createBuiltinOpencodeAgentPlugin)(),
+        (0, index_js_1.createBuiltinCodexAgentPlugin)(),
+        (0, index_js_1.createBuiltinClaudeCodeAgentPlugin)(),
+        (0, index_js_1.createBuiltinHermesAgentPlugin)(),
+    ];
+}
+function createRuntimeChannelPlugins(options) {
+    return {
+        lark: (0, channel_lark_plugin_js_1.createBuiltinLarkChannelPlugin)(options),
+        weixin: (0, channel_weixin_plugin_js_1.createBuiltinWeixinChannelPlugin)(options),
+    };
+}
+function createRuntimeKnowledgePlugin(options) {
+    return options.enableKnowledge === false
+        ? (0, knowledge_noop_plugin_js_1.createBuiltinNoopKnowledgePlugin)()
+        : (0, knowledge_ai_vector_plugin_js_1.createBuiltinAiVectorKnowledgePlugin)({
+            userDataPath: options.userDataPath,
+            getConfig: options.getConfig,
+            setConfig: options.setConfig,
+        });
+}
+function createRuntimeSchedulerPlugins(options) {
+    return [
+        (0, scheduler_local_plugin_js_1.createBuiltinLocalSchedulerPlugin)({
+            store: options.store,
+            getWorkspaceRouter: options.getWorkspaceRouter,
+        }),
+        (0, scheduler_lark_plugin_js_1.createBuiltinLarkSchedulerPlugin)({
+            store: options.store,
+            getWorkspaceRouter: options.getWorkspaceRouter,
+            getChannelRuntime: options.getLarkChannelRuntime,
+            log: options.log,
+        }),
+        (0, scheduler_weixin_plugin_js_1.createBuiltinWeixinSchedulerPlugin)({
+            store: options.store,
+            getWorkspaceRouter: options.getWorkspaceRouter,
+            getChannelRuntime: options.getWeixinChannelRuntime,
+            log: options.log,
+        }),
+    ];
+}
+function createRuntimeMonitorPlugins() {
+    return [
+        (0, monitor_stock_plugin_js_1.createBuiltinStockMonitorPlugin)(),
+    ];
+}

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

@@ -7,6 +7,7 @@ const node_path_1 = require("node:path");
 const desktop_js_1 = require("../../../../shared/desktop.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)
@@ -61,7 +62,7 @@ function toLocalCoreProjectConfig(configState, project) {
         throw new Error(`Workspace "${project.name}" requires [projects.agent.options].command for Local AI Core ACP execution.`);
     }
     const defaultArgs = launchDefaults.args || [];
-    return {
+    const launchConfig = {
         workspaceId: project.name,
         agentType,
         workDir,
@@ -74,4 +75,5 @@ function toLocalCoreProjectConfig(configState, project) {
         },
         model,
     };
+    return (0, agent_execution_backend_js_1.prepareAgentExecutionLaunch)({ configState, project, launchConfig });
 }

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

@@ -223,6 +223,21 @@ class WorkspaceRouter {
         await this.getWorkspaceRoute(workspaceId);
         return this.localCoreAcp.interruptRun(runId);
     }
+    async setThreadMode(threadId, mode) {
+        const { workspaceId } = (0, workspace_thread_id_js_1.decodeThreadId)(threadId);
+        await this.getWorkspaceRoute(workspaceId);
+        return this.localCoreAcp.setThreadMode(threadId, mode);
+    }
+    closeThreadSession(threadId) {
+        this.localCoreAcp.closeThreadSession(threadId);
+    }
+    async getWorkspaceDefaultAgentType(workspaceId) {
+        const route = await this.getWorkspaceRoute(workspaceId);
+        return route.agentType;
+    }
+    getAgentTypes() {
+        return this.options.getCapabilities().snapshot.agents.map((agent) => agent.agentType);
+    }
     getCapabilities() {
         return this.options.getCapabilities();
     }
@@ -432,10 +447,13 @@ class WorkspaceRouter {
         const defaultRoute = await this.getWorkspaceRoute(workspaceId);
         const row = this.store.getThreadRow(threadId);
         const threadAgentType = String(row?.agent_type || '').trim().toLowerCase();
-        if (!threadAgentType || threadAgentType === defaultRoute.agentType) {
-            return defaultRoute;
-        }
-        return this.getWorkspaceRoute(workspaceId, threadAgentType);
+        const route = !threadAgentType || threadAgentType === defaultRoute.agentType
+            ? defaultRoute
+            : await this.getWorkspaceRoute(workspaceId, threadAgentType);
+        const externalThread = this.store.getExternalThreadByThreadId(threadId);
+        return externalThread
+            ? withThreadWorkspacePath(route, externalThread.workspacePath)
+            : route;
     }
     async getWorkspaceRoute(workspaceId, agentTypeOverride = '') {
         const configState = await this.options.readConfigState();
@@ -477,11 +495,12 @@ class WorkspaceRouter {
         }
     }
     resolveProjectRoute(configState, project) {
+        const routeProject = this.withResolvedProjectProvider(project);
         for (const runtime of this.options.getAgentRuntimes?.() || []) {
-            if (!runtime.matchesProject(project)) {
+            if (!runtime.matchesProject(routeProject)) {
                 continue;
             }
-            const route = runtime.createRoute(configState, project);
+            const route = runtime.createRoute(configState, routeProject);
             if (route) {
                 return {
                     ...route,
@@ -489,14 +508,14 @@ class WorkspaceRouter {
                 };
             }
         }
-        if ((0, workspace_route_config_js_1.isLocalCoreNativeAcpProject)(project)) {
-            const agentType = String(project.agent?.type || '').trim().toLowerCase() || 'localcore-acp';
+        if ((0, workspace_route_config_js_1.isLocalCoreNativeAcpProject)(routeProject)) {
+            const agentType = String(routeProject.agent?.type || '').trim().toLowerCase() || 'localcore-acp';
             return {
                 kind: 'localcore-acp',
                 agentType,
                 transport: 'localcore-acp',
                 config: {
-                    ...(0, workspace_route_config_js_1.toLocalCoreProjectConfig)(configState, project),
+                    ...(0, workspace_route_config_js_1.toLocalCoreProjectConfig)(configState, routeProject),
                     agentType,
                 },
                 supportsStreamingProbe: true,
@@ -510,6 +529,23 @@ class WorkspaceRouter {
         }
         return null;
     }
+    withResolvedProjectProvider(project) {
+        const providerId = String(project.agent?.options?.provider_id || '').trim();
+        if (!providerId) {
+            return project;
+        }
+        const provider = this.store.getModelProvider(providerId);
+        if (!provider) {
+            throw new Error(`Workspace "${project.name}" references missing provider "${providerId}".`);
+        }
+        return {
+            ...project,
+            agent: {
+                ...project.agent,
+                providers: [provider],
+            },
+        };
+    }
 }
 exports.WorkspaceRouter = WorkspaceRouter;
 function createWorkspaceRouter(options) {
@@ -540,6 +576,25 @@ function withAgentTypeOverride(project, agentType) {
         },
     };
 }
+function withThreadWorkspacePath(route, workspacePath) {
+    const workDir = String(workspacePath || '').trim();
+    if (!workDir) {
+        return route;
+    }
+    return {
+        ...route,
+        config: {
+            ...route.config,
+            workDir,
+            sandbox: route.config.sandbox
+                ? {
+                    ...route.config.sandbox,
+                    workspaceHostPath: workDir,
+                }
+                : route.config.sandbox,
+        },
+    };
+}
 function isLocalSlashCommand(content) {
     const text = typeof content === 'string' ? content : String(content.displayText || '');
     const normalized = text.trim().toLowerCase();

package/dist-electron/services/local-ai-core/src/runtime/agent-runtime-detector.js

@@ -11,8 +11,11 @@ function detectInstalledAgentRuntimes(options = {}) {
     const env = options.env || process.env;
     const configuredCommands = collectConfiguredAgentCommands(options.config);
     const detectedAt = (options.now || new Date()).toISOString();
-    const versionTimeoutMs = options.versionTimeoutMs ?? 2500;
-    return desktop_js_1.DESKTOP_AGENT_TYPE_OPTIONS.map((agentType) => {
+    const versionTimeoutMs = options.versionTimeoutMs ?? 1500;
+    const agentTypes = options.runtimeId
+        ? desktop_js_1.DESKTOP_AGENT_TYPE_OPTIONS.filter((agentType) => agentType === options.runtimeId)
+        : desktop_js_1.DESKTOP_AGENT_TYPE_OPTIONS;
+    return agentTypes.map((agentType) => {
         const definition = (0, index_js_1.resolveAgentRuntimeDefinition)(agentType);
         const detection = definition?.detection;
         if (detection?.builtin || agentType === desktop_js_1.LOCALCORE_ACP_AGENT_TYPE) {

package/dist-electron/services/local-ai-core/src/runtime/config-migration.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CURRENT_DESKTOP_CONFIG_VERSION = void 0;
+exports.migrateDesktopConnectConfig = migrateDesktopConnectConfig;
+exports.normalizeDesktopProviderForStorage = normalizeDesktopProviderForStorage;
+const index_js_1 = require("../../../../packages/contracts/src/index.js");
+exports.CURRENT_DESKTOP_CONFIG_VERSION = 2;
+function migrateDesktopConnectConfig(input) {
+    const config = cloneConfig(input);
+    const warnings = [];
+    let changed = false;
+    if (config.config_version !== exports.CURRENT_DESKTOP_CONFIG_VERSION) {
+        config.config_version = exports.CURRENT_DESKTOP_CONFIG_VERSION;
+        changed = true;
+    }
+    const deploymentProfile = String(config.deployment_profile || '').trim();
+    for (const project of Array.isArray(config.projects) ? config.projects : []) {
+        const options = ensureProjectOptions(project);
+        if ('tenant_id' in options && !options.user_id) {
+            options.user_id = String(options.tenant_id || '').trim() || 'local';
+            delete options.tenant_id;
+            changed = true;
+            warnings.push(`Project "${project.name}" migrated agent.options.tenant_id to user_id.`);
+        }
+        if (Array.isArray(project.agent?.providers)) {
+            for (const provider of project.agent.providers) {
+                if (normalizeDeepSeekProvider(provider)) {
+                    changed = true;
+                    warnings.push(`Project "${project.name}" normalized a DeepSeek provider name.`);
+                }
+            }
+        }
+        const sandbox = normalizeSandboxOptions(options.sandbox);
+        if (sandbox.changed) {
+            options.sandbox = sandbox.value;
+            changed = true;
+        }
+        if (options.sandbox?.enabled) {
+            const providerMigration = migrateProjectSandboxProvider(config, options.sandbox, deploymentProfile);
+            if (providerMigration.changed) {
+                changed = true;
+            }
+            const imageMigration = migrateProjectSandboxRuntimeImage(config, project, options.sandbox);
+            if (imageMigration.changed) {
+                changed = true;
+            }
+        }
+    }
+    return { config, changed, warnings };
+}
+function ensureProjectOptions(project) {
+    project.agent ||= { type: 'pi', options: {}, providers: [] };
+    project.agent.options ||= {};
+    return project.agent.options;
+}
+function normalizeDeepSeekProvider(provider) {
+    const name = String(provider.name || '').trim().toLowerCase();
+    const baseUrl = String(provider.base_url || '').trim().toLowerCase();
+    if (name === 'deepseek' || (!name.startsWith('deepseek-') && !baseUrl.includes('deepseek.com'))) {
+        return false;
+    }
+    provider.name = 'deepseek';
+    return true;
+}
+function normalizeDesktopProviderForStorage(provider) {
+    const next = JSON.parse(JSON.stringify(provider || {}));
+    normalizeDeepSeekProvider(next);
+    return next;
+}
+function normalizeSandboxOptions(input) {
+    if (!input || typeof input !== 'object') {
+        return { value: input, changed: false };
+    }
+    const sandbox = { ...input };
+    let changed = false;
+    if (sandbox.enabled) {
+        if (!sandbox.provider_id) {
+            sandbox.provider_id = index_js_1.DEFAULT_SANDBOX_PROVIDER_ID;
+            changed = true;
+        }
+        if (!sandbox.state_scope) {
+            sandbox.state_scope = 'project';
+            changed = true;
+        }
+        if (!sandbox.sandbox_lifecycle) {
+            sandbox.sandbox_lifecycle = 'per_thread';
+            changed = true;
+        }
+        if (!sandbox.idle_seconds) {
+            sandbox.idle_seconds = 900;
+            changed = true;
+        }
+    }
+    return { value: sandbox, changed };
+}
+function migrateProjectSandboxProvider(config, sandbox, deploymentProfile) {
+    const providerId = String(sandbox.provider_id || index_js_1.DEFAULT_SANDBOX_PROVIDER_ID).trim() || index_js_1.DEFAULT_SANDBOX_PROVIDER_ID;
+    config.sandbox_providers = Array.isArray(config.sandbox_providers) ? config.sandbox_providers : [];
+    const existing = config.sandbox_providers.find((provider) => provider.id === providerId);
+    if (existing) {
+        return { changed: false };
+    }
+    const defaultProvider = (0, index_js_1.defaultSandboxProviderForProfile)(deploymentProfile);
+    config.sandbox_providers.push({
+        ...defaultProvider,
+        id: providerId,
+        type: sandbox.provider || defaultProvider.type,
+        server_url: sandbox.server_url || defaultProvider.server_url,
+        api_key_env: sandbox.api_key_env || defaultProvider.api_key_env,
+    });
+    return { changed: true };
+}
+function migrateProjectSandboxRuntimeImage(config, project, sandbox) {
+    const agentType = String(project.agent?.type || 'pi').trim().toLowerCase() || 'pi';
+    const fallback = (0, index_js_1.defaultSandboxRuntimeImage)(agentType);
+    const imageId = String(sandbox.runtime_image_id || fallback.id).trim() || fallback.id;
+    const assignedRuntimeImage = sandbox.runtime_image_id === imageId;
+    sandbox.runtime_image_id = imageId;
+    config.sandbox_runtime_images = Array.isArray(config.sandbox_runtime_images) ? config.sandbox_runtime_images : [];
+    const existing = config.sandbox_runtime_images.find((image) => image.id === imageId);
+    if (existing) {
+        let changed = !assignedRuntimeImage;
+        if (!existing.transport && isBuiltInHttpSandboxRuntimeImage(existing.id, existing.image, fallback.image)) {
+            existing.transport = fallback.transport;
+            changed = true;
+        }
+        if (!existing.entrypoint) {
+            existing.entrypoint = fallback.entrypoint;
+            changed = true;
+        }
+        return { changed };
+    }
+    config.sandbox_runtime_images.push({
+        ...fallback,
+        id: imageId,
+        image: sandbox.image || fallback.image,
+        transport: fallback.transport,
+        acp_port: sandbox.acp_port || fallback.acp_port,
+        entrypoint: sandbox.entrypoint || fallback.entrypoint,
+        runtime_command: fallback.runtime_command,
+        runtime_args: fallback.runtime_args,
+        workspace_mount_path: sandbox.workspace_mount_path || fallback.workspace_mount_path,
+        state_mount_path: sandbox.state_mount_path || fallback.state_mount_path,
+    });
+    return { changed: true };
+}
+function isBuiltInHttpSandboxRuntimeImage(id, image, fallbackImage) {
+    return id === index_js_1.DEFAULT_SANDBOX_RUNTIME_IMAGE_ID && String(image || fallbackImage).trim() === fallbackImage;
+}
+function cloneConfig(input) {
+    return JSON.parse(JSON.stringify(input || {}));
+}