@kafca/agentdock 0.1.24 → 0.1.26

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

@@ -2,8 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLarkTurnState = createLarkTurnState;
 exports.foldToolResultForLark = foldToolResultForLark;
+exports.summarizeToolCallForLark = summarizeToolCallForLark;
+exports.isPendingToolProgressForLark = isPendingToolProgressForLark;
 exports.consumeLarkBridgeEvent = consumeLarkBridgeEvent;
 exports.renderLarkBridgeEventMessage = renderLarkBridgeEventMessage;
+exports.renderLarkBridgeEventMessages = renderLarkBridgeEventMessages;
 exports.getLarkRenderedMessageId = getLarkRenderedMessageId;
 exports.setLarkRenderedMessageId = setLarkRenderedMessageId;
 function createLarkTurnState(sessionKey, sourceMessageId) {
@@ -16,6 +19,8 @@ function createLarkTurnState(sessionKey, sourceMessageId) {
         finalText: '',
         progressMessageIds: {},
         thinkingSteps: [],
+        pendingThoughtKey: undefined,
+        pendingThoughtText: undefined,
         toolCalls: [],
         statusLines: [],
         buttonRows: [],
@@ -33,6 +38,21 @@ function foldToolResultForLark(content) {
         return normalized;
     return parts.slice(0, 2).join(' - ');
 }
+function summarizeToolCallForLark(event, content) {
+    const toolCall = event.toolCall;
+    if (toolCall) {
+        const name = String(toolCall.name || '').trim() || summarizeToolContentForLark(content);
+        const input = formatToolInputForLark(toolCall.input);
+        return [name.startsWith('🔧 ') ? name : `🔧 ${name}`, input ? `参数：${input}` : '']
+            .filter(Boolean)
+            .join('\n\n');
+    }
+    return summarizeToolContentForLark(content);
+}
+function isPendingToolProgressForLark(content) {
+    const normalized = foldToolResultForLark(content).toLowerCase();
+    return normalized.startsWith('🔧 ') && normalized.includes(' - pending');
+}
 function consumeLarkBridgeEvent(turn, event, options) {
     const content = foldToolResultForLark(String(event.content || '').trim());
     if (event.type === 'typing_start') {
@@ -45,6 +65,8 @@ function consumeLarkBridgeEvent(turn, event, options) {
         turn.previewText = '';
         turn.finalText = '';
         turn.thinkingSteps = [];
+        turn.pendingThoughtKey = undefined;
+        turn.pendingThoughtText = undefined;
         turn.toolCalls = [];
         turn.buttonRows = [];
         turn.statusLines = [];
@@ -56,6 +78,12 @@ function consumeLarkBridgeEvent(turn, event, options) {
         return;
     }
     if (event.type === 'preview_start' || event.type === 'update_message') {
+        if (content.startsWith('💭 ')) {
+            turn.pendingThoughtKey = event.previewHandle || 'thinking-preview';
+            turn.pendingThoughtText = content;
+            pushUniqueLarkTurnLine(turn.thinkingSteps, content.slice(3).trim());
+            return;
+        }
         turn.previewText = content;
         return;
     }
@@ -77,6 +105,8 @@ function consumeLarkBridgeEvent(turn, event, options) {
         return;
     }
     if (content.startsWith('💭 ')) {
+        turn.pendingThoughtKey = progressKey('thinking', event);
+        turn.pendingThoughtText = content;
         pushUniqueLarkTurnLine(turn.thinkingSteps, content.slice(3).trim());
         return;
     }
@@ -95,10 +125,13 @@ function renderLarkBridgeEventMessage(turn, event) {
     const content = foldToolResultForLark(String(event.content || '').trim());
     if (event.type === 'preview_start' || event.type === 'update_message') {
         if (content.startsWith('💭 ')) {
-            return renderProgressMessage(event.previewHandle || 'thinking-preview', content);
+            return { key: 'noop', text: '', buttonRows: [], isFinal: false };
         }
         if (content.startsWith('🔧 ')) {
-            return renderProgressMessage(progressKey('tool', event), content);
+            if (isPendingToolProgressForLark(content)) {
+                return { key: 'noop', text: '', buttonRows: [], isFinal: false };
+            }
+            return renderToolMessage(progressKey('tool', event), summarizeToolCallForLark(event, content));
         }
         return {
             key: 'final',
@@ -113,10 +146,13 @@ function renderLarkBridgeEventMessage(turn, event) {
     }
     if (event.type === 'reply') {
         if (content.startsWith('💭 ')) {
-            return renderProgressMessage(progressKey('thinking', event), content);
+            return { key: 'noop', text: '', buttonRows: [], isFinal: false };
         }
         if (content.startsWith('🔧 ')) {
-            return renderProgressMessage(progressKey('tool', event), content);
+            if (isPendingToolProgressForLark(content)) {
+                return { key: 'noop', text: '', buttonRows: [], isFinal: false };
+            }
+            return renderToolMessage(progressKey('tool', event), summarizeToolCallForLark(event, content));
         }
         if (content.startsWith('⏳ ') || content.startsWith('📤 ')) {
             return renderProgressMessage(progressKey('status', event), content);
@@ -139,23 +175,35 @@ function renderLarkBridgeEventMessage(turn, event) {
         isFinal: false,
     };
 }
+function renderLarkBridgeEventMessages(turn, event) {
+    const rendered = renderLarkBridgeEventMessage(turn, event);
+    if (isThoughtBridgeEvent(event)) {
+        return [rendered];
+    }
+    const pendingThought = takePendingLarkThoughtRender(turn);
+    return pendingThought ? [pendingThought, rendered] : [rendered];
+}
+function takePendingLarkThoughtRender(turn) {
+    const text = String(turn.pendingThoughtText || '').trim();
+    if (!text) {
+        return null;
+    }
+    const rendered = renderProgressMessage(turn.pendingThoughtKey || 'thinking-preview', text);
+    turn.pendingThoughtKey = undefined;
+    turn.pendingThoughtText = undefined;
+    return rendered;
+}
 function getLarkRenderedMessageId(turn, rendered) {
     if (rendered.isFinal) {
-        if (rendered.finalSource === 'reply') {
-            return turn.replyMessageId;
-        }
-        return turn.finalMessageId || turn.messageId;
+        return turn.finalMessageId || turn.messageId || turn.replyMessageId;
     }
     return turn.progressMessageIds[rendered.key];
 }
 function setLarkRenderedMessageId(turn, rendered, messageId) {
     if (rendered.isFinal) {
-        if (rendered.finalSource === 'reply') {
-            turn.replyMessageId = messageId;
-            return;
-        }
         turn.finalMessageId = messageId;
         turn.messageId = messageId;
+        turn.replyMessageId = messageId;
         return;
     }
     turn.progressMessageIds[rendered.key] = messageId;
@@ -168,6 +216,12 @@ function renderProgressMessage(key, text) {
         isFinal: false,
     };
 }
+function renderToolMessage(key, text) {
+    return {
+        ...renderProgressMessage(key, text),
+        updatePolicy: 'create-only',
+    };
+}
 function progressKey(prefix, event) {
     const stableId = String(event.messageId || event.previewHandle || '').trim();
     if (stableId) {
@@ -176,6 +230,44 @@ function progressKey(prefix, event) {
     const content = String(event.content || '').trim().replace(/\s+/g, ' ');
     return `${prefix}:${content.slice(0, 120)}`;
 }
+function isThoughtBridgeEvent(event) {
+    if (event.type !== 'preview_start' && event.type !== 'update_message' && event.type !== 'reply') {
+        return false;
+    }
+    return String(event.content || '').trim().startsWith('💭 ');
+}
+function summarizeToolContentForLark(content) {
+    const normalized = String(content || '').trim();
+    if (!normalized.startsWith('🔧 ')) {
+        return normalized;
+    }
+    const withoutOutput = normalized.split(' - ')[0]?.trim() || normalized;
+    return withoutOutput
+        .replace(/\s+-\s*(running|pending|completed|failed|error|cancelled|canceled)\s*$/i, '')
+        .replace(/:\s*(running|pending|completed|failed|error|cancelled|canceled)\s*$/i, '')
+        .trim();
+}
+function formatToolInputForLark(input) {
+    if (input == null) {
+        return '';
+    }
+    if (typeof input === 'string') {
+        return inlineCode(input);
+    }
+    try {
+        return inlineCode(JSON.stringify(input));
+    }
+    catch {
+        return inlineCode(String(input));
+    }
+}
+function inlineCode(value) {
+    const normalized = value.trim();
+    if (!normalized) {
+        return '';
+    }
+    return `\`${normalized.replace(/`/g, '\\`')}\``;
+}
 function pushUniqueLarkTurnLine(target, value) {
     const normalized = value.trim();
     if (!normalized) {

package/dist-electron/services/local-ai-core/src/channel/shared/file-utils.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.prepareChannelFile = prepareChannelFile;
+exports.resolveChannelFilePath = resolveChannelFilePath;
 exports.sanitizeChannelFileName = sanitizeChannelFileName;
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
 async function prepareChannelFile(input) {
-    const filePath = String(input.path || '').trim();
+    const filePath = resolveChannelFilePath(input.path, input.workspacePath);
     if (!filePath) {
         throw new Error('Missing file path');
     }
@@ -27,6 +28,17 @@ async function prepareChannelFile(input) {
         fileSize: fileStat.size,
     };
 }
+function resolveChannelFilePath(filePath, workspacePath) {
+    const normalized = String(filePath || '').trim();
+    if (!normalized) {
+        return '';
+    }
+    if ((0, node_path_1.isAbsolute)(normalized)) {
+        return normalized;
+    }
+    const workspaceRoot = String(workspacePath || '').trim();
+    return workspaceRoot ? (0, node_path_1.resolve)(workspaceRoot, normalized) : normalized;
+}
 function sanitizeChannelFileName(fileName) {
     const normalized = String(fileName || '').trim().replace(/[\/\\]+/g, '_');
     return normalized || 'file';

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

@@ -643,6 +643,10 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         if (slashCommand?.name === 'new') {
             const title = slashCommand.args.join(' ').trim() || `${input.displayName || 'WeChat'} ${new Date().toLocaleTimeString()}`;
             const nextThread = await router.createThread(input.workspaceId, title);
+            const inheritedMode = this.options.store.getThreadRow?.(threadId)?.agent_mode || '';
+            if (inheritedMode && inheritedMode !== 'default') {
+                this.options.store.updateThreadAgentMode?.(nextThread.id, inheritedMode);
+            }
             const now = new Date().toISOString();
             this.options.store.updateAuthorizedUserThread(input.workspaceId, input.platformUserId, nextThread.id, platformKey);
             this.options.store.upsertPlatformThreadBinding({
@@ -676,7 +680,9 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
             return { paired: true, threadId };
         }
         this.options.store.updatePlatformThreadMessageId(input.workspaceId, input.chatId, input.platformUserId, input.contextToken || input.messageId, platformKey);
-        const wrappedText = (0, desktop_js_1.wrapUserMessageWithSchedulerProtocol)(input.text);
+        const wrappedText = slashCommand
+            ? input.text
+            : (0, desktop_js_1.wrapUserMessageWithSchedulerProtocol)(input.text);
         await router.sendThreadMessage(threadId, (0, content_js_1.createChannelThreadMessageInput)(wrappedText, input.contentParts));
         return { paired: true, threadId };
     }
@@ -920,6 +926,7 @@ class LocalCoreWeixinGateway extends node_events_1.EventEmitter {
         const file = await (0, file_utils_js_1.prepareChannelFile)({
             path: part.path,
             fileName: part.fileName,
+            workspacePath: typeof part.metadata?.workspacePath === 'string' ? part.metadata.workspacePath : undefined,
             maxBytes: WEIXIN_MAX_UPLOAD_FILE_SIZE,
             platformLabel: 'WeChat',
         });

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

@@ -75,6 +75,7 @@ async function handleChannelSendFile(flags, env, io, json) {
                 type: 'file',
                 path: filePath,
                 fileName: getFlag(flags, 'name') || undefined,
+                metadata: context.workspacePath ? { workspacePath: context.workspacePath } : undefined,
             }],
     });
     const file = result.attachments?.[0];
@@ -226,6 +227,7 @@ function resolveContext(flags, env) {
     return {
         baseUrl: getFlag(flags, 'base-url') || String(env.LOCAL_AI_CORE_BASE || DEFAULT_BASE_URL),
         workspaceId: getFlag(flags, 'workspace') || String(env.LOCAL_AI_WORKSPACE_ID || ''),
+        workspacePath: getFlag(flags, 'workspace-path') || String(env.LOCAL_AI_WORKSPACE_PATH || ''),
         threadId: normalizeMaybeBooleanFlag(getFlag(flags, 'thread')) || String(env.LOCAL_AI_THREAD_ID || ''),
         platform,
         routeType: String(env.LOCAL_AI_ROUTE_TYPE || '') || (platform === 'lark' && chatId && platformUserId ? 'channel.chat' : ''),
@@ -301,7 +303,7 @@ function printUsage(output) {
         '  lac scheduler edit <job-id> [--cron "<expr>"] [--message "<text>"] [--desc "<label>"] [--enabled true|false] [--execution-mode same-thread|side-thread] [--json]',
         '  lac scheduler del <job-id> [--json]',
         '  lac scheduler run <job-id> [--json]',
-        '  lac channel send-file --path "<file>" [--target <chat-or-user-id>] [--workspace <id>] [--platform lark] [--name <filename>] [--json]',
+        '  lac channel send-file --path "<file>" [--target <chat-or-user-id>] [--workspace <id>] [--workspace-path <path>] [--platform lark] [--name <filename>] [--json]',
     ].join('\n') + '\n');
 }
 function formatJobLine(job) {

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

@@ -163,6 +163,7 @@ function bootstrapLocalCoreRuntime(options) {
     }
     const agentPlugins = [
         localCoreAgentPlugin,
+        (0, agent_localcore_acp_plugin_js_1.createBuiltinPiAgentPlugin)(),
         (0, agent_localcore_acp_plugin_js_1.createBuiltinOpencodeAgentPlugin)(),
         (0, agent_localcore_acp_plugin_js_1.createBuiltinCodexAgentPlugin)(),
         (0, agent_localcore_acp_plugin_js_1.createBuiltinClaudeCodeAgentPlugin)(),

package/dist-electron/services/local-ai-core/src/plugins/builtin/agent-localcore-acp-plugin.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createBuiltinLocalCoreAcpAgentPlugin = createBuiltinLocalCoreAcpAgentPlugin;
 exports.createBuiltinOpencodeAgentPlugin = createBuiltinOpencodeAgentPlugin;
+exports.createBuiltinPiAgentPlugin = createBuiltinPiAgentPlugin;
 exports.createBuiltinCodexAgentPlugin = createBuiltinCodexAgentPlugin;
 exports.createBuiltinClaudeCodeAgentPlugin = createBuiltinClaudeCodeAgentPlugin;
 exports.createBuiltinStaticAgentCapabilityPlugin = createBuiltinStaticAgentCapabilityPlugin;
@@ -86,6 +87,14 @@ function createBuiltinOpencodeAgentPlugin() {
         displayName: 'OpenCode',
     });
 }
+function createBuiltinPiAgentPlugin() {
+    return createBuiltinAgentPlugin({
+        pluginId: 'builtin.agent-pi',
+        agentType: 'pi',
+        match: (normalizedAgentType) => normalizedAgentType === 'pi',
+        displayName: 'Pi',
+    });
+}
 function createBuiltinCodexAgentPlugin() {
     return createBuiltinAgentPlugin({
         pluginId: 'builtin.agent-codex',

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

@@ -4,6 +4,7 @@ exports.normalizePlatformTypes = normalizePlatformTypes;
 exports.isLocalCoreNativeAcpProject = isLocalCoreNativeAcpProject;
 exports.toLocalCoreProjectConfig = toLocalCoreProjectConfig;
 const node_module_1 = require("node:module");
+const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const desktop_js_1 = require("../../../../shared/desktop.js");
 function normalizePlatformTypes(project) {
@@ -17,10 +18,13 @@ function isLocalCoreNativeAcpProject(project) {
         || agentType === 'acp'
         || agentType === desktop_js_1.LOCALCORE_ACP_AGENT_TYPE;
 }
-function resolveOpencodeModel(project, providers) {
+function resolveAgentModel(project, providers) {
     const agentType = String(project.agent?.type || '').trim().toLowerCase();
     const rawModel = String(project.agent?.options?.model || '').trim();
     const normalizedModel = (0, desktop_js_1.normalizeDesktopAgentModel)(agentType, rawModel);
+    if (agentType === 'pi') {
+        return rawModel || getFirstProviderModelId(providers);
+    }
     if (agentType !== 'opencode') {
         return normalizedModel;
     }
@@ -31,6 +35,15 @@ function resolveOpencodeModel(project, providers) {
     }
     return normalizedModel;
 }
+function getFirstProviderModelId(providers) {
+    for (const provider of providers) {
+        const modelId = getProviderDefaultModelId(provider);
+        if (modelId) {
+            return modelId;
+        }
+    }
+    return '';
+}
 function getFirstProviderModelRef(providers) {
     for (const provider of providers) {
         const providerId = normalizeOpencodeProviderId(provider.name);
@@ -131,6 +144,108 @@ function collectProviderEnv(providers) {
     }
     return env;
 }
+function collectPiProviderEnv(providers) {
+    const env = {};
+    for (const provider of providers) {
+        const apiKey = String(provider.api_key || '').trim();
+        const envName = piProviderApiKeyEnvName(provider.name);
+        if (apiKey && envName) {
+            env[envName] = apiKey;
+        }
+    }
+    return env;
+}
+function resolvePiProviderModel(providers, model) {
+    const [explicitProvider, explicitModel] = splitProviderModelRef(model);
+    if (explicitProvider && explicitModel) {
+        return {
+            providerId: normalizePiProviderId(explicitProvider),
+            modelId: explicitModel,
+        };
+    }
+    for (const provider of providers) {
+        const providerId = normalizePiProviderId(provider.name);
+        const modelId = getProviderDefaultModelId(provider);
+        if (providerId && modelId && (!model || model === modelId)) {
+            return { providerId, modelId };
+        }
+    }
+    const fallbackProvider = providers.find((provider) => normalizePiProviderId(provider.name));
+    return {
+        providerId: normalizePiProviderId(fallbackProvider?.name),
+        modelId: model,
+    };
+}
+function splitProviderModelRef(value) {
+    const trimmed = value.trim();
+    const slashIndex = trimmed.indexOf('/');
+    if (slashIndex <= 0 || slashIndex >= trimmed.length - 1) {
+        return ['', trimmed];
+    }
+    return [trimmed.slice(0, slashIndex), trimmed.slice(slashIndex + 1)];
+}
+function normalizePiProviderId(providerName) {
+    const providerId = normalizeProviderId(providerName);
+    const aliases = {
+        google: 'google',
+        gemini: 'google',
+        kimi: 'kimi-coding',
+        moonshot: 'moonshotai',
+        zhipuai: 'zai',
+    };
+    return aliases[providerId] || providerId;
+}
+function piProviderAgentDir(configState, projectName) {
+    const configDir = (0, node_path_1.dirname)(configState.path);
+    const safeProjectName = String(projectName || 'workspace')
+        .trim()
+        .replace(/[^a-zA-Z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '') || 'workspace';
+    return (0, node_path_1.resolve)(configDir, '.pi-agent', safeProjectName);
+}
+function writeJsonFile(path, value, mode = 0o600) {
+    (0, node_fs_1.writeFileSync)(path, `${JSON.stringify(value, null, 2)}\n`, { encoding: 'utf8', mode });
+    (0, node_fs_1.chmodSync)(path, mode);
+}
+function writePiProviderRuntimeConfig(configState, project, providers, model) {
+    if (providers.length === 0) {
+        return {};
+    }
+    const { providerId, modelId } = resolvePiProviderModel(providers, model);
+    const agentDir = piProviderAgentDir(configState, project.name);
+    (0, node_fs_1.mkdirSync)(agentDir, { recursive: true, mode: 0o700 });
+    (0, node_fs_1.chmodSync)(agentDir, 0o700);
+    const auth = {};
+    const modelProviders = {};
+    for (const provider of providers) {
+        const id = normalizePiProviderId(provider.name);
+        if (!id) {
+            continue;
+        }
+        const apiKey = String(provider.api_key || '').trim();
+        const baseUrl = String(provider.base_url || '').trim();
+        if (apiKey) {
+            auth[id] = { type: 'api_key', key: apiKey };
+        }
+        if (baseUrl || apiKey) {
+            modelProviders[id] = {
+                name: String(provider.name || id).trim() || id,
+                ...(baseUrl ? { baseUrl } : {}),
+                ...(apiKey ? { apiKey } : {}),
+            };
+        }
+    }
+    writeJsonFile((0, node_path_1.resolve)(agentDir, 'auth.json'), auth);
+    writeJsonFile((0, node_path_1.resolve)(agentDir, 'models.json'), { providers: modelProviders });
+    writeJsonFile((0, node_path_1.resolve)(agentDir, 'settings.json'), {
+        ...(providerId ? { defaultProvider: providerId } : {}),
+        ...(modelId ? { defaultModel: modelId } : {}),
+        quietStartup: true,
+    }, 0o644);
+    return {
+        PI_CODING_AGENT_DIR: agentDir,
+    };
+}
 function normalizeOpencodeProviderId(value) {
     return String(value || '')
         .trim()
@@ -138,6 +253,48 @@ function normalizeOpencodeProviderId(value) {
         .replace(/[^a-z0-9._-]+/g, '-')
         .replace(/^-+|-+$/g, '');
 }
+function normalizeProviderId(value) {
+    return String(value || '')
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+function piProviderApiKeyEnvName(providerName) {
+    const providerId = normalizeProviderId(providerName);
+    const envNames = {
+        anthropic: 'ANTHROPIC_API_KEY',
+        'azure-openai': 'AZURE_OPENAI_API_KEY',
+        'azure-openai-responses': 'AZURE_OPENAI_API_KEY',
+        cerebras: 'CEREBRAS_API_KEY',
+        cloudflare: 'CLOUDFLARE_API_KEY',
+        'cloudflare-ai-gateway': 'CLOUDFLARE_API_KEY',
+        'cloudflare-workers-ai': 'CLOUDFLARE_API_KEY',
+        deepseek: 'DEEPSEEK_API_KEY',
+        fireworks: 'FIREWORKS_API_KEY',
+        gemini: 'GEMINI_API_KEY',
+        google: 'GEMINI_API_KEY',
+        groq: 'GROQ_API_KEY',
+        huggingface: 'HF_TOKEN',
+        kimi: 'KIMI_API_KEY',
+        'kimi-coding': 'KIMI_API_KEY',
+        minimax: 'MINIMAX_API_KEY',
+        'minimax-cn': 'MINIMAX_CN_API_KEY',
+        mistral: 'MISTRAL_API_KEY',
+        moonshot: 'KIMI_API_KEY',
+        openai: 'OPENAI_API_KEY',
+        opencode: 'OPENCODE_API_KEY',
+        'opencode-go': 'OPENCODE_API_KEY',
+        openrouter: 'OPENROUTER_API_KEY',
+        siliconflow: 'SILICONFLOW_API_KEY',
+        vercel: 'AI_GATEWAY_API_KEY',
+        'vercel-ai-gateway': 'AI_GATEWAY_API_KEY',
+        xai: 'XAI_API_KEY',
+        zai: 'ZAI_API_KEY',
+        zhipuai: 'ZAI_API_KEY',
+    };
+    return envNames[providerId] || '';
+}
 function opencodeProviderApiKeyEnvName(providerId) {
     const suffix = providerId.toUpperCase().replace(/[^A-Z0-9]+/g, '_').replace(/^_+|_+$/g, '');
     return `AI_WORKSTATION_OPENCODE_${suffix || 'PROVIDER'}_API_KEY`;
@@ -152,7 +309,7 @@ function shouldUseOpenAiCompatibleProvider(providerId) {
 }
 function resolveBundledAcpCommand(packageName, binName) {
     const require = (0, node_module_1.createRequire)(__filename);
-    const packageJsonPath = require.resolve(`${packageName}/package.json`);
+    const packageJsonPath = resolveBundledPackageJsonPath(packageName);
     const packageJson = require(packageJsonPath);
     const binField = packageJson.bin;
     const relativeBinPath = typeof binField === 'string'
@@ -166,12 +323,44 @@ function resolveBundledAcpCommand(packageName, binName) {
         args: [(0, node_path_1.resolve)((0, node_path_1.dirname)(packageJsonPath), relativeBinPath)],
     };
 }
+function resolveBundledPackageJsonPath(packageName) {
+    const require = (0, node_module_1.createRequire)(__filename);
+    try {
+        return require.resolve(`${packageName}/package.json`);
+    }
+    catch (error) {
+        if (error?.code !== 'ERR_PACKAGE_PATH_NOT_EXPORTED') {
+            throw error;
+        }
+    }
+    for (const basePath of require.resolve.paths(packageName) || []) {
+        const packageJsonPath = (0, node_path_1.resolve)(basePath, ...packageName.split('/'), 'package.json');
+        if ((0, node_fs_1.existsSync)(packageJsonPath)) {
+            return packageJsonPath;
+        }
+    }
+    let current = (0, node_path_1.dirname)(require.resolve(packageName));
+    while (current && current !== (0, node_path_1.dirname)(current)) {
+        const packageJsonPath = (0, node_path_1.resolve)(current, 'package.json');
+        if ((0, node_fs_1.existsSync)(packageJsonPath)) {
+            return packageJsonPath;
+        }
+        current = (0, node_path_1.dirname)(current);
+    }
+    throw new Error(`Bundled package "${packageName}" package.json could not be resolved.`);
+}
 function resolveBundledCodexCommand() {
     return resolveBundledAcpCommand(desktop_js_1.DESKTOP_CODEX_ACP_PACKAGE, 'codex-acp');
 }
 function resolveBundledClaudeCodeCommand() {
     return resolveBundledAcpCommand(desktop_js_1.DESKTOP_CLAUDECODE_ACP_PACKAGE, 'claude-agent-acp');
 }
+function resolveBundledPiAcpCommand() {
+    return resolveBundledAcpCommand(desktop_js_1.DESKTOP_PI_ACP_PACKAGE, 'pi-acp');
+}
+function resolveBundledPiCommand() {
+    return resolveBundledAcpCommand(desktop_js_1.DESKTOP_PI_CODING_AGENT_PACKAGE, 'pi').args[0];
+}
 function toLocalCoreProjectConfig(configState, project) {
     const rawWorkDir = String(project.agent?.options?.work_dir || '.').trim() || '.';
     const configDir = (0, node_path_1.dirname)(configState.path);
@@ -188,8 +377,11 @@ function toLocalCoreProjectConfig(configState, project) {
         : {};
     const agentType = String(project.agent?.type || '').trim().toLowerCase();
     const providers = Array.isArray(project.agent?.providers) ? project.agent.providers : [];
-    const model = resolveOpencodeModel(project, providers);
+    const model = resolveAgentModel(project, providers);
     const providerEnv = collectProviderEnv(providers);
+    const piProviderEnv = agentType === 'pi'
+        ? collectPiProviderEnv(providers)
+        : {};
     const opencodeInlineConfig = agentType === 'opencode'
         ? buildOpencodeInlineConfig(model, providers)
         : null;
@@ -204,6 +396,22 @@ function toLocalCoreProjectConfig(configState, project) {
             ANTHROPIC_MODEL: model,
         }
         : {};
+    const bundledPiAcp = agentType === 'pi'
+        ? resolveBundledPiAcpCommand()
+        : null;
+    const bundledPiCommand = agentType === 'pi'
+        ? resolveBundledPiCommand()
+        : '';
+    const piProviderRuntimeEnv = agentType === 'pi'
+        ? writePiProviderRuntimeConfig(configState, project, providers, model)
+        : {};
+    const inferredPiEnv = agentType === 'pi'
+        ? {
+            ...piProviderEnv,
+            ...piProviderRuntimeEnv,
+            PI_ACP_PI_COMMAND: bundledPiCommand,
+        }
+        : {};
     const bundledCodex = agentType === 'codex'
         ? resolveBundledCodexCommand()
         : null;
@@ -212,18 +420,20 @@ function toLocalCoreProjectConfig(configState, project) {
         : null;
     const inferredCommand = agentType === 'opencode'
         ? 'opencode'
-        : bundledCodex?.command || bundledClaudeCode?.command || '';
+        : bundledPiAcp?.command || bundledCodex?.command || bundledClaudeCode?.command || '';
     const command = String(project.agent?.options?.command || inferredCommand).trim();
     if (!command) {
         throw new Error(`Workspace "${project.name}" requires [projects.agent.options].command for Local AI Core ACP execution.`);
     }
     const defaultArgs = agentType === 'opencode'
         ? ['acp']
-        : agentType === 'codex'
-            ? [...(bundledCodex?.args || [])]
-            : agentType === 'claudecode'
-                ? [...(bundledClaudeCode?.args || [])]
-                : [];
+        : agentType === 'pi'
+            ? [...(bundledPiAcp?.args || [])]
+            : agentType === 'codex'
+                ? [...(bundledCodex?.args || [])]
+                : agentType === 'claudecode'
+                    ? [...(bundledClaudeCode?.args || [])]
+                    : [];
     return {
         workspaceId: project.name,
         agentType,
@@ -231,9 +441,10 @@ function toLocalCoreProjectConfig(configState, project) {
         command,
         args: args.length > 0 ? args : defaultArgs,
         env: {
-            ...providerEnv,
             ...inferredOpencodeEnv,
             ...inferredClaudeCodeEnv,
+            ...inferredPiEnv,
+            ...providerEnv,
             ...env,
         },
         model,