@downcity/agent 1.1.25 → 1.1.35

package/src/core/AgentCore.ts

@@ -11,7 +11,7 @@ import fs from "fs-extra";
 import { nanoid } from "nanoid";
 import type { LanguageModel, Tool } from "ai";
 import { Logger } from "@/utils/logger/Logger.js";
-import type { BaseService } from "@/service/builtins/BaseService.js";
+import type { BasePlugin } from "@/plugin/core/BasePlugin.js";
 import type { AgentContext } from "@/core/AgentContextTypes.js";
 import type { SessionPort } from "@/core/AgentContextTypes.js";
 import type { AgentRuntime } from "@/core/AgentCoreTypes.js";
@@ -19,33 +19,36 @@ import type { DowncityConfig } from "@/types/config/DowncityConfig.js";
 import type { JsonValue } from "@/types/common/Json.js";
 import type { AgentPlatformRuntime } from "@/types/runtime/host/AgentHost.js";
 import type {
-  Plugin,
   PluginAvailability,
   PluginPort,
   PluginView,
 } from "@/plugin/types/Plugin.js";
 import type {
+  AgentMode,
+  AgentCreateSessionInput,
+  AgentListSessionsInput,
   AgentOptions,
-  AgentSessionMetadata,
+  AgentSessionSummaryPage,
   AgentSessionSystemBlock,
 } from "@/sdk/AgentSdkTypes.js";
 import { Session } from "@/sdk/Session.js";
-import { DEFAULT_SHIP_PROMPTS } from "@session/composer/system/default/SystemDomain.js";
-import { getSdkAgentSessionsRootDirPath } from "@/sdk/session/index.js";
+import { DEFAULT_SHIP_PROMPTS } from "@executor/composer/system/default/SystemDomain.js";
+import {
+  getSdkAgentSessionDirPath,
+  listAgentSessionSummaryPage,
+} from "@/sdk/session/index.js";
 import {
   createAgentPathRuntime,
   createAgentPluginConfigRuntime,
 } from "@/runtime/host/AgentHostRuntime.js";
 import { loadDowncityConfig } from "@/config/Config.js";
-import { appendExecSessionMessage } from "@/service/builtins/chat/runtime/ChatIngressStore.js";
-import { readChatMetaBySessionId } from "@/service/builtins/chat/runtime/ChatMetaStore.js";
-import { resolveChatQueueStore } from "@/service/builtins/chat/runtime/ChatQueueStore.js";
+import { readChatMetaBySessionId } from "@/plugin/builtins/chat/runtime/ChatMetaStore.js";
+import { resolveChatQueueStore } from "@/plugin/builtins/chat/runtime/ChatQueueStore.js";
 import { HookRegistry } from "@/plugin/core/HookRegistry.js";
 import { PluginRegistry } from "@/plugin/core/PluginRegistry.js";
 import { isPluginEnabled } from "@/plugin/core/Activation.js";
-import { PLUGINS } from "@/plugin/core/Plugins.js";
-import { createRegisteredServiceInstances } from "@/service/core/ServiceClassRegistry.js";
-import { setShellToolRuntime } from "@session/tools/shell/ShellToolDefinition.js";
+import { createRegisteredPluginInstances } from "@/plugin/core/PluginClassRegistry.js";
+import { setShellToolRuntime } from "@executor/tools/shell/ShellToolDefinition.js";
 
 const EMPTY_SDK_PLATFORM: AgentPlatformRuntime = {
   getGlobalEnv: () => ({}),
@@ -115,15 +118,14 @@ export class AgentCore {
   readonly id: string;
   readonly path: string;
   readonly tools: Record<string, Tool>;
-  readonly services: Map<string, BaseService>;
+  readonly pluginInstances: Map<string, BasePlugin>;
   readonly plugins: PluginPort;
 
   private readonly logger: Logger;
   private readonly sessionsById = new Map<string, Session>();
   private readonly runtime: AgentRuntime;
-  private readonly serviceContext: AgentContext;
+  private readonly agentContext: AgentContext;
   private readonly pluginRegistry: PluginRegistry;
-  private readonly pluginSystemProviders: Plugin[];
   private readonly config: DowncityConfig;
   private readonly platform: AgentPlatformRuntime;
   private readonly env: Record<string, string>;
@@ -131,7 +133,7 @@ export class AgentCore {
   private readonly defaultModel?: LanguageModel;
   private readonly configureSessionHook?: AgentOptions["configureSession"];
   private instruction: string[];
-  private servicesStartPromise: Promise<void> | null = null;
+  private pluginsStartPromise: Promise<void> | null = null;
   private configuredSessionIds = new Set<string>();
 
   constructor(options: AgentOptions) {
@@ -156,20 +158,16 @@ export class AgentCore {
     this.defaultModel = options.model;
     this.configureSessionHook = options.configureSession;
     this.config = this.loadConfig();
-    this.services = new Map<string, BaseService>();
+    this.pluginInstances = new Map<string, BasePlugin>();
     this.runtime = this.createRuntime();
-    this.registerServices({
-      explicitServices: options.services || [],
-      useBuiltinServices: options.useBuiltinServices === true,
-    });
-    this.pluginSystemProviders = this.resolvePlugins({
-      explicitPlugins: options.plugins,
-      useBuiltinPlugins: options.useBuiltinPlugins === true,
+    this.registerPlugins({
+      explicitPlugins: options.plugins || [],
+      mode: options.mode || "custom",
     });
-    this.pluginRegistry = this.createPluginRegistry(this.pluginSystemProviders);
+    this.pluginRegistry = this.createPluginRegistry([...this.pluginInstances.values()]);
     this.plugins = this.createPluginPort();
-    this.serviceContext = this.createServiceContext();
-    setShellToolRuntime(this.serviceContext.invoke);
+    this.agentContext = this.createAgentContext();
+    setShellToolRuntime(this.agentContext.invoke);
   }
 
   /**
@@ -183,7 +181,7 @@ export class AgentCore {
    * 返回实例级执行上下文。
    */
   getContext(): AgentContext {
-    return this.serviceContext;
+    return this.agentContext;
   }
 
   /**
@@ -201,53 +199,78 @@ export class AgentCore {
   }
 
   /**
-   * 获取或创建一个 session。
+   * 新建一个 session。
    */
-  async session(sessionId?: string): Promise<Session> {
-    const session = this.getOrCreateSession(sessionId);
+  async createSession(input?: AgentCreateSessionInput): Promise<Session> {
+    const explicitSessionId = String(input?.sessionId || "").trim() || undefined;
+    if (
+      explicitSessionId &&
+      (this.sessionsById.has(explicitSessionId) ||
+        (await fs.pathExists(
+          getSdkAgentSessionDirPath(this.path, this.id, explicitSessionId),
+        )))
+    ) {
+      throw new Error(`Session "${explicitSessionId}" already exists`);
+    }
+    const session = this.getOrCreateSession(explicitSessionId);
     await session.initialize();
     await this.configureSession(session);
     return session;
   }
 
   /**
-   * 列出当前 agent 的全部 session 元数据。
+   * 获取一个已存在的 session。
    */
-  async sessions(): Promise<AgentSessionMetadata[]> {
-    const rootDir = getSdkAgentSessionsRootDirPath(this.path, this.id);
-    if (!(await fs.pathExists(rootDir))) return [];
-    const entries = await fs.readdir(rootDir, { withFileTypes: true });
-    const items: AgentSessionMetadata[] = [];
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      let sessionId = "";
-      try {
-        sessionId = decodeURIComponent(entry.name);
-      } catch {
-        sessionId = entry.name;
-      }
-      if (!sessionId) continue;
-      const session = await this.session(sessionId);
-      items.push(await session.toMetadata());
+  async getSession(sessionId: string): Promise<Session> {
+    const resolvedSessionId = String(sessionId || "").trim();
+    if (!resolvedSessionId) {
+      throw new Error("getSession requires a non-empty sessionId");
+    }
+    const sessionDirPath = getSdkAgentSessionDirPath(
+      this.path,
+      this.id,
+      resolvedSessionId,
+    );
+    if (
+      !this.sessionsById.has(resolvedSessionId) &&
+      !(await fs.pathExists(sessionDirPath))
+    ) {
+      throw new Error(`Session "${resolvedSessionId}" not found`);
     }
-    items.sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
-    return items;
+    const session = this.getOrCreateSession(resolvedSessionId);
+    await session.initialize();
+    await this.configureSession(session);
+    return session;
   }
 
   /**
-   * 确保显式注入的 services 已启动。
+   * 列出当前 agent 的 session 摘要页。
    */
-  async ensureServicesStarted(): Promise<void> {
-    if (this.servicesStartPromise) {
-      await this.servicesStartPromise;
+  async listSessions(
+    input?: AgentListSessionsInput,
+  ): Promise<AgentSessionSummaryPage> {
+    return await listAgentSessionSummaryPage({
+      projectRoot: this.path,
+      agentId: this.id,
+      input,
+      executingSessionIds: new Set(this.runtime.listExecutingSessionIds()),
+    });
+  }
+
+  /**
+   * 确保当前 plugins 已启动。
+   */
+  async ensurePluginsStarted(): Promise<void> {
+    if (this.pluginsStartPromise) {
+      await this.pluginsStartPromise;
       return;
     }
-    this.servicesStartPromise = (async () => {
-      for (const service of this.services.values()) {
-        await service.lifecycle?.start?.(this.serviceContext);
+    this.pluginsStartPromise = (async () => {
+      for (const plugin of this.pluginInstances.values()) {
+        await plugin.lifecycle?.start?.(this.agentContext);
       }
     })();
-    await this.servicesStartPromise;
+    await this.pluginsStartPromise;
   }
 
   /**
@@ -269,49 +292,37 @@ export class AgentCore {
     }
   }
 
-  private registerServices(input: {
-    explicitServices: BaseService[];
-    useBuiltinServices: boolean;
+  private registerPlugins(input: {
+    explicitPlugins: BasePlugin[];
+    mode: AgentMode;
   }): void {
-    const explicitServices = input.explicitServices;
-    const builtinServices = input.useBuiltinServices
-      ? [...createRegisteredServiceInstances(this.runtime).values()]
+    const presetPlugins = input.mode === "preset"
+      ? [...createRegisteredPluginInstances(this.runtime).values()]
       : [];
-    for (const service of [...builtinServices, ...explicitServices]) {
-      const name = String(service?.name || "").trim();
+    for (const plugin of [...presetPlugins, ...input.explicitPlugins]) {
+      const name = String(plugin?.name || "").trim();
       if (!name) {
-        throw new Error("Agent received a service without a valid name");
+        throw new Error("Agent received a plugin without a valid name");
       }
-      if (this.services.has(name)) {
-        throw new Error(`Duplicate service registration: ${name}`);
+      if (this.pluginInstances.has(name)) {
+        throw new Error(`Duplicate plugin registration: ${name}`);
       }
-      service.bindAgent(this.runtime);
-      this.services.set(name, service);
+      plugin.bindAgent(this.runtime);
+      this.pluginInstances.set(name, plugin);
     }
   }
 
-  private resolvePlugins(input: {
-    explicitPlugins?: Plugin[];
-    useBuiltinPlugins: boolean;
-  }): Plugin[] {
-    const plugins = input.useBuiltinPlugins ? [...PLUGINS] : [];
-    if (Array.isArray(input.explicitPlugins)) {
-      plugins.push(...input.explicitPlugins);
-    }
-    return plugins;
-  }
-
-  private createPluginRegistry(input: Plugin[]): PluginRegistry {
+  private createPluginRegistry(input: BasePlugin[]): PluginRegistry {
     let pluginRegistryRef: PluginRegistry | null = null;
     const hookRegistry = new HookRegistry({
-      contextResolver: () => this.serviceContext,
+      contextResolver: () => this.agentContext,
       pluginEnabledChecker: (pluginName) => {
         const plugin = pluginRegistryRef?.get(pluginName);
-        return plugin ? isPluginEnabled({ plugin, context: this.serviceContext }) : false;
+        return plugin ? isPluginEnabled({ plugin, context: this.agentContext }) : false;
       },
     });
     const registry = new PluginRegistry({
-      contextResolver: () => this.serviceContext,
+      contextResolver: () => this.agentContext,
       hookRegistry,
     });
     pluginRegistryRef = registry;
@@ -350,15 +361,15 @@ export class AgentCore {
 
   private async loadPluginSystemBlocks(): Promise<AgentSessionSystemBlock[]> {
     const out: AgentSessionSystemBlock[] = [];
-    for (const plugin of this.pluginSystemProviders) {
+    for (const plugin of this.pluginInstances.values()) {
       if (typeof plugin.system !== "function") continue;
       try {
-        if (!isPluginEnabled({ plugin, context: this.serviceContext })) continue;
+        if (!isPluginEnabled({ plugin, context: this.agentContext })) continue;
         if (typeof plugin.availability === "function") {
-          const availability = await plugin.availability(this.serviceContext);
+          const availability = await plugin.availability(this.agentContext);
           if (!availability.available) continue;
         }
-        const text = String(await plugin.system(this.serviceContext)).trim();
+        const text = String(await plugin.system(this.agentContext)).trim();
         if (!text) continue;
         out.push({
           source: "plugin",
@@ -372,25 +383,6 @@ export class AgentCore {
     return out;
   }
 
-  private async loadServiceSystemBlocks(): Promise<AgentSessionSystemBlock[]> {
-    const out: AgentSessionSystemBlock[] = [];
-    for (const service of this.services.values()) {
-      if (typeof service.system !== "function") continue;
-      try {
-        const text = String(await service.system(this.serviceContext)).trim();
-        if (!text) continue;
-        out.push({
-          source: "service",
-          name: service.name,
-          content: text,
-        });
-      } catch {
-        // 单个 service system 失败不应阻断 SDK session 主链路。
-      }
-    }
-    return out;
-  }
-
   private createRuntime(): AgentRuntime {
     const runtime = {
       cwd: this.path,
@@ -400,23 +392,23 @@ export class AgentCore {
       env: this.env,
       globalEnv: this.globalEnv,
       systems: this.instruction,
-      paths: createAgentPathRuntime(this.path),
+      paths: createAgentPathRuntime(this.path, this.id),
       pluginConfig: createAgentPluginConfigRuntime(this.path),
       platform: this.platform,
       getSession: (sessionId: string): SessionPort =>
-        this.getOrCreateSession(sessionId).getServicePort(),
+        this.getOrCreateSession(sessionId).getRuntimePort(),
       listExecutingSessionIds: () =>
         [...this.sessionsById.values()]
           .filter((session) => session.isExecuting())
           .map((session) => session.id),
       getExecutingSessionCount: () =>
         [...this.sessionsById.values()].filter((session) => session.isExecuting()).length,
-      services: this.services,
+      pluginInstances: this.pluginInstances,
     } satisfies AgentRuntime;
     return runtime;
   }
 
-  private createServiceContext(): AgentContext {
+  private createAgentContext(): AgentContext {
     let context!: AgentContext;
     context = {
       agent: this.runtime,
@@ -431,40 +423,40 @@ export class AgentCore {
       pluginConfig: this.runtime.pluginConfig,
       platform: this.platform,
       session: {
-        get: (sessionId) => this.getOrCreateSession(sessionId).getServicePort(),
+        get: (sessionId) => this.getOrCreateSession(sessionId).getRuntimePort(),
         listExecutingSessionIds: () => this.runtime.listExecutingSessionIds(),
         getExecutingSessionCount: () => this.runtime.getExecutingSessionCount(),
         resolveModel: async (sessionId) => {
-          const session = await this.session(sessionId);
+          const session = await this.getSession(sessionId);
           return session.config.model;
         },
       },
       invoke: {
         invoke: async (params: {
-          service: string;
+          plugin: string;
           action: string;
           payload?: JsonValue;
         }) => {
-          const serviceName = String(params.service || "").trim();
+          const pluginName = String(params.plugin || "").trim();
           const actionName = String(params.action || "").trim();
-          const service = this.services.get(serviceName);
-          if (!service) {
+          const plugin = this.pluginInstances.get(pluginName);
+          if (!plugin) {
             return {
               success: false,
-              error: `Unknown service: ${serviceName}`,
+              error: `Unknown plugin: ${pluginName}`,
             };
           }
-          const action = service.actions[actionName];
+          const action = plugin.actions[actionName];
           if (!action) {
             return {
               success: false,
-              error: `Unknown action: ${serviceName}.${actionName}`,
+              error: `Unknown action: ${pluginName}.${actionName}`,
             };
           }
           const result = await action.execute({
             context,
             payload: params.payload ?? null,
-            serviceName,
+            pluginName,
             actionName,
           });
           if (!result.success) {
@@ -486,14 +478,6 @@ export class AgentCore {
             sessionId,
           });
         },
-        appendExecSessionMessage: async (params) => {
-          await appendExecSessionMessage({
-            context,
-            sessionId: params.sessionId,
-            text: params.text,
-            extra: params.extra,
-          });
-        },
         enqueue: (params) => resolveChatQueueStore(context).enqueue(params),
       },
       plugins: this.plugins,
@@ -514,7 +498,7 @@ export class AgentCore {
       tools: this.tools,
       logger: this.logger,
       getInstructionSystemBlocks: () => this.loadInstructionSystemBlocks(),
-      getServiceSystemBlocks: () => this.loadServiceSystemBlocks(),
+      getManagedPluginSystemBlocks: async () => [],
       getPluginSystemBlocks: () => this.loadPluginSystemBlocks(),
       ensureConfigured: async (session) => {
         await this.configureSession(session);

package/src/core/AgentCoreTypes.ts

@@ -4,7 +4,7 @@
  * 关键点（中文）
  * - 这里表达的是单个 `AgentCore` 实例持有的长期运行状态。
  * - 它不再依赖 `runtime/*` 兼容层，而是作为实例级主类型来源。
- * - Session / Service / Plugin 这些长期对象都从这里挂出。
+ * - Session / plugin 这些长期对象都从这里挂出。
  */
 
 import type { Logger } from "@/utils/logger/Logger.js";
@@ -14,7 +14,7 @@ import type {
   AgentPlatformRuntime,
   AgentPluginConfigRuntime,
 } from "@/types/runtime/host/AgentHost.js";
-import type { BaseService } from "@/service/builtins/BaseService.js";
+import type { BasePlugin } from "@/plugin/core/BasePlugin.js";
 import type { SessionPort } from "@/core/AgentContextTypes.js";
 
 /**
@@ -72,7 +72,7 @@ export interface AgentRuntime extends AgentRuntimeBase {
    *
    * 关键点（中文）
    * - 返回值是统一的 `SessionPort`，而不是裸 `Executor`。
-   * - 这样 HTTP / service / chat queue / contact 等入口都能复用同一层会话装配与执行兜底。
+   * - 这样 HTTP / plugin runtime / chat queue / contact 等入口都能复用同一层会话装配与执行兜底。
    */
   getSession(sessionId: string): SessionPort;
   /**
@@ -84,7 +84,7 @@ export interface AgentRuntime extends AgentRuntimeBase {
    */
   getExecutingSessionCount(): number;
   /**
-   * 当前 agent 持有的 service instances。
+   * 当前 agent 持有的插件实例集合。
    */
-  services: Map<string, BaseService>;
+  pluginInstances: Map<string, BasePlugin>;
 }