@kafca/agentdock 0.1.55 → 0.1.57

package/dist-electron/services/local-ai-core/src/thread/agent-message-policy.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composeAgentMessage = composeAgentMessage;
+const SCHEDULER_INSTRUCTION = [
+    '[Scheduler Tools]',
+    'If the user asks to create, view, edit, delete, or manually run a scheduled task for this conversation, use the Bash tool to run the local scheduler CLI.',
+    'Use these commands:',
+    'lac scheduler add --cron "<5-field cron>" --message "<exact message to send>" --desc "<short label>" [--execution-mode same-thread|side-thread]',
+    'lac scheduler list',
+    'lac scheduler list --thread',
+    'lac scheduler info <short-job-id>',
+    'lac scheduler edit <short-job-id> [--cron "<5-field cron>"] [--message "<exact message>"] [--desc "<short label>"] [--enabled true|false] [--execution-mode same-thread|side-thread]',
+    'lac scheduler del <short-job-id>',
+    'lac scheduler run <short-job-id>',
+    'Environment variables LOCAL_AI_WORKSPACE_ID, LOCAL_AI_THREAD_ID, LOCAL_AI_PLATFORM, LOCAL_AI_CHAT_ID, and LOCAL_AI_PLATFORM_USER_ID are already set when available.',
+    'Prefer relying on those variables instead of inventing your own route or creating session-only cron jobs.',
+    'By default, `lac scheduler list` shows all scheduled tasks in the current workspace. Use `lac scheduler list --thread` to show only the current conversation thread.',
+    'Use the short job id shown by `lac scheduler list`; do not add a `job:` prefix or expand it to a full UUID.',
+    'Use `--execution-mode same-thread` to reuse the current thread, or `--execution-mode side-thread` to run in a dedicated scheduled thread.',
+    'Only use the scheduler CLI when the user explicitly asks for scheduled automation.',
+    '[/Scheduler Tools]',
+].join('\n');
+const MONITOR_INSTRUCTION = [
+    '[Monitor Tools]',
+    'If the user asks to create, view, edit, delete, or manually run an event monitor for this conversation, use the Bash tool to run the local monitor CLI.',
+    'Use these commands:',
+    'lac monitor add --title "<short title>" --source stock.quote --symbol "<ticker>" --condition "<metric operator value>" --message "<exact analysis prompt>" [--cooldown 15m] [--execution-mode same-thread|side-thread]',
+    'lac monitor list',
+    'lac monitor list --thread',
+    'lac monitor info <short-monitor-id>',
+    'lac monitor edit <short-monitor-id> [--title "<title>"] [--condition "<expr>"] [--message "<exact prompt>"] [--enabled true|false] [--cooldown 15m] [--execution-mode same-thread|side-thread]',
+    'lac monitor del <short-monitor-id>',
+    'lac monitor run <short-monitor-id>',
+    'Supported stock metrics include latestPrice, change_percent, changePercent, and abs_change_percent. Example condition: "abs_change_percent >= 3".',
+    'Environment variables LOCAL_AI_WORKSPACE_ID, LOCAL_AI_THREAD_ID, LOCAL_AI_PLATFORM, LOCAL_AI_CHAT_ID, and LOCAL_AI_PLATFORM_USER_ID are already set when available.',
+    'Prefer relying on those variables instead of inventing your own route.',
+    'Use --execution-mode side-thread by default so monitor analysis does not interrupt the current conversation.',
+    'Only use the monitor CLI when the user explicitly asks for event monitoring automation.',
+    '[/Monitor Tools]',
+].join('\n');
+const CHANNEL_INSTRUCTION = [
+    '[Channel Tools]',
+    'If the user asks you to send a local file back through the current channel conversation, use the Bash tool to run the local channel CLI.',
+    'Use this command:',
+    'lac channel send-file --path "<absolute-or-workdir-relative-file-path>" [--target "<channel-chat-or-user-id>"]',
+    'By default, the file is sent to the current platform conversation from LOCAL_AI_CHAT_ID.',
+    'Use --target only when the user explicitly names a different channel chat or user id.',
+    'The CLI accepts absolute paths. Check that the file exists before sending when practical.',
+    'Only use the channel CLI when the user explicitly asks to send a file through the channel.',
+    '[/Channel Tools]',
+].join('\n');
+function composeAgentMessage(content, knowledgeBases = []) {
+    if (content.trim().startsWith('/')) {
+        return content;
+    }
+    const knowledgeBlock = knowledgeBases.length
+        ? [
+            '[Selected Knowledge Bases]',
+            ...knowledgeBases.map((base) => `- id: ${base.id} | name: ${base.name}`),
+            '[/Selected Knowledge Bases]',
+        ].join('\n')
+        : '';
+    return [
+        SCHEDULER_INSTRUCTION,
+        '',
+        MONITOR_INSTRUCTION,
+        '',
+        CHANNEL_INSTRUCTION,
+        ...(knowledgeBlock ? ['', knowledgeBlock] : []),
+        '',
+        '[User Message]',
+        content,
+        '[/User Message]',
+    ].join('\n');
+}

package/dist-electron/shared/desktop.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_SANDBOX_RUNTIME_IMAGES = exports.DESKTOP_DEPLOYMENT_PROFILES = exports.DEFAULT_SANDBOX_STATE_MOUNT_PATH = exports.DEFAULT_SANDBOX_WORKSPACE_MOUNT_PATH = exports.DEFAULT_SANDBOX_RUNTIME_IMAGE_ID = exports.DEFAULT_SANDBOX_PROVIDER_ID = exports.CHANNEL_PROTOCOL_INSTRUCTION = exports.MONITOR_PROTOCOL_INSTRUCTION = exports.SCHEDULER_PROTOCOL_INSTRUCTION = exports.LOCALCORE_ACP_AGENT_TYPE = exports.DESKTOP_INTERACTIVE_PERMISSION_AGENT_TYPES = exports.DESKTOP_PROVIDER_THINKING_OPTIONS = exports.DESKTOP_PROVIDER_PRESET_OPTIONS = exports.DESKTOP_PLATFORM_TYPE_OPTIONS = exports.DESKTOP_AGENT_TYPE_OPTIONS = exports.DESKTOP_LARK_SDK_PACKAGE = exports.DESKTOP_CLAUDECODE_ACP_PACKAGE = exports.DESKTOP_CODEX_ACP_PACKAGE = exports.DESKTOP_PI_CODING_AGENT_PACKAGE = exports.DESKTOP_PI_ACP_PACKAGE = exports.DEFAULT_DESKTOP_CLAUDECODE_MODEL = exports.DEFAULT_DESKTOP_OPENCODE_MODEL = exports.DEFAULT_DESKTOP_AGENT_TYPE = void 0;
+exports.DEFAULT_SANDBOX_RUNTIME_IMAGES = exports.DESKTOP_DEPLOYMENT_PROFILES = exports.DEFAULT_SANDBOX_STATE_MOUNT_PATH = exports.DEFAULT_SANDBOX_WORKSPACE_MOUNT_PATH = exports.DEFAULT_SANDBOX_RUNTIME_IMAGE_ID = exports.DEFAULT_SANDBOX_PROVIDER_ID = exports.LOCALCORE_ACP_AGENT_TYPE = exports.DESKTOP_INTERACTIVE_PERMISSION_AGENT_TYPES = exports.DESKTOP_PROVIDER_THINKING_OPTIONS = exports.DESKTOP_PROVIDER_PRESET_OPTIONS = exports.DESKTOP_PLATFORM_TYPE_OPTIONS = exports.DESKTOP_AGENT_TYPE_OPTIONS = exports.DESKTOP_LARK_SDK_PACKAGE = exports.DESKTOP_CLAUDECODE_ACP_PACKAGE = exports.DESKTOP_CODEX_ACP_PACKAGE = exports.DESKTOP_PI_CODING_AGENT_PACKAGE = exports.DESKTOP_PI_ACP_PACKAGE = exports.DEFAULT_DESKTOP_CLAUDECODE_MODEL = exports.DEFAULT_DESKTOP_OPENCODE_MODEL = exports.DEFAULT_DESKTOP_AGENT_TYPE = void 0;
 exports.deriveDesktopRuntimePhase = deriveDesktopRuntimePhase;
 exports.deriveDesktopRuntimeRoles = deriveDesktopRuntimeRoles;
 exports.normalizeDesktopPlatformType = normalizeDesktopPlatformType;
-exports.wrapUserMessageWithSchedulerProtocol = wrapUserMessageWithSchedulerProtocol;
 exports.getDefaultDesktopAgentModel = getDefaultDesktopAgentModel;
 exports.normalizeDesktopAgentModel = normalizeDesktopAgentModel;
 exports.normalizePermissionResponse = normalizePermissionResponse;
@@ -62,54 +61,6 @@ exports.DESKTOP_PROVIDER_PRESET_OPTIONS = [
 exports.DESKTOP_PROVIDER_THINKING_OPTIONS = ['', 'enabled', 'disabled'];
 exports.DESKTOP_INTERACTIVE_PERMISSION_AGENT_TYPES = ['pi', 'opencode', 'codex', 'claudecode', 'hermes', 'acp', 'localcore-acp'];
 exports.LOCALCORE_ACP_AGENT_TYPE = 'localcore-acp';
-exports.SCHEDULER_PROTOCOL_INSTRUCTION = [
-    '[Scheduler Tools]',
-    'If the user asks to create, view, edit, delete, or manually run a scheduled task for this conversation, use the Bash tool to run the local scheduler CLI.',
-    'Use these commands:',
-    'lac scheduler add --cron "<5-field cron>" --message "<exact message to send>" --desc "<short label>" [--execution-mode same-thread|side-thread]',
-    'lac scheduler list',
-    'lac scheduler list --thread',
-    'lac scheduler info <short-job-id>',
-    'lac scheduler edit <short-job-id> [--cron "<5-field cron>"] [--message "<exact message>"] [--desc "<short label>"] [--enabled true|false] [--execution-mode same-thread|side-thread]',
-    'lac scheduler del <short-job-id>',
-    'lac scheduler run <short-job-id>',
-    'Environment variables LOCAL_AI_WORKSPACE_ID, LOCAL_AI_THREAD_ID, LOCAL_AI_PLATFORM, LOCAL_AI_CHAT_ID, and LOCAL_AI_PLATFORM_USER_ID are already set when available.',
-    'Prefer relying on those variables instead of inventing your own route or creating session-only cron jobs.',
-    'By default, `lac scheduler list` shows all scheduled tasks in the current workspace. Use `lac scheduler list --thread` to show only the current conversation thread.',
-    'Use the short job id shown by `lac scheduler list`; do not add a `job:` prefix or expand it to a full UUID.',
-    'Use `--execution-mode same-thread` to reuse the current thread, or `--execution-mode side-thread` to run in a dedicated scheduled thread.',
-    'Only use the scheduler CLI when the user explicitly asks for scheduled automation.',
-    '[/Scheduler Tools]',
-].join('\n');
-exports.MONITOR_PROTOCOL_INSTRUCTION = [
-    '[Monitor Tools]',
-    'If the user asks to create, view, edit, delete, or manually run an event monitor for this conversation, use the Bash tool to run the local monitor CLI.',
-    'Use these commands:',
-    'lac monitor add --title "<short title>" --source stock.quote --symbol "<ticker>" --condition "<metric operator value>" --message "<exact analysis prompt>" [--cooldown 15m] [--execution-mode same-thread|side-thread]',
-    'lac monitor list',
-    'lac monitor list --thread',
-    'lac monitor info <short-monitor-id>',
-    'lac monitor edit <short-monitor-id> [--title "<title>"] [--condition "<expr>"] [--message "<exact prompt>"] [--enabled true|false] [--cooldown 15m] [--execution-mode same-thread|side-thread]',
-    'lac monitor del <short-monitor-id>',
-    'lac monitor run <short-monitor-id>',
-    'Supported stock metrics include latestPrice, change_percent, changePercent, and abs_change_percent. Example condition: "abs_change_percent >= 3".',
-    'Environment variables LOCAL_AI_WORKSPACE_ID, LOCAL_AI_THREAD_ID, LOCAL_AI_PLATFORM, LOCAL_AI_CHAT_ID, and LOCAL_AI_PLATFORM_USER_ID are already set when available.',
-    'Prefer relying on those variables instead of inventing your own route.',
-    'Use --execution-mode side-thread by default so monitor analysis does not interrupt the current conversation.',
-    'Only use the monitor CLI when the user explicitly asks for event monitoring automation.',
-    '[/Monitor Tools]',
-].join('\n');
-exports.CHANNEL_PROTOCOL_INSTRUCTION = [
-    '[Channel Tools]',
-    'If the user asks you to send a local file back through the current channel conversation, use the Bash tool to run the local channel CLI.',
-    'Use this command:',
-    'lac channel send-file --path "<absolute-or-workdir-relative-file-path>" [--target "<channel-chat-or-user-id>"]',
-    'By default, the file is sent to the current platform conversation from LOCAL_AI_CHAT_ID.',
-    'Use --target only when the user explicitly names a different channel chat or user id.',
-    'The CLI accepts absolute paths. Check that the file exists before sending when practical.',
-    'Only use the channel CLI when the user explicitly asks to send a file through the channel.',
-    '[/Channel Tools]',
-].join('\n');
 const PERMISSION_RESPONSE_MAP = {
     allow: 'allow',
     deny: 'deny',
@@ -155,20 +106,6 @@ function normalizeDesktopPlatformType(platformType) {
     }
     return normalized;
 }
-function wrapUserMessageWithSchedulerProtocol(content, extraBlocks = []) {
-    return [
-        exports.SCHEDULER_PROTOCOL_INSTRUCTION,
-        '',
-        exports.MONITOR_PROTOCOL_INSTRUCTION,
-        '',
-        exports.CHANNEL_PROTOCOL_INSTRUCTION,
-        ...extraBlocks.flatMap((block) => (block ? ['', block] : [])),
-        '',
-        '[User Message]',
-        content,
-        '[/User Message]',
-    ].join('\n');
-}
 function getDefaultDesktopAgentModel(agentType) {
     switch (String(agentType || '').trim().toLowerCase()) {
         case 'opencode':

package/dist-electron/src/components/chat/chat-controller-state.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initialChatControllerState = void 0;
+exports.isChatControllerInputLocked = isChatControllerInputLocked;
+exports.chatControllerActionForSessionOutcome = chatControllerActionForSessionOutcome;
+exports.chatControllerReducer = chatControllerReducer;
+exports.initialChatControllerState = { status: 'idle' };
+function isChatControllerInputLocked(status) {
+    return status === 'activating' ||
+        status === 'sending' ||
+        status === 'waiting' ||
+        status === 'polling' ||
+        status === 'running' ||
+        status === 'stopping' ||
+        status === 'permission_submitted';
+}
+function chatControllerActionForSessionOutcome(outcome, failedError) {
+    switch (outcome) {
+        case 'running':
+            return { type: 'stream_started' };
+        case 'settled':
+            return { type: 'settled' };
+        case 'failed':
+            return { type: 'failed', error: failedError };
+        case 'awaiting_input':
+            return { type: 'input_requested' };
+        case 'awaiting_permission':
+            return { type: 'permission_requested' };
+    }
+}
+function chatControllerReducer(state, action) {
+    switch (action.type) {
+        case 'activate_started':
+            return { status: 'activating' };
+        case 'send_started':
+            return { status: 'sending' };
+        case 'send_accepted':
+            return state.status === 'sending' ? { status: 'waiting' } : state;
+        case 'stream_started':
+            return { status: 'running' };
+        case 'input_requested':
+            return { status: 'awaiting_input' };
+        case 'permission_requested':
+            return { status: 'awaiting_permission' };
+        case 'permission_submitted':
+            return { status: 'permission_submitted' };
+        case 'stop_started':
+            return { status: 'stopping' };
+        case 'failed':
+            return { status: 'failed', error: action.error };
+        case 'timed_out':
+            return { status: 'timed_out', error: action.error };
+        case 'settled':
+            return exports.initialChatControllerState;
+        case 'transition':
+            return { status: action.status, error: action.error };
+        default:
+            return state;
+    }
+}

package/dist-electron/src/components/chat/chat-event-gate.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldAcceptRunScopedEvent = shouldAcceptRunScopedEvent;
+exports.createChatEventGate = createChatEventGate;
+const lateStreamingEventTypes = new Set([
+    'buttons',
+    'reply',
+    'preview_start',
+    'status',
+    'update_message',
+    'typing_start',
+]);
+// Stateless signals re-arm reply timeouts or re-promote task state on every
+// emission, so a legitimately repeated one (e.g. a re-delivery after a brief
+// transport blip, or two genuine identical status lines) must NOT be dropped by
+// the echo dedup. Content-bearing events keep full fingerprint dedup.
+const statelessSignalTypes = new Set(['typing_start', 'status']);
+function isStatelessSignalType(type) {
+    return statelessSignalTypes.has(type);
+}
+function shouldAcceptRunScopedEvent(event, context) {
+    const replyCtx = String(event.replyCtx || '').trim();
+    if (!replyCtx) {
+        return true;
+    }
+    const activeRunId = String(context.activeRunId || '').trim();
+    const pendingTurn = context.pendingTurn;
+    if (pendingTurn && pendingTurn.sessionKey === event.sessionKey) {
+        const pendingRunId = String(pendingTurn.runId || '').trim();
+        if (pendingRunId) {
+            return replyCtx === pendingRunId;
+        }
+        const supersededRunId = String(pendingTurn.supersededRunId || '').trim();
+        if (supersededRunId && replyCtx === supersededRunId) {
+            return false;
+        }
+    }
+    return !activeRunId || replyCtx === activeRunId;
+}
+function bridgeEventFingerprint(event) {
+    return JSON.stringify([
+        event.type,
+        event.sessionKey || '',
+        event.replyCtx || '',
+        event.previewHandle || '',
+        event.messageId || '',
+        event.bridgeKind || '',
+        event.bridgeStatus || '',
+        event.content || '',
+        event.toolCall || null,
+        event.buttonRows || event.buttons || null,
+    ]);
+}
+function coreEventFingerprint(event) {
+    return JSON.stringify(event);
+}
+function streamFromCoreEvent(event) {
+    return 'stream' in event ? event.stream : undefined;
+}
+function createChatEventGate(maxRememberedEvents = 256) {
+    const fingerprints = new Set();
+    const fingerprintOrder = [];
+    const settledTurns = new Set();
+    const settledTurnOrder = [];
+    const remember = (fingerprint) => {
+        if (fingerprints.has(fingerprint)) {
+            return false;
+        }
+        fingerprints.add(fingerprint);
+        fingerprintOrder.push(fingerprint);
+        while (fingerprintOrder.length > maxRememberedEvents) {
+            const oldest = fingerprintOrder.shift();
+            if (oldest) {
+                fingerprints.delete(oldest);
+            }
+        }
+        return true;
+    };
+    const rememberSettledTurn = (turnKey) => {
+        if (settledTurns.has(turnKey)) {
+            return;
+        }
+        settledTurns.add(turnKey);
+        settledTurnOrder.push(turnKey);
+        while (settledTurnOrder.length > maxRememberedEvents) {
+            const oldest = settledTurnOrder.shift();
+            if (oldest) {
+                settledTurns.delete(oldest);
+            }
+        }
+    };
+    return {
+        acceptBridgeEvent(event, context = {}) {
+            if (!shouldAcceptRunScopedEvent(event, context)) {
+                return false;
+            }
+            const turnKey = event.replyCtx
+                ? `${event.sessionKey || ''}:${event.replyCtx}`
+                : '';
+            if (turnKey && settledTurns.has(turnKey) && lateStreamingEventTypes.has(event.type)) {
+                return false;
+            }
+            if (!isStatelessSignalType(event.type) && !remember(`bridge:${bridgeEventFingerprint(event)}`)) {
+                return false;
+            }
+            if (turnKey && (event.type === 'typing_stop' || event.type === 'card')) {
+                rememberSettledTurn(turnKey);
+            }
+            return true;
+        },
+        acceptCoreEvent(event) {
+            const runTurnKey = event.type === 'run.updated' ? `run:${event.run.id}` : '';
+            if (event.type === 'run.updated' &&
+                settledTurns.has(runTurnKey) &&
+                (event.run.status === 'queued' || event.run.status === 'running' || event.run.status === 'awaiting_input')) {
+                return false;
+            }
+            const stream = streamFromCoreEvent(event);
+            const turnKey = stream?.replyCtx
+                ? `${stream.sessionKey || ''}:${stream.replyCtx}`
+                : '';
+            if (turnKey && settledTurns.has(turnKey) && lateStreamingEventTypes.has(stream.type)) {
+                return false;
+            }
+            const isStatelessStream = stream ? isStatelessSignalType(stream.type) : false;
+            if (!isStatelessStream && !remember(`core:${coreEventFingerprint(event)}`)) {
+                return false;
+            }
+            if (turnKey && (stream?.type === 'typing_stop' || stream?.type === 'card')) {
+                rememberSettledTurn(turnKey);
+            }
+            if (runTurnKey &&
+                event.type === 'run.updated' &&
+                (event.run.status === 'completed' || event.run.status === 'failed' || event.run.status === 'interrupted')) {
+                rememberSettledTurn(runTurnKey);
+            }
+            return true;
+        },
+        reset() {
+            fingerprints.clear();
+            fingerprintOrder.length = 0;
+            settledTurns.clear();
+            settledTurnOrder.length = 0;
+        },
+    };
+}

package/dist-electron/src/components/chat/markdown-code-block.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasMarkdownCodeBlock = hasMarkdownCodeBlock;
+const FENCED_CODE_BLOCK_RE = /(^|\n) {0,3}(?:`{3,}|~{3,})[^\n]*(?:\n|$)/;
+const INDENTED_CODE_BLOCK_RE = /(^|\n)(?: {4}|\t)\S/;
+function hasMarkdownCodeBlock(content) {
+    return FENCED_CODE_BLOCK_RE.test(content) || INDENTED_CODE_BLOCK_RE.test(content);
+}

package/dist-electron/src/pages/Desktop/workspace-model.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultSandboxForm = exports.PROVIDER_PRESETS = exports.PLATFORM_TYPE_OPTIONS = exports.CUSTOM_SELECT_VALUE = void 0;
+exports.desktopProjectWorkspaceId = desktopProjectWorkspaceId;
+exports.clone = clone;
+exports.ensureProjects = ensureProjects;
+exports.createProjectDialogDraft = createProjectDialogDraft;
+exports.normalizeProject = normalizeProject;
+exports.providerToDraft = providerToDraft;
+exports.getSelectValue = getSelectValue;
+exports.getProviderPresetValue = getProviderPresetValue;
+exports.applyProviderPreset = applyProviderPreset;
+exports.createPlatformDraft = createPlatformDraft;
+exports.getPlatformInstanceId = getPlatformInstanceId;
+exports.normalizePlatformDraft = normalizePlatformDraft;
+exports.platformSummary = platformSummary;
+exports.workDirLabel = workDirLabel;
+exports.noticeClass = noticeClass;
+exports.toSandboxForm = toSandboxForm;
+exports.fromSandboxForm = fromSandboxForm;
+const superai_contracts_1 = require("../../../packages/contracts/src/index.js");
+exports.CUSTOM_SELECT_VALUE = '__custom__';
+exports.PLATFORM_TYPE_OPTIONS = ['weixin', 'lark'];
+function desktopProjectWorkspaceId(project) {
+    return String(project.workspace_id || project.name || '').trim();
+}
+exports.PROVIDER_PRESETS = [
+    { id: 'openai', label: 'OpenAI', name: 'openai', base_url: 'https://api.openai.com/v1', model: 'gpt-4.1-mini' },
+    { id: 'openrouter', label: 'OpenRouter', name: 'openrouter', base_url: 'https://openrouter.ai/api/v1', model: 'openai/gpt-4.1-mini' },
+    { id: 'anthropic', label: 'Anthropic', name: 'anthropic', base_url: 'https://api.anthropic.com/v1', model: 'claude-3-5-haiku-latest' },
+    { id: 'deepseek', label: 'DeepSeek', name: 'deepseek', base_url: 'https://api.deepseek.com', model: 'deepseek-v4-flash' },
+    { id: 'minimax', label: 'Minimax', name: 'minimax', base_url: 'https://api.minimax.chat/v1', model: 'MiniMax-M2.5' },
+    { id: 'ollama', label: 'Ollama', name: 'ollama', base_url: 'http://127.0.0.1:11434/v1', model: 'qwen2.5-coder:7b' },
+];
+exports.defaultSandboxForm = {
+    enabled: false,
+    provider_id: superai_contracts_1.DEFAULT_SANDBOX_PROVIDER_ID,
+    runtime_image_id: (0, superai_contracts_1.defaultSandboxRuntimeImage)('pi').id,
+    server_url: 'http://127.0.0.1:8080',
+    image: 'agentdock/pi-acp:local',
+    api_key_env: 'OPEN_SANDBOX_API_KEY',
+    acp_port: '8080',
+    state_scope: 'project',
+    timeout_seconds: '7200',
+    sandbox_lifecycle: 'per_thread',
+    idle_seconds: '900',
+    warm_pool_size: '0',
+    cpu: '1000m',
+    memory: '2Gi',
+    workspace_mount_path: '/workspace',
+    state_mount_path: '/agent-state',
+};
+function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function ensureProjects(config) {
+    if (!Array.isArray(config.projects))
+        config.projects = [];
+    return config.projects;
+}
+function createProjectDialogDraft(projects) {
+    const projectNames = new Set(projects.map((project) => project.name).filter(Boolean));
+    let index = projects.length + 1;
+    while (projectNames.has(`project-${index}`)) {
+        index += 1;
+    }
+    return {
+        name: `project-${index}`,
+        agentType: superai_contracts_1.DEFAULT_DESKTOP_AGENT_TYPE,
+        workDir: '',
+        model: '',
+    };
+}
+function normalizeProject(project) {
+    return {
+        ...project,
+        agent: {
+            ...project.agent,
+            options: {
+                ...(project.agent?.options || {}),
+                model: (0, superai_contracts_1.normalizeDesktopAgentModel)(project.agent?.type, String(project.agent?.options?.model || '')),
+            },
+        },
+        platforms: project.platforms || [],
+    };
+}
+function providerToDraft(provider) {
+    return {
+        id: provider.id,
+        name: provider.name,
+        api_key: provider.api_key || '',
+        base_url: provider.base_url || '',
+        model: provider.model || '',
+        models: provider.models || [],
+        thinking: provider.thinking || '',
+        env: provider.env || {},
+    };
+}
+function getSelectValue(value, options) {
+    return options.includes(value) ? value : exports.CUSTOM_SELECT_VALUE;
+}
+function getProviderPresetValue(provider) {
+    return exports.PROVIDER_PRESETS.find((preset) => provider.name === preset.name ||
+        (preset.base_url && provider.base_url === preset.base_url) ||
+        (preset.model && provider.model === preset.model && provider.name === preset.name))?.id || exports.CUSTOM_SELECT_VALUE;
+}
+function applyProviderPreset(provider, presetId) {
+    const preset = exports.PROVIDER_PRESETS.find((item) => item.id === presetId);
+    if (!preset)
+        return provider;
+    return {
+        ...provider,
+        name: preset.name,
+        base_url: preset.base_url,
+        model: preset.model,
+    };
+}
+function createPlatformDraft(type = 'weixin') {
+    return {
+        type,
+        options: {
+            instance_id: `${type}-${crypto.randomUUID?.() || Date.now().toString(36)}`,
+        },
+    };
+}
+function getPlatformInstanceId(platform) {
+    return String(platform?.options?.instance_id || '').trim() || 'default';
+}
+function normalizePlatformDraft(platform) {
+    const type = platform.type === 'feishu' ? 'lark' : platform.type;
+    const options = platform.options && typeof platform.options === 'object' ? { ...platform.options } : {};
+    if (type === 'weixin') {
+        return {
+            type,
+            options: {
+                ...options,
+                instance_id: String(options.instance_id || '').trim(),
+            },
+        };
+    }
+    if (type === 'lark') {
+        return {
+            type,
+            options: {
+                ...options,
+                instance_id: String(options.instance_id || '').trim(),
+                app_id: String(options.app_id || '').trim(),
+                app_secret: String(options.app_secret || '').trim(),
+                downloads_dir: String(options.downloads_dir || '').trim(),
+                card_actions: options.card_actions === true,
+            },
+        };
+    }
+    return { type, options };
+}
+function platformSummary(platform) {
+    if (platform.type === 'weixin')
+        return 'WeChat QR login';
+    if (platform.type === 'lark') {
+        const appId = String(platform.options?.app_id || '').trim();
+        return appId ? `App ID ${appId}` : 'App ID and secret required';
+    }
+    return 'Custom platform';
+}
+function workDirLabel(project) {
+    const workDir = String(project.agent?.options?.work_dir || '').trim();
+    if (!workDir)
+        return 'No work directory';
+    const normalized = workDir.replace(/\/+$/, '');
+    return normalized.split('/').filter(Boolean).pop() || workDir;
+}
+function noticeClass(tone) {
+    if (tone === 'success')
+        return 'border-primary/20 bg-primary/10 text-primary dark:border-primary/25 dark:bg-primary/10 dark:text-blue-200';
+    if (tone === 'warning')
+        return 'border-amber-200 bg-amber-50 text-amber-700 dark:border-amber-400/20 dark:bg-amber-500/10 dark:text-amber-200';
+    return 'border-red-200 bg-red-50 text-red-700 dark:border-red-400/20 dark:bg-red-500/10 dark:text-red-200';
+}
+function toSandboxForm(input) {
+    return {
+        enabled: Boolean(input?.enabled),
+        provider_id: input?.provider_id || superai_contracts_1.DEFAULT_SANDBOX_PROVIDER_ID,
+        runtime_image_id: input?.runtime_image_id || exports.defaultSandboxForm.runtime_image_id,
+        server_url: input?.server_url || exports.defaultSandboxForm.server_url,
+        image: input?.image || exports.defaultSandboxForm.image,
+        api_key_env: input?.api_key_env || exports.defaultSandboxForm.api_key_env,
+        acp_port: String(input?.acp_port || exports.defaultSandboxForm.acp_port),
+        state_scope: input?.state_scope || exports.defaultSandboxForm.state_scope,
+        timeout_seconds: String(input?.timeout_seconds || exports.defaultSandboxForm.timeout_seconds),
+        sandbox_lifecycle: input?.sandbox_lifecycle || exports.defaultSandboxForm.sandbox_lifecycle,
+        idle_seconds: String(input?.idle_seconds || exports.defaultSandboxForm.idle_seconds),
+        warm_pool_size: String(input?.warm_pool_size ?? exports.defaultSandboxForm.warm_pool_size),
+        cpu: input?.cpu || exports.defaultSandboxForm.cpu,
+        memory: input?.memory || exports.defaultSandboxForm.memory,
+        workspace_mount_path: input?.workspace_mount_path || exports.defaultSandboxForm.workspace_mount_path,
+        state_mount_path: input?.state_mount_path || exports.defaultSandboxForm.state_mount_path,
+    };
+}
+function fromSandboxForm(input) {
+    return {
+        enabled: input.enabled,
+        provider_id: input.provider_id.trim() || superai_contracts_1.DEFAULT_SANDBOX_PROVIDER_ID,
+        runtime_image_id: input.runtime_image_id.trim() || exports.defaultSandboxForm.runtime_image_id,
+        state_scope: input.state_scope,
+        timeout_seconds: Number(input.timeout_seconds) || Number(exports.defaultSandboxForm.timeout_seconds),
+        sandbox_lifecycle: input.sandbox_lifecycle,
+        idle_seconds: Number(input.idle_seconds) || Number(exports.defaultSandboxForm.idle_seconds),
+        warm_pool_size: Math.max(0, Number(input.warm_pool_size) || 0),
+        cpu: input.cpu.trim() || exports.defaultSandboxForm.cpu,
+        memory: input.memory.trim() || exports.defaultSandboxForm.memory,
+    };
+}