@downcity/agent 1.1.66 → 1.1.70

package/src/rpc/Client.ts

@@ -17,8 +17,19 @@ import type {
   AgentSessionSummaryPage,
   AgentSessionSystemSnapshot,
 } from "@/types/agent/AgentTypes.js";
+import type { JsonValue } from "@/types/common/Json.js";
+import type {
+  PluginActionResult,
+  PluginAvailability,
+  PluginCommandResult,
+  PluginStateControlAction,
+  PluginStateControlResult,
+  PluginStateSnapshot,
+  PluginView,
+} from "@/plugin/types/Plugin.js";
 import type { AgentSessionEvent } from "@/types/sdk/AgentSessionEvent.js";
 import type { AgentSessionPromptInput } from "@/types/sdk/AgentSessionPrompt.js";
+import type { ControlSessionExecuteAttachmentInput } from "@/runtime/server/http/control/types/ControlSessionExecute.js";
 
 type RpcClientRequest =
   | {
@@ -82,6 +93,82 @@ type RpcClientRequest =
       params: {
         subscriptionId: string;
       };
+    }
+  | {
+      id: string;
+      method: "internal.status.get";
+    }
+  | {
+      id: string;
+      method: "internal.sessions.execute";
+      params: {
+        sessionId: string;
+        instructions: string;
+        attachments?: ControlSessionExecuteAttachmentInput[];
+      };
+    }
+  | {
+      id: string;
+      method: "internal.sessions.clear_messages";
+      params: {
+        sessionId: string;
+      };
+    }
+  | {
+      id: string;
+      method: "internal.sessions.clear_chat_history";
+      params: {
+        sessionId: string;
+      };
+    }
+  | {
+      id: string;
+      method: "internal.sessions.resolve_system_prompt";
+      params: {
+        sessionId: string;
+      };
+    }
+  | {
+      id: string;
+      method: "internal.plugins.catalog";
+    }
+  | {
+      id: string;
+      method: "internal.plugins.list";
+    }
+  | {
+      id: string;
+      method: "internal.plugins.control";
+      params: {
+        pluginName: string;
+        action: PluginStateControlAction;
+      };
+    }
+  | {
+      id: string;
+      method: "internal.plugins.command";
+      params: {
+        pluginName: string;
+        command: string;
+        payload?: JsonValue;
+        schedule?: JsonValue;
+      };
+    }
+  | {
+      id: string;
+      method: "internal.plugins.availability";
+      params: {
+        pluginName: string;
+      };
+    }
+  | {
+      id: string;
+      method: "internal.plugins.action";
+      params: {
+        pluginName: string;
+        actionName: string;
+        payload?: JsonValue;
+      };
     };
 
 type RpcResponseFrame = {
@@ -132,6 +219,60 @@ export interface RpcSessionSubscription {
   unsubscribe(): Promise<void>;
 }
 
+/**
+ * RPC system prompt 分段条目。
+ */
+export interface RpcSystemPromptSectionItem {
+  /** 消息序号。 */
+  index: number;
+  /** system message 文本内容。 */
+  content: string;
+}
+
+/**
+ * RPC system prompt 分段。
+ */
+export interface RpcSystemPromptSection {
+  /** 分段稳定 key。 */
+  key: string;
+  /** 分段展示标题。 */
+  title: string;
+  /** 分段内消息条目。 */
+  items: RpcSystemPromptSectionItem[];
+}
+
+/**
+ * RPC system prompt 响应。
+ */
+export interface RpcSystemPromptPayload {
+  /** 请求是否成功。 */
+  success?: boolean;
+  /** 当前 session id。 */
+  sessionId: string;
+  /** system message 总数。 */
+  totalMessages: number;
+  /** system message 总字符数。 */
+  totalChars: number;
+  /** system message 分段。 */
+  sections: RpcSystemPromptSection[];
+}
+
+/**
+ * RPC session execute 响应。
+ */
+export interface RpcSessionExecuteResult {
+  /** 执行是否成功。 */
+  success: boolean;
+  /** 失败错误信息。 */
+  error?: string;
+  /** assistant 原始消息。 */
+  assistantMessage?: unknown;
+  /** 用户可见文本。 */
+  userVisible: string;
+  /** 是否进入队列。 */
+  queued: boolean;
+}
+
 /**
  * RPC Client。
  */
@@ -288,6 +429,175 @@ export class RpcClient {
     };
   }
 
+  /**
+   * 读取 Agent 内部状态。
+   */
+  async get_internal_status(): Promise<{ status: string }> {
+    return await this.request<{ status: string }>({
+      method: "internal.status.get",
+    });
+  }
+
+  /**
+   * 在 Agent runtime 内执行一轮 session 指令。
+   */
+  async execute_internal_session(params: {
+    session_id: string;
+    instructions: string;
+    attachments?: ControlSessionExecuteAttachmentInput[];
+  }): Promise<{ sessionId: string; result: RpcSessionExecuteResult }> {
+    return await this.request<{
+      sessionId: string;
+      result: RpcSessionExecuteResult;
+    }>({
+      method: "internal.sessions.execute",
+      params: {
+        sessionId: params.session_id,
+        instructions: params.instructions,
+        ...(params.attachments !== undefined ? { attachments: params.attachments } : {}),
+      },
+    });
+  }
+
+  /**
+   * 清空 Agent runtime 内指定 session 的消息。
+   */
+  async clear_internal_session_messages(
+    session_id: string,
+  ): Promise<{ sessionId: string; cleared: boolean }> {
+    return await this.request<{ sessionId: string; cleared: boolean }>({
+      method: "internal.sessions.clear_messages",
+      params: {
+        sessionId: session_id,
+      },
+    });
+  }
+
+  /**
+   * 清空 Agent runtime 内指定 session 的 chat history。
+   */
+  async clear_internal_chat_history(
+    session_id: string,
+  ): Promise<{ sessionId: string; cleared: boolean }> {
+    return await this.request<{ sessionId: string; cleared: boolean }>({
+      method: "internal.sessions.clear_chat_history",
+      params: {
+        sessionId: session_id,
+      },
+    });
+  }
+
+  /**
+   * 解析 Agent runtime 内指定 session 的 system prompt。
+   */
+  async resolve_internal_system_prompt(
+    session_id: string,
+  ): Promise<RpcSystemPromptPayload> {
+    return await this.request<RpcSystemPromptPayload>({
+      method: "internal.sessions.resolve_system_prompt",
+      params: {
+        sessionId: session_id,
+      },
+    });
+  }
+
+  /**
+   * 列出 Agent runtime 注册的 plugin catalog。
+   */
+  async list_internal_plugin_catalog(): Promise<PluginView[]> {
+    const data = await this.request<{ plugins: PluginView[] }>({
+      method: "internal.plugins.catalog",
+    });
+    return Array.isArray(data.plugins) ? data.plugins : [];
+  }
+
+  /**
+   * 列出 Agent runtime 内 plugin 状态。
+   */
+  async list_internal_plugin_states(): Promise<PluginStateSnapshot[]> {
+    const data = await this.request<{ plugins: PluginStateSnapshot[] }>({
+      method: "internal.plugins.list",
+    });
+    return Array.isArray(data.plugins) ? data.plugins : [];
+  }
+
+  /**
+   * 控制 Agent runtime 内 plugin 生命周期。
+   */
+  async control_internal_plugin(params: {
+    plugin_name: string;
+    action: PluginStateControlAction;
+  }): Promise<PluginStateControlResult> {
+    return await this.request<PluginStateControlResult>({
+      method: "internal.plugins.control",
+      params: {
+        pluginName: params.plugin_name,
+        action: params.action,
+      },
+    });
+  }
+
+  /**
+   * 执行 Agent runtime 内 plugin command。
+   */
+  async run_internal_plugin_command(params: {
+    plugin_name: string;
+    command: string;
+    payload?: JsonValue;
+    schedule?: JsonValue;
+  }): Promise<PluginCommandResult & { plugin?: PluginStateSnapshot }> {
+    return await this.request<PluginCommandResult & { plugin?: PluginStateSnapshot }>({
+      method: "internal.plugins.command",
+      params: {
+        pluginName: params.plugin_name,
+        command: params.command,
+        ...(params.payload !== undefined ? { payload: params.payload } : {}),
+        ...(params.schedule !== undefined ? { schedule: params.schedule } : {}),
+      },
+    });
+  }
+
+  /**
+   * 检查 Agent runtime 内 plugin 可用性。
+   */
+  async get_internal_plugin_availability(
+    plugin_name: string,
+  ): Promise<PluginAvailability> {
+    const data = await this.request<{
+      availability: PluginAvailability;
+    }>({
+      method: "internal.plugins.availability",
+      params: {
+        pluginName: plugin_name,
+      },
+    });
+    return data.availability;
+  }
+
+  /**
+   * 执行 Agent runtime 内 plugin action。
+   */
+  async run_internal_plugin_action(params: {
+    plugin_name: string;
+    action_name: string;
+    payload?: JsonValue;
+  }): Promise<PluginActionResult<JsonValue> & {
+    pluginName?: string;
+    actionName?: string;
+  }> {
+    return await this.request<PluginActionResult<JsonValue> & {
+      pluginName?: string;
+      actionName?: string;
+    }>({
+      method: "internal.plugins.action",
+      params: {
+        pluginName: params.plugin_name,
+        actionName: params.action_name,
+        ...(params.payload !== undefined ? { payload: params.payload } : {}),
+      },
+    });
+  }
+
   /**
    * 关闭底层连接。
    */

package/src/rpc/Server.ts

@@ -8,12 +8,32 @@
  */
 
 import net from "node:net";
+import fs from "fs-extra";
+import { dirname } from "node:path";
+import type { SystemModelMessage } from "ai";
 import type {
   AgentListSessionsInput,
   AgentSessionCollection,
 } from "@/types/agent/AgentTypes.js";
 import type { AgentSessionPromptInput } from "@/types/sdk/AgentSessionPrompt.js";
 import type { AgentSessionEvent } from "@/types/sdk/AgentSessionEvent.js";
+import type { AgentContext } from "@/types/runtime/agent/AgentContext.js";
+import type { AgentRuntime } from "@/types/runtime/agent/AgentRuntime.js";
+import type { JsonValue } from "@/types/common/Json.js";
+import type { PluginStateControlAction } from "@/plugin/types/Plugin.js";
+import type { ControlSessionExecuteAttachmentInput } from "@/runtime/server/http/control/types/ControlSessionExecute.js";
+import {
+  getDowncityChatHistoryPath,
+  getDowncitySessionMessagesPath,
+} from "@/config/Paths.js";
+import { resolveSessionSystemMessages } from "@/executor/composer/system/default/SystemDomain.js";
+import {
+  controlPluginState,
+  listPluginStates,
+} from "@/plugin/core/PluginStateController.js";
+import { parsePluginCommandRequestBody } from "@/plugin/core/PluginCommandRequest.js";
+import { runPluginCommand } from "@/plugin/core/PluginActionRunner.js";
+import { executeBySessionId } from "@/runtime/server/http/control/ExecuteBySession.js";
 
 type RpcSessionRequest =
   | {
@@ -84,6 +104,82 @@ type RpcSessionRequest =
       params: {
         subscriptionId: string;
       };
+    }
+  | {
+      id: string;
+      method: "internal.status.get";
+    }
+  | {
+      id: string;
+      method: "internal.sessions.execute";
+      params: {
+        sessionId: string;
+        instructions: string;
+        attachments?: ControlSessionExecuteAttachmentInput[];
+      };
+    }
+  | {
+      id: string;
+      method: "internal.sessions.clear_messages";
+      params: {
+        sessionId: string;
+      };
+    }
+  | {
+      id: string;
+      method: "internal.sessions.clear_chat_history";
+      params: {
+        sessionId: string;
+      };
+    }
+  | {
+      id: string;
+      method: "internal.sessions.resolve_system_prompt";
+      params: {
+        sessionId: string;
+      };
+    }
+  | {
+      id: string;
+      method: "internal.plugins.catalog";
+    }
+  | {
+      id: string;
+      method: "internal.plugins.list";
+    }
+  | {
+      id: string;
+      method: "internal.plugins.control";
+      params: {
+        pluginName: string;
+        action: PluginStateControlAction;
+      };
+    }
+  | {
+      id: string;
+      method: "internal.plugins.command";
+      params: {
+        pluginName: string;
+        command: string;
+        payload?: JsonValue;
+        schedule?: JsonValue;
+      };
+    }
+  | {
+      id: string;
+      method: "internal.plugins.availability";
+      params: {
+        pluginName: string;
+      };
+    }
+  | {
+      id: string;
+      method: "internal.plugins.action";
+      params: {
+        pluginName: string;
+        actionName: string;
+        payload?: JsonValue;
+      };
     };
 
 type RpcSuccessFrame = {
@@ -119,6 +215,10 @@ export interface RpcServerStartOptions {
   host: string;
   /** Session 集合访问口。 */
   sessionCollection: AgentSessionCollection;
+  /** Agent 上下文访问口。 */
+  getAgentContext?: () => AgentContext;
+  /** Agent 运行态访问口。 */
+  getAgentRuntime?: () => AgentRuntime;
 }
 
 /**
@@ -143,7 +243,9 @@ export interface RpcServerInstance {
 export async function startRpcServer(
   options: RpcServerStartOptions,
 ): Promise<RpcServerInstance> {
+  const sockets = new Set<net.Socket>();
   const server = net.createServer((socket) => {
+    sockets.add(socket);
     const subscriptions = new Map<string, SocketSubscription>();
     let buffered = "";
 
@@ -241,6 +343,133 @@ export async function startRpcServer(
             writeSuccess(request.id, { unsubscribed: true });
             return;
           }
+          case "internal.status.get": {
+            writeSuccess(request.id, { status: "ok" });
+            return;
+          }
+          case "internal.sessions.execute": {
+            const runtime = requireAgentRuntime(options);
+            const context = requireAgentContext(options);
+            const result = await executeBySessionId({
+              agentState: runtime,
+              executionContext: context,
+              sessionId: request.params.sessionId,
+              instructions: request.params.instructions,
+              attachments: request.params.attachments,
+            });
+            writeSuccess(request.id, {
+              sessionId: request.params.sessionId,
+              result,
+            });
+            return;
+          }
+          case "internal.sessions.clear_messages": {
+            const runtime = requireAgentRuntime(options);
+            const sessionId = String(request.params.sessionId || "").trim();
+            if (!sessionId) throw new Error("Missing sessionId");
+            const messagesPath = getDowncitySessionMessagesPath(
+              runtime.rootPath,
+              runtime.paths.agentId,
+              sessionId,
+            );
+            await fs.remove(dirname(messagesPath));
+            runtime.getSession(sessionId).clearExecutor();
+            writeSuccess(request.id, {
+              sessionId,
+              cleared: true,
+            });
+            return;
+          }
+          case "internal.sessions.clear_chat_history": {
+            const runtime = requireAgentRuntime(options);
+            const sessionId = String(request.params.sessionId || "").trim();
+            if (!sessionId) throw new Error("Missing sessionId");
+            await fs.remove(getDowncityChatHistoryPath(runtime.rootPath, sessionId));
+            writeSuccess(request.id, {
+              sessionId,
+              cleared: true,
+            });
+            return;
+          }
+          case "internal.sessions.resolve_system_prompt": {
+            const runtime = requireAgentRuntime(options);
+            const context = requireAgentContext(options);
+            const sessionId = String(request.params.sessionId || "").trim() || "consoleui-chat-main";
+            const systemMessages = await resolveSessionSystemMessages({
+              projectRoot: runtime.rootPath,
+              sessionId,
+              profile: "chat",
+              staticSystemPrompts: runtime.systems,
+              context,
+            });
+            writeSuccess(request.id, {
+              sessionId,
+              ...toSystemPromptPayload(systemMessages),
+            });
+            return;
+          }
+          case "internal.plugins.catalog": {
+            const context = requireAgentContext(options);
+            writeSuccess(request.id, {
+              plugins: context.plugins.list(),
+            });
+            return;
+          }
+          case "internal.plugins.list": {
+            const context = requireAgentContext(options);
+            writeSuccess(request.id, {
+              plugins: listPluginStates({ context }),
+            });
+            return;
+          }
+          case "internal.plugins.control": {
+            const context = requireAgentContext(options);
+            const result = await controlPluginState({
+              pluginName: request.params.pluginName,
+              action: request.params.action,
+              context,
+            });
+            writeSuccess(request.id, result);
+            return;
+          }
+          case "internal.plugins.command": {
+            const context = requireAgentContext(options);
+            const body = parsePluginCommandRequestBody(request.params);
+            const result = await runPluginCommand({
+              pluginName: body.pluginName,
+              command: body.command,
+              payload: body.payload,
+              schedule: body.schedule,
+              context,
+            });
+            writeSuccess(request.id, result);
+            return;
+          }
+          case "internal.plugins.availability": {
+            const context = requireAgentContext(options);
+            const availability = await context.plugins.availability(
+              request.params.pluginName,
+            );
+            writeSuccess(request.id, {
+              pluginName: request.params.pluginName,
+              availability,
+            });
+            return;
+          }
+          case "internal.plugins.action": {
+            const context = requireAgentContext(options);
+            const result = await context.plugins.runAction({
+              plugin: request.params.pluginName,
+              action: request.params.actionName,
+              payload: request.params.payload,
+            });
+            writeSuccess(request.id, {
+              ...result,
+              pluginName: request.params.pluginName,
+              actionName: request.params.actionName,
+            });
+            return;
+          }
         }
       } catch (error) {
         writeError(request.id, error);
@@ -273,6 +502,7 @@ export async function startRpcServer(
       cleanupSubscriptions();
     });
     socket.on("close", () => {
+      sockets.delete(socket);
       cleanupSubscriptions();
     });
     socket.on("end", () => {
@@ -294,9 +524,84 @@ export async function startRpcServer(
     url: `rpc://${options.host}:${options.port}`,
     server,
     async stop(): Promise<void> {
+      // 关键点（中文）：RPC 是长连接；停止 server 时必须主动关闭现有 socket。
+      for (const socket of sockets) {
+        socket.destroy();
+      }
+      sockets.clear();
       await new Promise<void>((resolve) => {
         server.close(() => resolve());
       });
     },
   };
 }
+
+function requireAgentContext(options: RpcServerStartOptions): AgentContext {
+  const context = options.getAgentContext?.();
+  if (!context) {
+    throw new Error("Agent RPC server was started without AgentContext");
+  }
+  return context;
+}
+
+function requireAgentRuntime(options: RpcServerStartOptions): AgentRuntime {
+  const runtime = options.getAgentRuntime?.();
+  if (!runtime) {
+    throw new Error("Agent RPC server was started without AgentRuntime");
+  }
+  return runtime;
+}
+
+function normalizeSystemText(input: string | null | undefined): string {
+  return String(input || "").trim();
+}
+
+function toSystemMessageText(message: SystemModelMessage): string {
+  const content = message.content as unknown;
+  if (typeof content === "string") return normalizeSystemText(content);
+  if (!Array.isArray(content)) return "";
+  const parts = content as Array<{ text?: unknown }>;
+  const texts: string[] = [];
+  for (const part of parts) {
+    if (!part || typeof part !== "object") continue;
+    const text = normalizeSystemText(String(part.text || ""));
+    if (!text) continue;
+    texts.push(text);
+  }
+  return texts.join("\n").trim();
+}
+
+/**
+ * 把 system messages 转成 Console/Town 可直接渲染的结构。
+ */
+function toSystemPromptPayload(messages: SystemModelMessage[]): {
+  sections: Array<{
+    key: string;
+    title: string;
+    items: Array<{ index: number; content: string }>;
+  }>;
+  totalMessages: number;
+  totalChars: number;
+} {
+  const items = messages
+    .map((message, index) => ({
+      index: index + 1,
+      content: toSystemMessageText(message),
+    }))
+    .filter((item) => item.content);
+  const totalChars = items.reduce(
+    (acc, item) => acc + String(item.content || "").length,
+    0,
+  );
+  return {
+    sections: [
+      {
+        key: "resolved",
+        title: "Resolved System Messages",
+        items,
+      },
+    ],
+    totalMessages: items.length,
+    totalChars,
+  };
+}