@downcity/agent 1.1.13 → 1.1.15

package/src/core/AgentCore.ts

@@ -0,0 +1,527 @@
+/**
+ * AgentCore：单个 Agent 实例的运行内核。
+ *
+ * 关键点（中文）
+ * - 一个 `AgentCore` 只服务一个 agent 实例，不依赖进程级 singleton runtime。
+ * - SDK `Agent`、实例绑定式 HTTP server、实例绑定式 local RPC 都应基于它工作。
+ * - 宿主若需要统一 session 默认配置，应通过 `configureSession` 注入，而不是把策略写死在 SDK 中。
+ */
+
+import fs from "fs-extra";
+import { nanoid } from "nanoid";
+import type { Tool } from "ai";
+import { Logger } from "@/utils/logger/Logger.js";
+import type { BaseService } from "@/service/builtins/BaseService.js";
+import type { AgentContext } from "@/core/AgentContextTypes.js";
+import type { AgentRuntime } from "@/core/AgentCoreTypes.js";
+import type { DowncityConfig } from "@/types/config/DowncityConfig.js";
+import type { JsonValue } from "@/types/common/Json.js";
+import type { AgentPlatformRuntime } from "@/types/host/AgentHost.js";
+import type {
+  Plugin,
+  PluginAvailability,
+  PluginPort,
+  PluginView,
+} from "@/plugin/types/Plugin.js";
+import type {
+  AgentOptions,
+  AgentSessionMetadata,
+  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 {
+  createAgentPathRuntime,
+  createAgentPluginConfigRuntime,
+} from "@/host/runtime/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 { 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";
+
+const EMPTY_SDK_PLATFORM: AgentPlatformRuntime = {
+  getGlobalEnv: () => ({}),
+  getAgentEnv: () => ({}),
+  listModels: () => [],
+  listProviders: async () => [],
+  getModel: () => null,
+  getChannelAccount: () => null,
+  readChatAuthorizationConfig: () => ({
+    roles: {},
+    channels: {},
+  }),
+  writeChatAuthorizationConfig: async (_projectRoot, nextConfig) => nextConfig,
+  setChatAuthorizationUserRole: async () => ({
+    roles: {},
+    channels: {},
+  }),
+  isPluginEnabled: (pluginName) => pluginName === "auth",
+};
+
+function createFallbackSdkConfig(agentId: string): DowncityConfig {
+  return {
+    name: agentId,
+    version: "0.0.0",
+  } as DowncityConfig;
+}
+
+function normalizeInstructionInput(input: string | string[] | undefined): string[] {
+  const items = Array.isArray(input) ? input : typeof input === "string" ? [input] : [];
+  return items
+    .map((item) => String(item || "").trim())
+    .filter((item) => item.length > 0);
+}
+
+function createCoreInstructionContent(projectRoot: string): string {
+  const currentYear = String(new Date().getFullYear());
+  return DEFAULT_SHIP_PROMPTS
+    .replaceAll("{{project_path}}", projectRoot)
+    .replaceAll("{{project_root}}", projectRoot)
+    .replaceAll("{{current_year}}", currentYear);
+}
+
+function createInstructionSystemBlocks(
+  instruction: string[],
+  projectRoot: string,
+): AgentSessionSystemBlock[] {
+  if (instruction.length === 0) {
+    return [
+      {
+        source: "core",
+        name: "default",
+        content: createCoreInstructionContent(projectRoot),
+      },
+    ];
+  }
+  return instruction.map((content, index) => ({
+    source: "instruction" as const,
+    name: instruction.length === 1 ? "agent" : `agent:${index + 1}`,
+    content,
+  }));
+}
+
+/**
+ * SDK / server 共用的实例级 Agent 内核。
+ */
+export class AgentCore {
+  readonly id: string;
+  readonly path: string;
+  readonly tools: Record<string, Tool>;
+  readonly services: Map<string, BaseService>;
+  readonly plugins: PluginPort;
+
+  private readonly logger: Logger;
+  private readonly sessionsById = new Map<string, Session>();
+  private readonly runtime: AgentRuntime;
+  private readonly serviceContext: AgentContext;
+  private readonly pluginRegistry: PluginRegistry;
+  private readonly pluginSystemProviders: Plugin[];
+  private readonly config: DowncityConfig;
+  private readonly platform: AgentPlatformRuntime;
+  private readonly env: Record<string, string>;
+  private readonly globalEnv: Record<string, string>;
+  private readonly configureSessionHook?: AgentOptions["configureSession"];
+  private instruction: string[];
+  private servicesStartPromise: Promise<void> | null = null;
+  private configuredSessionIds = new Set<string>();
+
+  constructor(options: AgentOptions) {
+    this.id = String(options.id || "").trim();
+    this.path = String(options.path || "").trim();
+    this.tools = options.tools && typeof options.tools === "object"
+      ? { ...options.tools }
+      : {};
+    if (!this.id) {
+      throw new Error("Agent requires a non-empty id");
+    }
+    if (!this.path) {
+      throw new Error("Agent requires a non-empty path");
+    }
+
+    this.logger = new Logger();
+    this.logger.bindProjectRoot(this.path);
+    this.platform = options.platform || EMPTY_SDK_PLATFORM;
+    this.globalEnv = this.platform.getGlobalEnv?.() || {};
+    this.env = this.platform.getAgentEnv?.(this.path) || {};
+    this.instruction = normalizeInstructionInput(options.instruction);
+    this.configureSessionHook = options.configureSession;
+    this.config = this.loadConfig();
+    this.services = new Map<string, BaseService>();
+    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.pluginRegistry = this.createPluginRegistry(this.pluginSystemProviders);
+    this.plugins = this.createPluginPort();
+    this.serviceContext = this.createServiceContext();
+    setShellToolRuntime(this.serviceContext.invoke);
+  }
+
+  /**
+   * 返回实例级 runtime 视图。
+   */
+  getRuntime(): AgentRuntime {
+    return this.runtime;
+  }
+
+  /**
+   * 返回实例级执行上下文。
+   */
+  getContext(): AgentContext {
+    return this.serviceContext;
+  }
+
+  /**
+   * 返回当前项目根目录解析后的配置快照。
+   */
+  getConfig(): DowncityConfig {
+    return this.config;
+  }
+
+  /**
+   * 返回统一日志器。
+   */
+  getLogger(): Logger {
+    return this.logger;
+  }
+
+  /**
+   * 获取或创建一个 session。
+   */
+  async session(sessionId?: string): Promise<Session> {
+    const session = this.getOrCreateSession(sessionId);
+    await session.initialize();
+    await this.configureSession(session);
+    return session;
+  }
+
+  /**
+   * 列出当前 agent 的全部 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());
+    }
+    items.sort((a, b) => (b.updatedAt || 0) - (a.updatedAt || 0));
+    return items;
+  }
+
+  /**
+   * 确保显式注入的 services 已启动。
+   */
+  async ensureServicesStarted(): Promise<void> {
+    if (this.servicesStartPromise) {
+      await this.servicesStartPromise;
+      return;
+    }
+    this.servicesStartPromise = (async () => {
+      for (const service of this.services.values()) {
+        await service.lifecycle?.start?.(this.serviceContext);
+      }
+    })();
+    await this.servicesStartPromise;
+  }
+
+  /**
+   * 更新当前 Agent 的静态基础指令。
+   */
+  setInstruction(input: string | string[]): void {
+    this.instruction = normalizeInstructionInput(input);
+  }
+
+  private loadConfig(): DowncityConfig {
+    try {
+      return loadDowncityConfig(this.path, {
+        projectEnv: this.env,
+        agentEnv: this.env,
+        globalEnv: this.globalEnv,
+      });
+    } catch {
+      return createFallbackSdkConfig(this.id);
+    }
+  }
+
+  private registerServices(input: {
+    explicitServices: BaseService[];
+    useBuiltinServices: boolean;
+  }): void {
+    const explicitServices = input.explicitServices;
+    const builtinServices = input.useBuiltinServices
+      ? [...createRegisteredServiceInstances(this.runtime).values()]
+      : [];
+    for (const service of [...builtinServices, ...explicitServices]) {
+      const name = String(service?.name || "").trim();
+      if (!name) {
+        throw new Error("Agent received a service without a valid name");
+      }
+      if (this.services.has(name)) {
+        throw new Error(`Duplicate service registration: ${name}`);
+      }
+      service.bindAgent(this.runtime);
+      this.services.set(name, service);
+    }
+  }
+
+  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 {
+    let pluginRegistryRef: PluginRegistry | null = null;
+    const hookRegistry = new HookRegistry({
+      contextResolver: () => this.serviceContext,
+      pluginEnabledChecker: (pluginName) => {
+        const plugin = pluginRegistryRef?.get(pluginName);
+        return plugin ? isPluginEnabled({ plugin, context: this.serviceContext }) : false;
+      },
+    });
+    const registry = new PluginRegistry({
+      contextResolver: () => this.serviceContext,
+      hookRegistry,
+    });
+    pluginRegistryRef = registry;
+
+    for (const plugin of input) {
+      registry.register(plugin);
+    }
+    return registry;
+  }
+
+  private createPluginPort(): PluginPort {
+    return {
+      list: (): PluginView[] => this.pluginRegistry.list(),
+      availability: async (pluginName: string): Promise<PluginAvailability> =>
+        await this.pluginRegistry.availability(pluginName),
+      runAction: async (params) => await this.pluginRegistry.runAction(params),
+      pipeline: async <T>(pointName: string, value: T): Promise<T> =>
+        await this.pluginRegistry.pipeline(pointName, value),
+      guard: async <T>(pointName: string, value: T): Promise<void> => {
+        await this.pluginRegistry.guard(pointName, value);
+      },
+      effect: async <T>(pointName: string, value: T): Promise<void> => {
+        await this.pluginRegistry.effect(pointName, value);
+      },
+      resolve: async <TInput, TOutput>(
+        pointName: string,
+        value: TInput,
+      ): Promise<TOutput> =>
+        await this.pluginRegistry.resolve<TInput, TOutput>(pointName, value),
+    };
+  }
+
+  private loadInstructionSystemBlocks(): AgentSessionSystemBlock[] {
+    return createInstructionSystemBlocks(this.instruction, this.path);
+  }
+
+  private async loadPluginSystemBlocks(): Promise<AgentSessionSystemBlock[]> {
+    const out: AgentSessionSystemBlock[] = [];
+    for (const plugin of this.pluginSystemProviders) {
+      if (typeof plugin.system !== "function") continue;
+      try {
+        if (!isPluginEnabled({ plugin, context: this.serviceContext })) continue;
+        if (typeof plugin.availability === "function") {
+          const availability = await plugin.availability(this.serviceContext);
+          if (!availability.available) continue;
+        }
+        const text = String(await plugin.system(this.serviceContext)).trim();
+        if (!text) continue;
+        out.push({
+          source: "plugin",
+          name: plugin.name,
+          content: text,
+        });
+      } catch {
+        // 单个 plugin system 失败不应阻断 SDK session 主链路。
+      }
+    }
+    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,
+      rootPath: this.path,
+      logger: this.logger,
+      config: this.config,
+      env: this.env,
+      globalEnv: this.globalEnv,
+      systems: this.instruction,
+      paths: createAgentPathRuntime(this.path),
+      pluginConfig: createAgentPluginConfigRuntime(this.path),
+      platform: this.platform,
+      model: undefined,
+      getSession: (sessionId: string) => {
+        return this.getOrCreateSession(sessionId).getServicePort() as never;
+      },
+      listExecutingSessionIds: () =>
+        [...this.sessionsById.values()]
+          .filter((session) => session.isExecuting())
+          .map((session) => session.id),
+      getExecutingSessionCount: () =>
+        [...this.sessionsById.values()].filter((session) => session.isExecuting()).length,
+      services: this.services,
+    } satisfies Omit<AgentRuntime, "getSession"> & {
+      getSession(sessionId: string): never;
+    };
+    return runtime as unknown as AgentRuntime;
+  }
+
+  private createServiceContext(): AgentContext {
+    let context!: AgentContext;
+    context = {
+      agent: this.runtime,
+      cwd: this.path,
+      rootPath: this.path,
+      logger: this.logger,
+      config: this.config,
+      env: this.env,
+      globalEnv: this.globalEnv,
+      systems: this.instruction,
+      paths: this.runtime.paths,
+      pluginConfig: this.runtime.pluginConfig,
+      platform: this.platform,
+      session: {
+        get: (sessionId) => this.getOrCreateSession(sessionId).getServicePort(),
+        listExecutingSessionIds: () => this.runtime.listExecutingSessionIds(),
+        getExecutingSessionCount: () => this.runtime.getExecutingSessionCount(),
+      },
+      invoke: {
+        invoke: async (params: {
+          service: string;
+          action: string;
+          payload?: JsonValue;
+        }) => {
+          const serviceName = String(params.service || "").trim();
+          const actionName = String(params.action || "").trim();
+          const service = this.services.get(serviceName);
+          if (!service) {
+            return {
+              success: false,
+              error: `Unknown service: ${serviceName}`,
+            };
+          }
+          const action = service.actions[actionName];
+          if (!action) {
+            return {
+              success: false,
+              error: `Unknown action: ${serviceName}.${actionName}`,
+            };
+          }
+          const result = await action.execute({
+            context,
+            payload: params.payload ?? null,
+            serviceName,
+            actionName,
+          });
+          if (!result.success) {
+            return {
+              success: false,
+              ...(result.error ? { error: result.error } : {}),
+            };
+          }
+          return {
+            success: true,
+            ...(result.data !== undefined ? { data: result.data } : {}),
+          };
+        },
+      },
+      chat: {
+        readMetaBySessionId: async (sessionId: string) => {
+          return await readChatMetaBySessionId({
+            context,
+            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,
+    };
+    return context;
+  }
+
+  private getOrCreateSession(sessionId?: string): Session {
+    const resolvedSessionId =
+      String(sessionId || "").trim() || `session-${Date.now()}-${nanoid(8)}`;
+    const cached = this.sessionsById.get(resolvedSessionId);
+    if (cached) return cached;
+
+    const created = new Session({
+      agentId: this.id,
+      projectRoot: this.path,
+      sessionId: resolvedSessionId,
+      tools: this.tools,
+      logger: this.logger,
+      getInstructionSystemBlocks: () => this.loadInstructionSystemBlocks(),
+      getServiceSystemBlocks: () => this.loadServiceSystemBlocks(),
+      getPluginSystemBlocks: () => this.loadPluginSystemBlocks(),
+    });
+    this.sessionsById.set(resolvedSessionId, created);
+    return created;
+  }
+
+  private async configureSession(session: Session): Promise<void> {
+    if (!this.configureSessionHook) return;
+    if (this.configuredSessionIds.has(session.id)) return;
+    await this.configureSessionHook(session);
+    this.configuredSessionIds.add(session.id);
+  }
+}

package/src/{runtime/AgentRuntimeTypes.ts → core/AgentCoreTypes.ts}

@@ -1,10 +1,10 @@
 /**
- * AgentRuntime 类型定义。
+ * AgentCore 运行时类型定义。
  *
  * 关键点（中文）
- * - 这里表达的是“当前 agent 进程的长期运行状态”。
- * - 它不是抽象 host，也不是一次执行上下文。
- * - Session / Service / Plugin 这些长期对象都应从这里挂出。
+ * - 这里表达的是单个 `AgentCore` 实例持有的长期运行状态。
+ * - 它不再依赖 `runtime/*` 兼容层，而是作为实例级主类型来源。
+ * - Session / Service / Plugin 这些长期对象都从这里挂出。
  */
 
 import type { LanguageModel } from "ai";
@@ -19,7 +19,7 @@ import type { BaseService } from "@/service/builtins/BaseService.js";
 import type { Executor } from "@session/Executor.js";
 
 /**
- * AgentRuntime 启动早期的基础状态。
+ * AgentCore 启动早期的基础状态。
  */
 export interface AgentRuntimeBase {
   /**
@@ -65,7 +65,7 @@ export interface AgentRuntimeBase {
 }
 
 /**
- * Agent 进程完整运行状态。
+ * AgentCore 完整运行状态。
  */
 export interface AgentRuntime extends AgentRuntimeBase {
   /**

package/src/host/daemon/ProjectSetup.ts

@@ -9,11 +9,10 @@
 import fs from "fs-extra";
 import path from "node:path";
 import { loadDowncityConfig } from "@/config/Config.js";
-import type { AgentPlatformRuntime } from "@/types/host/AgentHost.js";
 import {
-  readProjectExecutionBinding,
   readProjectPrimaryModelId,
-} from "@/project/ProjectExecutionBinding.js";
+} from "@/config/ExecutionBinding.js";
+import type { AgentPlatformRuntime } from "@/types/host/AgentHost.js";
 import {
   getCacheDirPath,
   getLogsDirPath,

package/src/host/runtime/PluginRuntime.ts

@@ -7,7 +7,7 @@
  * - agent runtime 仅作为 context provider 注册方，不再成为 plugin manager 的宿主。
  */
 
-import type { AgentContext } from "@/runtime/AgentContextTypes.js";
+import type { AgentContext } from "@/core/AgentContextTypes.js";
 
 type AgentContextResolver = () => AgentContext;
 

package/src/index.ts

@@ -11,8 +11,15 @@
 export { Agent } from "./sdk/Agent.js";
 export { Session } from "./sdk/Session.js";
 export { RemoteAgent } from "./sdk/RemoteAgent.js";
+export { AgentCore } from "./core/AgentCore.js";
 export type {
   AgentOptions,
+  AgentHttpBinding,
+  AgentHttpStartOptions,
+  AgentRpcBinding,
+  AgentStartOptions,
+  AgentStartResult,
+  AgentStopResult,
   RemoteAgentOptions,
   AgentSessionConfigSnapshot,
   AgentSessionForkInput,
@@ -26,6 +33,19 @@ export type {
   AgentSessionSystemSessionInfo,
   AgentSessionSystemSnapshot,
 } from "./sdk/AgentSdkTypes.js";
+export type {
+  AgentRuntime as AgentCoreRuntime,
+  AgentRuntimeBase as AgentCoreRuntimeBase,
+} from "./core/AgentCoreTypes.js";
+export type {
+  AgentContext as AgentContext,
+  AgentContext as AgentCoreContext,
+  ChatRuntimePort,
+  InvokeServicePort,
+  SessionCollectionPort,
+  SessionPort,
+  StructuredConfig,
+} from "./core/AgentContextTypes.js";
 
 // 服务与插件作者 API
 export { BaseService } from "./service/builtins/BaseService.js";
@@ -46,21 +66,6 @@ export { asrPlugin } from "./plugin/builtins/asr/Plugin.js";
 export { ttsPlugin } from "./plugin/builtins/tts/Plugin.js";
 export { workboardPlugin } from "./plugin/builtins/workboard/Plugin.js";
 
-// Agent 运行时集成
-export {
-  getAgentContext,
-  getAgentRuntime,
-  getAgentRuntimeBase,
-  initAgentRuntime,
-  requireAgentModel,
-  setAgentRuntime,
-  setAgentRuntimeBase,
-  stopAgentHotReload,
-} from "./runtime/AgentRuntime.js";
-export { createAgentContext } from "./runtime/AgentContext.js";
-export type { AgentRuntime, AgentRuntimeBase } from "./runtime/AgentRuntimeState.js";
-export type { AgentContext } from "./runtime/AgentContextTypes.js";
-
 // Session 与即时执行集成
 export { Executor } from "./session/Executor.js";
 export {
@@ -71,7 +76,10 @@ export { JsonlSessionHistoryComposer } from "./session/composer/history/jsonl/Js
 export { JsonlSessionCompactionComposer } from "./session/composer/compaction/jsonl/JsonlSessionCompactionComposer.js";
 export { SessionSystemComposer } from "./session/composer/system/SessionSystemComposer.js";
 export { transformPromptsIntoSystemMessages } from "./session/composer/system/default/PromptRenderer.js";
-export { loadStaticSystemPrompts } from "./session/composer/system/default/StaticPromptCatalog.js";
+export {
+  loadStaticSystemPrompts,
+  StaticPromptCatalog,
+} from "./session/composer/system/default/StaticPromptCatalog.js";
 
 // Agent server 与 transport 集成
 export { startServer } from "./server/http/Server.js";
@@ -84,12 +92,8 @@ export {
   startAllServices,
   stopAllServices,
 } from "./service/core/Manager.js";
-export {
-  startServiceScheduleRuntime,
-  stopServiceScheduleRuntime,
-} from "./service/schedule/Runtime.js";
-export { ServiceScheduleStore } from "./service/schedule/Store.js";
-export { parseScheduledRunAtMsOrThrow } from "./service/schedule/Time.js";
+export { ServiceScheduleStore } from "./service/core/schedule/Store.js";
+export { parseScheduledRunAtMsOrThrow } from "./service/core/schedule/Time.js";
 export {
   pickLastSuccessfulChatSendText,
   resolveAssistantMessageForPersistence,
@@ -126,7 +130,7 @@ export {
   ensureRuntimeExecutionBindingReady,
   ensureRuntimeProjectReady,
 } from "./host/daemon/ProjectSetup.js";
-export { assertProjectExecutionTarget } from "./project/ProjectExecutionBinding.js";
+export { assertProjectExecutionTarget } from "./config/ExecutionBinding.js";
 
 // 日志
 export { getLogger, logger, type Logger } from "./utils/logger/Logger.js";
@@ -247,7 +251,6 @@ export type {
 export type {
   Service,
   ServiceAction,
-  ServiceActionApi,
   ServiceActionCommand,
   ServiceActionCommandInput,
   ServiceActionResult,

package/src/model/CreateModel.ts

@@ -21,7 +21,7 @@ import { createLlmLoggingFetch } from "@/utils/logger/Fetch.js";
 import { getLogger } from "@/utils/logger/Logger.js";
 import type { DowncityConfig } from "@/types/config/DowncityConfig.js";
 import type { LlmProviderType } from "@/types/config/LlmConfig.js";
-import { readProjectExecutionBinding } from "@/project/ProjectExecutionBinding.js";
+import { readProjectExecutionBinding } from "@/config/ExecutionBinding.js";
 import type { AgentPlatformRuntime } from "@/types/host/AgentHost.js";
 
 type ModelLogContext = {