ACP Service

Author: linyuan.yang

packages/channel.xiaoai/tsconfig.tsbuildinfo

@@ -1,10 +1,10 @@
-import { ACPAgentService } from "scorpio.ai";
+import { PersistentACPAgentService } from "scorpio.ai";
 import { LoggerService } from "../Core/LoggerService";
 
 const logger = LoggerService.getLogger('ACPAgentPool');
 
 export interface ACPPoolEntry {
-    instance: ACPAgentService;
+    instance: PersistentACPAgentService;
     key: string;
     agentId: string;
     agentName: string;
@@ -35,53 +35,48 @@ export class ACPAgentPool {
         return ACPAgentPool.inst;
     }
 
-    async acquire(
-        key: string,
-        agentId: string,
-        agentName: string,
-        dbSessionId: string,
-        configHash: string,
-        factory: () => Promise<ACPAgentService>,
-    ): Promise<ACPAgentService> {
+    async tryGet(key: string, configHash: string): Promise<PersistentACPAgentService | null> {
         const existing = this.pool.get(key);
+        if (!existing) return null;
 
-        if (existing) {
-            if (existing.configHash !== configHash) {
-                logger.info(`Config changed for ${key}, recreating`);
-                await existing.instance.forceDispose();
-                this.pool.delete(key);
-            } else if (existing.instance.isAlive()) {
-                existing.lastAccessed = Date.now();
-                return existing.instance;
-            } else {
-                logger.warn(`Dead process for ${key}, recreating`);
-                this.pool.delete(key);
-            }
+        if (existing.configHash !== configHash) {
+            logger.info(`Config changed for ${key}, recreating`);
+            await existing.instance.forceDispose();
+            this.pool.delete(key);
+            return null;
+        }
+
+        if (!existing.instance.isAlive()) {
+            logger.warn(`Dead process for ${key}, recreating`);
+            this.pool.delete(key);
+            return null;
         }
 
-        const instance = await factory();
+        existing.lastAccessed = Date.now();
+        return existing.instance;
+    }
+
+    put(key: string, instance: PersistentACPAgentService, meta: { agentId: string; agentName: string; dbSessionId: string; configHash: string }): void {
         instance.pooled = true;
-        instance.onExit = () => {
+        instance.onPoolExit = () => {
             const entry = this.pool.get(key);
             if (entry?.instance === instance) {
                 logger.warn(`ACP process died unexpectedly: ${key}`);
                 this.pool.delete(key);
             }
         };
 
-        const entry: ACPPoolEntry = {
+        this.pool.set(key, {
             instance,
             key,
-            agentId,
-            agentName,
-            dbSessionId,
-            configHash,
+            agentId: meta.agentId,
+            agentName: meta.agentName,
+            dbSessionId: meta.dbSessionId,
+            configHash: meta.configHash,
             createdAt: Date.now(),
             lastAccessed: Date.now(),
-        };
-        this.pool.set(key, entry);
+        });
         logger.info(`Cached ACP instance: ${key}`);
-        return instance;
     }
 
     async release(key: string): Promise<void> {

packages/desktop/src-tauri/icons/icon.icns

@@ -1,6 +1,6 @@
 import {
     AgentServiceBase, SingleAgentService, GenerativeAgentService,
-    ACPAgentService, T_ACPCommand, T_ACPArgs, T_ACPEnv, T_ACPSessionMode, T_ACPWorkPath,
+    TransientACPAgentService, PersistentACPAgentService, T_ACPCommand, T_ACPArgs, T_ACPEnv, T_ACPWorkPath,
     IModelService,
     IAgentSaverService, AgentMemorySaver, ILoggerService,
     ConversationCompactor, IConversationCompactor, T_SummaryModelService, T_CompactPromptTemplate,
@@ -274,37 +274,34 @@ export class AgentFactory {
     ): Promise<AgentServiceBase> {
         const workPath = options.workPath ?? process.cwd();
         const sessionMode = entry.sessionMode ?? ACPSessionMode.Persistent;
+        const acpArgs = {
+            [T_ACPCommand]: entry.command,
+            [T_ACPArgs]: entry.args ?? [],
+            [T_ACPWorkPath]: workPath,
+            ...(entry.env && { [T_ACPEnv]: entry.env }),
+        };
 
         if (sessionMode === ACPSessionMode.Persistent) {
             const pool = ACPAgentPool.getInstance();
             const key = `${options.agentId}:${options.dbSessionId}`;
             const agentName = entry.name ?? options.agentId;
             const configHash = JSON.stringify({ command: entry.command, args: entry.args ?? [], env: entry.env ?? {}, workPath });
 
-            return pool.acquire(key, options.agentId, agentName, options.dbSessionId, configHash, async () => {
-                const sub = new ServiceContainer();
-                if (container.isRegistered(ILoggerService))
-                    sub.registerInstance(ILoggerService, await container.resolve(ILoggerService));
-                if (container.isRegistered(IAgentSaverService))
-                    sub.registerInstance(IAgentSaverService, await container.resolve(IAgentSaverService));
-                sub.registerWithArgs(ACPAgentService, {
-                    [T_ACPCommand]: entry.command,
-                    [T_ACPArgs]: entry.args ?? [],
-                    [T_ACPWorkPath]: workPath,
-                    ...(entry.env && { [T_ACPEnv]: entry.env }),
-                    [T_ACPSessionMode]: ACPSessionMode.Persistent,
-                });
-                return sub.resolve<ACPAgentService>(ACPAgentService);
-            });
+            const cached = await pool.tryGet(key, configHash);
+            if (cached) return cached;
+
+            const sub = new ServiceContainer();
+            if (container.isRegistered(ILoggerService))
+                sub.registerInstance(ILoggerService, await container.resolve(ILoggerService));
+            if (container.isRegistered(IAgentSaverService))
+                sub.registerInstance(IAgentSaverService, await container.resolve(IAgentSaverService));
+            sub.registerWithArgs(PersistentACPAgentService, acpArgs);
+            const instance = await sub.resolve<PersistentACPAgentService>(PersistentACPAgentService);
+            pool.put(key, instance, { agentId: options.agentId, agentName, dbSessionId: options.dbSessionId, configHash });
+            return instance;
         }
 
-        container.registerWithArgs(ACPAgentService, {
-            [T_ACPCommand]: entry.command,
-            [T_ACPArgs]: entry.args ?? [],
-            [T_ACPWorkPath]: workPath,
-            ...(entry.env && { [T_ACPEnv]: entry.env }),
-            [T_ACPSessionMode]: ACPSessionMode.Transient,
-        });
-        return container.resolve(ACPAgentService);
+        container.registerWithArgs(TransientACPAgentService, acpArgs);
+        return container.resolve(TransientACPAgentService);
     }
 }