@downcity/agent 1.1.13 → 1.1.15

package/src/runtime/AgentRuntimeState.ts

@@ -1,213 +0,0 @@
-/**
- * AgentRuntime 进程级状态读写模块。
- *
- * 关键点（中文）
- * - 这里统一维护当前进程中的 base / ready 两阶段状态。
- * - `AgentRuntimeBase` 只表示启动早期已经可用的基础配置；`AgentRuntime` 才表示完整运行态。
- * - 该模块只负责状态持有与读写，不负责装配具体依赖对象。
- */
-
-import type { LanguageModel } from "ai";
-import type {
-  AgentRuntime,
-  AgentRuntimeBase,
-} from "@/runtime/AgentRuntimeTypes.js";
-import type { DowncityConfig } from "@/types/config/DowncityConfig.js";
-import type {
-  AgentPathRuntime,
-  AgentPlatformRuntime,
-  AgentPluginConfigRuntime,
-} from "@/types/host/AgentHost.js";
-import type { ChatChannelName } from "@/service/builtins/chat/types/ChannelStatus.js";
-export type { AgentRuntime, AgentRuntimeBase } from "@/runtime/AgentRuntimeTypes.js";
-
-let baseState: AgentRuntimeBase | null = null;
-let readyState: AgentRuntime | null = null;
-
-const EMPTY_PATHS: AgentPathRuntime = {
-  projectRoot: ".",
-  getDowncityDirPath: () => ".downcity",
-  getCacheDirPath: () => ".downcity/.cache",
-  getDowncityChannelDirPath: () => ".downcity/channel",
-  getDowncityChannelMetaPath: () => ".downcity/channel/meta.json",
-  getDowncityChatHistoryPath: (sessionId) => `.downcity/chat/${sessionId}/history.jsonl`,
-  getDowncityMemoryLongTermPath: () => ".downcity/memory/MEMORY.md",
-  getDowncityMemoryDailyDirPath: () => ".downcity/memory/daily",
-  getDowncityMemoryDailyPath: (date) => `.downcity/memory/daily/${date}.md`,
-  getDowncitySessionRootDirPath: () => ".downcity/session",
-  getDowncitySessionDirPath: (sessionId) => `.downcity/session/${sessionId}`,
-};
-
-const EMPTY_PLUGIN_CONFIG: AgentPluginConfigRuntime = {
-  async persistProjectPlugins() {
-    return "";
-  },
-};
-
-const EMPTY_PLATFORM: AgentPlatformRuntime = {
-  getGlobalEnv: () => ({}),
-  getAgentEnv: () => ({}),
-  listModels: () => [],
-  listProviders: async () => [],
-  getModel: () => null,
-  getChannelAccount: () => null,
-  listChannelAccounts: async () => [],
-  probeChannelAccount: async () => {
-    throw new Error("Channel account probing is not available in this runtime");
-  },
-  createChannelAccount: async () => {
-    throw new Error("Channel account creation is not available in this runtime");
-  },
-  updateChannelAccount: async () => {
-    throw new Error("Channel account update is not available in this runtime");
-  },
-  removeChannelAccount: async () => {
-    throw new Error("Channel account removal is not available in this runtime");
-  },
-  resolveChannelAccount: (_params: {
-    projectRoot: string;
-    channel: ChatChannelName;
-    channelAccountId?: string;
-  }) => null,
-  readChatAuthorizationConfig: () => ({
-    roles: {},
-    channels: {},
-  }),
-  writeChatAuthorizationConfig: async (_projectRoot, nextConfig) => nextConfig,
-  setChatAuthorizationUserRole: async () => ({
-    roles: {},
-    channels: {},
-  }),
-  isPluginEnabled: (pluginName) => pluginName === "auth",
-  setPluginEnabled: () => {
-    throw new Error("Plugin lifecycle management is not available in this runtime");
-  },
-  listPlatformModelChoices: async () => [],
-  initializeAgentProject: async () => {
-    throw new Error("Agent project initialization is not available in this runtime");
-  },
-  ensureRuntimeExecutionBindingReady: () => {
-    throw new Error("Execution binding validation is not available in this runtime");
-  },
-};
-
-function normalizeReadyState(input: AgentRuntime): AgentRuntime {
-  if (typeof input.getSession !== "function") {
-    throw new Error("AgentRuntime requires getSession");
-  }
-
-  return {
-    cwd: input.cwd,
-    rootPath: input.rootPath,
-    logger: input.logger,
-    config: input.config,
-    env: input.env,
-    globalEnv: input.globalEnv,
-    systems: input.systems,
-    paths: input.paths || EMPTY_PATHS,
-    pluginConfig: input.pluginConfig || EMPTY_PLUGIN_CONFIG,
-    platform: input.platform || EMPTY_PLATFORM,
-    model: input.model,
-    getSession: input.getSession,
-    listExecutingSessionIds:
-      input.listExecutingSessionIds || (() => []),
-    getExecutingSessionCount:
-      input.getExecutingSessionCount || (() => 0),
-    services: input.services || new Map(),
-  };
-}
-
-function normalizeBaseState(input: AgentRuntimeBase): AgentRuntimeBase {
-  return {
-    cwd: input.cwd,
-    rootPath: input.rootPath,
-    logger: input.logger,
-    config: input.config,
-    env: input.env,
-    globalEnv: input.globalEnv,
-    systems: input.systems,
-    paths: input.paths || EMPTY_PATHS,
-    pluginConfig: input.pluginConfig || EMPTY_PLUGIN_CONFIG,
-    platform: input.platform || EMPTY_PLATFORM,
-  };
-}
-
-/**
- * 设置 agent 基础状态。
- */
-export function setAgentRuntimeBase(next: AgentRuntimeBase): void {
-  baseState = normalizeBaseState(next);
-  readyState = null;
-}
-
-/**
- * 设置完整 agent 状态。
- */
-export function setAgentRuntime(next: AgentRuntime): void {
-  const normalized = normalizeReadyState(next);
-  baseState = normalized;
-  readyState = normalized;
-}
-
-/**
- * 仅更新当前 agent 的项目配置快照。
- *
- * 关键点（中文）
- * - 运行中 agent 可能在不重启进程的情况下收到 downcity.json 变更。
- * - 这里仅替换 `config`，不重建 model / service / session 等长期对象。
- * - 目标是让 plugin 启用态、system 注入等直接依赖配置快照的能力及时生效。
- */
-export function updateAgentRuntimeConfig(nextConfig: DowncityConfig): void {
-  if (!baseState) {
-    throw new Error(
-      "Agent state is not initialized. Call initAgentRuntime() during startup.",
-    );
-  }
-
-  baseState = {
-    ...baseState,
-    config: nextConfig,
-  };
-
-  if (readyState) {
-    readyState = {
-      ...readyState,
-      config: nextConfig,
-    };
-  }
-}
-
-/**
- * 获取 agent 基础状态。
- */
-export function getAgentRuntimeBase(): AgentRuntimeBase {
-  if (baseState) return baseState;
-  throw new Error(
-    "Agent state (base) is not initialized. Call initAgentRuntime() during startup.",
-  );
-}
-
-/**
- * 获取完整 agent 状态。
- */
-export function getAgentRuntime(): AgentRuntime {
-  if (readyState) return readyState;
-  if (!baseState) {
-    throw new Error(
-      "Agent state is not initialized. Call initAgentRuntime() during startup.",
-    );
-  }
-  throw new Error(
-    "Agent state is not ready yet. Ensure session is initialized before access.",
-  );
-}
-
-/**
- * 读取当前 agent 模型实例（必填）。
- */
-export function requireAgentModel(): LanguageModel {
-  if (readyState?.model) return readyState.model;
-  throw new Error(
-    "Agent model is not initialized. Ensure initAgentRuntime() completed successfully.",
-  );
-}

package/src/sdk/HttpServer.ts

@@ -1,231 +0,0 @@
-/**
- * SDK HTTP Server。
- *
- * 关键点（中文）
- * - 面向 `RemoteAgent` 暴露最小 session 能力集合。
- * - v1 先聚焦 session 创建、列表、history、run、stream、fork。
- */
-
-import http from "node:http";
-import { Hono } from "hono";
-import { cors } from "hono/cors";
-import type { Agent } from "@/sdk/Agent.js";
-
-type SdkHttpStartOptions = {
-  /**
-   * 监听主机。
-   */
-  host?: string;
-
-  /**
-   * 监听端口。
-   */
-  port?: number;
-};
-
-/**
- * SDK HTTP Server 管理器。
- */
-export class SdkAgentHttpServer {
-  private readonly agent: Agent;
-  private server: http.Server | null = null;
-  private baseUrlValue: string | null = null;
-
-  constructor(agent: Agent) {
-    this.agent = agent;
-  }
-
-  /**
-   * 启动 HTTP Server。
-   */
-  async start(options?: SdkHttpStartOptions): Promise<{ baseUrl: string }> {
-    if (this.server && this.baseUrlValue) {
-      return { baseUrl: this.baseUrlValue };
-    }
-    await this.agent.ensureServicesStarted();
-    const host = String(options?.host || "127.0.0.1").trim() || "127.0.0.1";
-    const port =
-      typeof options?.port === "number" && Number.isInteger(options.port)
-        ? options.port
-        : 15314;
-
-    const app = new Hono();
-    app.use(
-      "*",
-      cors({
-        origin: "*",
-        allowMethods: ["GET", "POST", "OPTIONS"],
-        allowHeaders: ["Content-Type"],
-      }),
-    );
-
-    app.get("/api/sdk/sessions", async (c) => {
-      return c.json({
-        success: true,
-        sessions: await this.agent.sessions(),
-      });
-    });
-
-    app.post("/api/sdk/sessions", async (c) => {
-      const body = await c.req.json().catch(() => ({}));
-      const session = await this.agent.session(
-        typeof body?.sessionId === "string" ? body.sessionId : undefined,
-      );
-      return c.json({
-        success: true,
-        session: await session.toMetadata(),
-      });
-    });
-
-    app.get("/api/sdk/sessions/:sessionId/messages", async (c) => {
-      const session = await this.agent.session(String(c.req.param("sessionId") || ""));
-      return c.json({
-        success: true,
-        sessionId: session.id,
-        messages: await session.history(),
-      });
-    });
-
-    app.get("/api/sdk/sessions/:sessionId/system", async (c) => {
-      const session = await this.agent.session(String(c.req.param("sessionId") || ""));
-      return c.json({
-        success: true,
-        sessionId: session.id,
-        system: await session.system(),
-      });
-    });
-
-    app.post("/api/sdk/sessions/:sessionId/run", async (c) => {
-      const session = await this.agent.session(String(c.req.param("sessionId") || ""));
-      const body = await c.req.json().catch(() => ({}));
-      const query = String(body?.query || "").trim();
-      if (!query) {
-        return c.json({ success: false, error: "query is required" }, 400);
-      }
-      const result = await session.run({ query });
-      return c.json({
-        success: true,
-        sessionId: session.id,
-        result,
-      });
-    });
-
-    app.post("/api/sdk/sessions/:sessionId/fork", async (c) => {
-      const session = await this.agent.session(String(c.req.param("sessionId") || ""));
-      const body = await c.req.json().catch(() => ({}));
-      const forked = await session.fork(
-        typeof body?.messageId === "string" ? body.messageId : undefined,
-      );
-      return c.json({
-        success: true,
-        session: await forked.toMetadata(),
-      });
-    });
-
-    app.post("/api/sdk/sessions/:sessionId/stream", async (c) => {
-      const session = await this.agent.session(String(c.req.param("sessionId") || ""));
-      const body = await c.req.json().catch(() => ({}));
-      const query = String(body?.query || "").trim();
-      if (!query) {
-        return c.json({ success: false, error: "query is required" }, 400);
-      }
-
-      const encoder = new TextEncoder();
-      const stream = new ReadableStream<Uint8Array>({
-        start: async (controller) => {
-          try {
-            for await (const event of session.stream({ query })) {
-              controller.enqueue(
-                encoder.encode(`${JSON.stringify(event)}\n`),
-              );
-            }
-            controller.close();
-          } catch (error) {
-            controller.enqueue(
-              encoder.encode(
-                `${JSON.stringify({
-                  type: "error",
-                  error: error instanceof Error ? error.message : String(error),
-                })}\n`,
-              ),
-            );
-            controller.close();
-          }
-        },
-      });
-
-      return new Response(stream, {
-        headers: {
-          "Content-Type": "application/x-ndjson; charset=utf-8",
-          "Cache-Control": "no-cache, no-transform",
-        },
-      });
-    });
-
-    const server = http.createServer(async (req, res) => {
-      try {
-        const url = new URL(req.url || "/", `http://${host}:${port}`);
-        const method = req.method || "GET";
-        const bodyBuffer = await this.readRequestBody(req);
-        const request = new Request(url.toString(), {
-          method,
-          headers: new Headers(req.headers as Record<string, string>),
-          body: bodyBuffer.length > 0 ? bodyBuffer : undefined,
-        });
-        const response = await app.fetch(request);
-        res.statusCode = response.status;
-        response.headers.forEach((value, key) => {
-          res.setHeader(key, value);
-        });
-        if (!response.body) {
-          res.end();
-          return;
-        }
-        const reader = response.body.getReader();
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          if (value) res.write(Buffer.from(value));
-        }
-        res.end();
-      } catch (error) {
-        res.statusCode = 500;
-        res.end(String(error));
-      }
-    });
-
-    await new Promise<void>((resolve) => {
-      server.listen(port, host, () => resolve());
-    });
-
-    this.server = server;
-    this.baseUrlValue = `http://${host}:${port}`;
-    return {
-      baseUrl: this.baseUrlValue,
-    };
-  }
-
-  /**
-   * 停止 HTTP Server。
-   */
-  async stop(): Promise<void> {
-    if (!this.server) return;
-    const current = this.server;
-    this.server = null;
-    this.baseUrlValue = null;
-    await new Promise<void>((resolve) => {
-      current.close(() => resolve());
-    });
-  }
-
-  private async readRequestBody(
-    req: http.IncomingMessage,
-  ): Promise<Buffer> {
-    return await new Promise<Buffer>((resolve, reject) => {
-      const chunks: Buffer[] = [];
-      req.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
-      req.on("end", () => resolve(Buffer.concat(chunks)));
-      req.on("error", reject);
-    });
-  }
-}

package/src/sdk/RpcServer.ts

@@ -1,244 +0,0 @@
-/**
- * SDK 本地 RPC Server。
- *
- * 关键点（中文）
- * - 面向同机受信任进程提供最小 session JSON RPC 能力。
- * - v1 先支持 session 列表、加载、run、history、fork。
- * - stream 仍建议优先走 HTTP NDJSON。
- */
-
-import fs from "fs-extra";
-import net, { type Server } from "node:net";
-import path from "node:path";
-import type { Agent } from "@/sdk/Agent.js";
-import type {
-  LocalRpcRequest,
-  LocalRpcResponse,
-} from "@/types/rpc/LocalRpc.js";
-import { getSdkAgentRpcEndpointPath } from "@/sdk/Paths.js";
-
-/**
- * SDK RPC Server 管理器。
- */
-export class SdkAgentRpcServer {
-  private readonly agent: Agent;
-  private server: Server | null = null;
-  private endpoint: string | null = null;
-
-  constructor(agent: Agent) {
-    this.agent = agent;
-  }
-
-  /**
-   * 启动本地 RPC server。
-   */
-  async start(): Promise<{ endpoint: string }> {
-    if (this.server && this.endpoint) {
-      return { endpoint: this.endpoint };
-    }
-    await this.agent.ensureServicesStarted();
-
-    const endpoint = getSdkAgentRpcEndpointPath(this.agent.path, this.agent.id);
-    await fs.ensureDir(path.dirname(endpoint));
-    await fs.remove(endpoint).catch(() => undefined);
-
-    const server = net.createServer((socket) => {
-      let buffered = "";
-      socket.setEncoding("utf8");
-      socket.on("data", (chunk) => {
-        buffered += String(chunk || "");
-        const newlineIndex = buffered.indexOf("\n");
-        if (newlineIndex < 0) return;
-        const raw = buffered.slice(0, newlineIndex).trim();
-        buffered = buffered.slice(newlineIndex + 1);
-        void this.respond(raw, socket);
-      });
-    });
-
-    await new Promise<void>((resolve, reject) => {
-      server.once("error", reject);
-      server.listen(endpoint, () => {
-        server.off("error", reject);
-        resolve();
-      });
-    });
-
-    this.server = server;
-    this.endpoint = endpoint;
-    return { endpoint };
-  }
-
-  /**
-   * 停止本地 RPC server。
-   */
-  async stop(): Promise<void> {
-    if (!this.server) return;
-    const current = this.server;
-    const endpoint = this.endpoint;
-    this.server = null;
-    this.endpoint = null;
-    await new Promise<void>((resolve) => current.close(() => resolve()));
-    if (endpoint) {
-      await fs.remove(endpoint).catch(() => undefined);
-    }
-  }
-
-  private async respond(raw: string, socket: net.Socket): Promise<void> {
-    let request: LocalRpcRequest | null = null;
-    try {
-      request = JSON.parse(raw) as LocalRpcRequest;
-    } catch {
-      socket.write(
-        `${JSON.stringify({
-          requestId: "unknown",
-          status: 400,
-          success: false,
-          error: "Invalid RPC JSON payload",
-        } satisfies LocalRpcResponse)}\n`,
-      );
-      return;
-    }
-
-    const response = await this.dispatch(request);
-    socket.write(`${JSON.stringify(response)}\n`);
-  }
-
-  private async dispatch(request: LocalRpcRequest): Promise<LocalRpcResponse> {
-    const requestId = String(request.requestId || "").trim() || "unknown";
-    try {
-      if (request.method === "GET" && request.path === "/api/sdk/sessions") {
-        return {
-          requestId,
-          status: 200,
-          success: true,
-          data: {
-            success: true,
-            sessions: await this.agent.sessions(),
-          } as unknown as LocalRpcResponse["data"],
-        };
-      }
-
-      if (request.method === "POST" && request.path === "/api/sdk/sessions") {
-        const body =
-          request.body && typeof request.body === "object" && !Array.isArray(request.body)
-            ? request.body
-            : {};
-        const session = await this.agent.session(
-          typeof body.sessionId === "string" ? body.sessionId : undefined,
-        );
-        return {
-          requestId,
-          status: 200,
-          success: true,
-          data: {
-            success: true,
-            session: await session.toMetadata(),
-          } as unknown as LocalRpcResponse["data"],
-        };
-      }
-
-      const runMatch = /^\/api\/sdk\/sessions\/([^/]+)\/run$/.exec(request.path);
-      if (request.method === "POST" && runMatch) {
-        const session = await this.agent.session(
-          decodeURIComponent(runMatch[1] || ""),
-        );
-        const body =
-          request.body && typeof request.body === "object" && !Array.isArray(request.body)
-            ? request.body
-            : {};
-        const query = String(body.query || "").trim();
-        if (!query) {
-          return {
-            requestId,
-            status: 400,
-            success: false,
-            error: "query is required",
-          };
-        }
-        return {
-          requestId,
-          status: 200,
-          success: true,
-          data: {
-            success: true,
-            sessionId: session.id,
-            result: await session.run({ query }),
-          } as unknown as LocalRpcResponse["data"],
-        };
-      }
-
-      const forkMatch = /^\/api\/sdk\/sessions\/([^/]+)\/fork$/.exec(request.path);
-      if (request.method === "POST" && forkMatch) {
-        const session = await this.agent.session(
-          decodeURIComponent(forkMatch[1] || ""),
-        );
-        const body =
-          request.body && typeof request.body === "object" && !Array.isArray(request.body)
-            ? request.body
-            : {};
-        const forked = await session.fork(
-          typeof body.messageId === "string" ? body.messageId : undefined,
-        );
-        return {
-          requestId,
-          status: 200,
-          success: true,
-          data: {
-            success: true,
-            session: await forked.toMetadata(),
-          } as unknown as LocalRpcResponse["data"],
-        };
-      }
-
-      const messagesMatch =
-        /^\/api\/sdk\/sessions\/([^/]+)\/messages$/.exec(request.path);
-      if (request.method === "GET" && messagesMatch) {
-        const session = await this.agent.session(
-          decodeURIComponent(messagesMatch[1] || ""),
-        );
-        return {
-          requestId,
-          status: 200,
-          success: true,
-          data: {
-            success: true,
-            sessionId: session.id,
-            messages: await session.history(),
-          } as unknown as LocalRpcResponse["data"],
-        };
-      }
-
-      const systemMatch =
-        /^\/api\/sdk\/sessions\/([^/]+)\/system$/.exec(request.path);
-      if (request.method === "GET" && systemMatch) {
-        const session = await this.agent.session(
-          decodeURIComponent(systemMatch[1] || ""),
-        );
-        return {
-          requestId,
-          status: 200,
-          success: true,
-          data: {
-            success: true,
-            sessionId: session.id,
-            system: await session.system(),
-          } as unknown as LocalRpcResponse["data"],
-        };
-      }
-
-      return {
-        requestId,
-        status: 404,
-        success: false,
-        error: `Unknown RPC path: ${request.method} ${request.path}`,
-      };
-    } catch (error) {
-      return {
-        requestId,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : String(error),
-      };
-    }
-  }
-}