@downcity/agent 1.1.73 → 1.1.79

package/src/executor/messages/AssistantResultPersistence.ts

@@ -4,14 +4,11 @@
  * 关键点（中文）
  * - 负责收敛“写完整 assistant message / 写 fallback 文本 / 完全跳过”三种分支。
  * - 避免 SDK、HTTP execute、control execute、chat queue 各自复制一套判断。
- * - 一旦 step 消息已经单独持久化，最终 merged assistant 必须跳过，不能再补一条 fallback。
+ * - 运行中 step/tool 的持久化由 inflight 快照承担；run 结束时只关心最终 assistant 如何收口。
  */
 
 import type { SessionMessageV1 } from "@/executor/types/SessionMessages.js";
-import {
-  hasPersistedAssistantSteps,
-  resolveAssistantMessageForPersistence,
-} from "@/executor/messages/UserVisibleText.js";
+import { resolveAssistantMessageForPersistence } from "@/executor/messages/UserVisibleText.js";
 
 /**
  * assistant 写入端口。
@@ -48,8 +45,8 @@ export interface PersistAssistantResultParams {
    * 可选兜底文本。
    *
    * 关键点（中文）
-   * - 仅在没有完整 assistant message 且未发生 step 持久化时才允许写入。
-   * - 若 step 已单独落盘，这里必须被忽略，避免重复 assistant。
+   * - 仅在没有完整 assistant message 时才允许写入。
+   * - inflight 快照的正式收口由 history store 负责，这里不再处理旧的 step 独立落盘分支。
    */
   fallbackText?: string;
 }
@@ -83,11 +80,6 @@ export function buildAssistantResultPersistencePayload(
     };
   }
 
-  // 关键点（中文）：step 已经单独落盘时，最终 merged assistant 必须完全跳过。
-  if (hasPersistedAssistantSteps(params.assistantMessage)) {
-    return null;
-  }
-
   const fallbackText = normalizeFallbackText(params.fallbackText);
   if (!fallbackText) return null;
   return {

package/src/executor/messages/SessionStepEventMapper.ts

@@ -1,14 +1,12 @@
 /**
- * SessionStepEventMapper：把单个 step 结果转成按顺序可持久化的 session 消息。
+ * SessionStepEventMapper：把单个 step 结果转成 assistant parts。
  *
  * 关键点（中文）
- * - 工具结果使用 AI SDK v6 UI tool part 格式，避免历史重放时丢失 tool result。
- * - 只做 best-effort 提取，不依赖 provider 私有结构。
- * - 输出仍然是标准 SessionMessageV1，供 SessionHistoryWriter 直接落盘。
+ * - 运行过程仍然要持久化，但收口到同一条 assistant UIMessage。
+ * - 工具结果使用 AI SDK v6 UI tool part 格式，和官方 UIMessage 语义保持一致。
+ * - 每个 step 前插入 `step-start`，便于在 UI 中保留多 step 边界。
  */
 
-import { generateId } from "@/utils/Id.js";
-import type { JsonObject } from "@/types/common/Json.js";
 import type { SessionMessageV1 } from "@/executor/types/SessionMessages.js";
 
 type UnknownRecord = Record<string, unknown>;
@@ -64,6 +62,21 @@ function resolveToolResultPayload(value: unknown): unknown {
   return undefined;
 }
 
+function resolveToolResultErrorText(value: unknown): string | undefined {
+  const record = toRecord(value);
+  if (!record) return undefined;
+  if (typeof record.errorText === "string" && record.errorText.trim()) {
+    return record.errorText.trim();
+  }
+  if (typeof record.error === "string" && record.error.trim()) {
+    return record.error.trim();
+  }
+  if (record.error instanceof Error && record.error.message.trim()) {
+    return record.error.message.trim();
+  }
+  return undefined;
+}
+
 function mapToolResultsByCallId(toolResults: unknown[]): Map<string, unknown> {
   const out = new Map<string, unknown>();
   for (const toolResult of toolResults) {
@@ -91,53 +104,16 @@ function toDataPartType(type: string): string {
   return `data-acp-${type.replace(/_/g, "-")}`;
 }
 
-function buildMetadata(params: {
-  sessionId: string;
-  ts: number;
-  extra?: JsonObject;
-}): SessionMessageV1["metadata"] {
-  return {
-    v: 1,
-    ts: params.ts,
-    sessionId: params.sessionId,
-    source: "egress",
-    kind: "normal",
-    ...(params.extra ? { extra: params.extra } : {}),
-  };
-}
-
-function buildAssistantStepMessage(params: {
-  sessionId: string;
-  ts: number;
-  part: Record<string, unknown>;
-  extra: JsonObject;
-}): SessionMessageV1 {
-  return {
-    id: `a:${params.sessionId}:${generateId()}`,
-    role: "assistant",
-    metadata: buildMetadata({
-      sessionId: params.sessionId,
-      ts: params.ts,
-      extra: params.extra,
-    }),
-    parts: [params.part as SessionMessageV1["parts"][number]],
-  };
-}
-
 /**
- * 从 stepResult 提取按顺序落盘的 session assistant 消息。
+ * 从 stepResult 提取按顺序写入同一条 assistant message 的 parts。
  */
-export function buildSessionStepEventMessages(params: {
-  sessionId: string;
+export function buildSessionStepParts(params: {
   stepIndex: number;
   stepResult?: unknown;
   text: string;
   visibility?: "visible" | "internal";
-}): SessionMessageV1[] {
-  const sessionId = String(params.sessionId || "").trim();
-  if (!sessionId) return [];
-
-  const out: SessionMessageV1[] = [];
+}): SessionMessageV1["parts"] {
+  const out: SessionMessageV1["parts"] = [];
   const stepRecord = toRecord(params.stepResult) || {};
   const toolCalls = Array.isArray(stepRecord.toolCalls) ? stepRecord.toolCalls : [];
   const toolResults = Array.isArray(stepRecord.toolResults)
@@ -147,34 +123,29 @@ export function buildSessionStepEventMessages(params: {
   const acpEvents = Array.isArray(stepRecord.acpEvents)
     ? stepRecord.acpEvents
     : [];
-  const baseTs = Date.now();
-  let sequence = 0;
 
   const text = String(params.text || "").trim();
+  const has_structured_output =
+    Boolean(text) || toolCalls.length > 0 || acpEvents.length > 0;
+  if (!has_structured_output) return [];
+
+  out.push({ type: "step-start" });
+
   if (text) {
     const isInternal = params.visibility === "internal";
     out.push(
-      buildAssistantStepMessage({
-        sessionId,
-        ts: baseTs + sequence,
-        part: isInternal
-          ? {
-              type: "reasoning",
-              text,
-              state: "done",
-            }
-          : {
-              type: "text",
-              text,
-            },
-        extra: {
-          internal: isInternal ? "assistant_step_reasoning" : "assistant_step_text",
-          stepIndex: params.stepIndex,
-          persistedBy: "session_store_run",
-        },
-      }),
+      isInternal
+        ? {
+            type: "reasoning",
+            text,
+            state: "done",
+          }
+        : {
+            type: "text",
+            text,
+            state: "done",
+          },
     );
-    sequence += 1;
   }
 
   for (let index = 0; index < toolCalls.length; index += 1) {
@@ -185,25 +156,23 @@ export function buildSessionStepEventMessages(params: {
     const toolResult = toolCallId ? toolResultsByCallId.get(toolCallId) : undefined;
     if (!toolResult) continue;
     const output = resolveToolResultPayload(toolResult);
+    const errorText = resolveToolResultErrorText(toolResult);
     out.push(
-      buildAssistantStepMessage({
-        sessionId,
-        ts: baseTs + sequence,
-        part: {
-          type: `tool-${toolName}`,
-          ...(toolCallId ? { toolCallId } : {}),
-          ...(input !== undefined ? { input } : {}),
-          state: "output-available",
-          output,
-        },
-        extra: {
-          internal: "assistant_step_tool_result",
-          stepIndex: params.stepIndex,
-          toolIndex: index + 1,
-        },
-      }),
+      {
+        type: `tool-${toolName}`,
+        ...(toolCallId ? { toolCallId } : {}),
+        ...(input !== undefined ? { input } : {}),
+        ...(errorText
+          ? {
+              state: "output-error",
+              errorText,
+            }
+          : {
+              state: "output-available",
+              output,
+            }),
+      } as SessionMessageV1["parts"][number],
     );
-    sequence += 1;
   }
 
   for (let index = 0; index < acpEvents.length; index += 1) {
@@ -211,22 +180,11 @@ export function buildSessionStepEventMessages(params: {
     const type = resolveAcpEventType(acpEvent);
     if (!type) continue;
     out.push(
-      buildAssistantStepMessage({
-        sessionId,
-        ts: baseTs + sequence,
-        part: {
-          type: toDataPartType(type),
-          data: resolveAcpEventData(acpEvent),
-        },
-        extra: {
-          internal: "assistant_step_acp_event",
-          stepIndex: params.stepIndex,
-          acpEventType: type,
-          eventIndex: index + 1,
-        },
-      }),
+      {
+        type: toDataPartType(type),
+        data: resolveAcpEventData(acpEvent),
+      } as SessionMessageV1["parts"][number],
     );
-    sequence += 1;
   }
 
   return out;

package/src/executor/messages/UserVisibleText.ts

@@ -17,29 +17,14 @@ import {
  * 生成真正应该落盘到 session 的 assistant message。
  *
  * 关键点（中文）
- * - 没有 step 持久化时，直接保留完整 assistant message。
- * - 一旦 step 已单独落盘，最终 merged assistant 不再重复写入。
+ * - session 正式历史应尽量保留 AI SDK 最终 assistant UIMessage。
+ * - 运行中 step/tool 的中断恢复由 inflight 快照承担，不再通过跳过最终 message 收口。
  */
 export function resolveAssistantMessageForPersistence(
   message: SessionMessageV1 | null | undefined,
 ): SessionMessageV1 | null {
   if (!message || typeof message !== "object") return null;
-  return hasPersistedAssistantSteps(message) ? null : message;
-}
-
-/**
- * 判断 assistant message 是否声明“本轮 step 消息已单独持久化”。
- *
- * 关键点（中文）
- * - 该标记只用于避免在 run 结束时把最终 merged assistant 再重复写入 context。
- * - 不影响 channel 发送；只影响 context messages 的最终 append 策略。
- */
-export function hasPersistedAssistantSteps(
-  message: SessionMessageV1 | null | undefined,
-): boolean {
-  const extra = message?.metadata?.extra;
-  if (!extra || typeof extra !== "object" || Array.isArray(extra)) return false;
-  return extra.assistantStepMessagesPersisted === true;
+  return message;
 }
 
 /**

package/src/executor/store/history/SessionHistoryStore.ts

@@ -63,6 +63,21 @@ export interface SessionHistoryStore {
    */
   append(message: SessionMessageV1): Promise<void>;
 
+  /**
+   * 读取当前运行中的 assistant 快照。
+   */
+  readInflight(): Promise<SessionMessageV1 | null>;
+
+  /**
+   * 写入当前运行中的 assistant 快照。
+   */
+  writeInflight(message: SessionMessageV1): Promise<void>;
+
+  /**
+   * 用最终 assistant 收口 inflight 快照。
+   */
+  finalizeInflight(message?: SessionMessageV1 | null): Promise<void>;
+
   /**
    * 读取完整消息历史。
    */

package/src/executor/store/history/jsonl/JsonlSessionHistoryStore.ts

@@ -106,6 +106,7 @@ export class JsonlSessionHistoryStore implements SessionHistoryStore {
   private readonly overrideMessagesFilePath?: string;
   private readonly overrideMetaFilePath?: string;
   private readonly overrideArchiveDirPath?: string;
+  private readonly overrideInflightFilePath?: string;
 
   constructor(options: JsonlSessionHistoryStoreOptions) {
     const rootPath = String(options.rootPath || "").trim();
@@ -135,6 +136,9 @@ export class JsonlSessionHistoryStore implements SessionHistoryStore {
     this.overrideArchiveDirPath = this.readOptionalPath(
       options.paths?.archiveDirPath,
     );
+    this.overrideInflightFilePath = this.readOptionalPath(
+      options.paths?.inflightFilePath,
+    );
   }
 
   private readOptionalPath(value: string | undefined): string | undefined {
@@ -183,6 +187,14 @@ export class JsonlSessionHistoryStore implements SessionHistoryStore {
     return path.join(this.getMessagesDirPath(), "archive");
   }
 
+  private getInflightFilePath(): string {
+    if (this.overrideInflightFilePath) return this.overrideInflightFilePath;
+    if (this.overrideMessagesDirPath) {
+      return path.join(this.overrideMessagesDirPath, "inflight.json");
+    }
+    return path.join(this.getMessagesDirPath(), "inflight.json");
+  }
+
   private getLockFilePath(): string {
     return path.join(this.getMessagesDirPath(), ".session.lock");
   }
@@ -199,6 +211,75 @@ export class JsonlSessionHistoryStore implements SessionHistoryStore {
     return value || undefined;
   }
 
+  private normalizePersistedMessage(
+    input: unknown,
+  ): SessionMessageV1 | null {
+    if (!input || typeof input !== "object") return null;
+    const candidate = input as Partial<SessionMessageV1>;
+    const role = String(candidate.role || "");
+    if (role !== "user" && role !== "assistant") return null;
+    if (!Array.isArray(candidate.parts)) return null;
+    return candidate as SessionMessageV1;
+  }
+
+  private hasStructuredAssistantParts(message: SessionMessageV1 | null): boolean {
+    if (!message || message.role !== "assistant" || !Array.isArray(message.parts)) {
+      return false;
+    }
+    return message.parts.some((part) => {
+      if (!part || typeof part !== "object") return false;
+      const type = typeof part.type === "string" ? part.type.trim() : "";
+      return Boolean(type) && type !== "text";
+    });
+  }
+
+  private mergeInflightWithFinal(
+    inflight: SessionMessageV1,
+    finalMessage: SessionMessageV1,
+  ): SessionMessageV1 {
+    const final_parts = Array.isArray(finalMessage.parts)
+      ? finalMessage.parts.filter((part) => part && typeof part === "object")
+      : [];
+    if (this.hasStructuredAssistantParts(finalMessage)) {
+      return finalMessage;
+    }
+    if (final_parts.length === 0) return inflight;
+
+    const inflight_parts = Array.isArray(inflight.parts)
+      ? inflight.parts
+      : [];
+    const last_inflight_part =
+      inflight_parts.length > 0 ? inflight_parts[inflight_parts.length - 1] : undefined;
+    const last_inflight_text =
+      last_inflight_part &&
+      typeof last_inflight_part === "object" &&
+      last_inflight_part.type === "text" &&
+      typeof last_inflight_part.text === "string"
+        ? last_inflight_part.text.trim()
+        : "";
+    const append_parts = final_parts.filter((part, index) => {
+      if (index > 0) return true;
+      if (!part || typeof part !== "object" || part.type !== "text") return true;
+      const next_text = typeof part.text === "string" ? part.text.trim() : "";
+      if (!next_text) return false;
+      return next_text !== last_inflight_text;
+    });
+
+    return {
+      ...inflight,
+      id: finalMessage.id,
+      metadata: {
+        ...(inflight.metadata || {
+          v: 1 as const,
+          ts: Date.now(),
+          sessionId: this.sessionId,
+        }),
+        ...(finalMessage.metadata || {}),
+      },
+      parts: [...inflight_parts, ...append_parts],
+    };
+  }
+
   private async readMetaUnsafe(): Promise<SessionHistoryMetaV1> {
     const file = this.getMetaFilePath();
     try {
@@ -261,6 +342,40 @@ export class JsonlSessionHistoryStore implements SessionHistoryStore {
     await fs.writeJson(this.getMetaFilePath(), normalized, { spaces: 2 });
   }
 
+  private async readInflightUnsafe(): Promise<SessionMessageV1 | null> {
+    const file = this.getInflightFilePath();
+    try {
+      const raw = await fs.readJson(file);
+      return this.normalizePersistedMessage(raw);
+    } catch {
+      return null;
+    }
+  }
+
+  private async writeInflightUnsafe(message: SessionMessageV1): Promise<void> {
+    const normalized = this.normalizePersistedMessage(message);
+    if (!normalized || normalized.role !== "assistant") {
+      throw new Error("inflight assistant must be an assistant UIMessage");
+    }
+    const file = this.getInflightFilePath();
+    const temp = `${file}.${process.pid}.${Date.now()}.tmp`;
+    await fs.ensureDir(path.dirname(file));
+    await fs.writeJson(temp, normalized, { spaces: 2 });
+    await fs.move(temp, file, { overwrite: true });
+  }
+
+  private async removeInflightUnsafe(): Promise<void> {
+    await fs.remove(this.getInflightFilePath());
+  }
+
+  private async appendMessageUnsafe(message: SessionMessageV1): Promise<void> {
+    await fs.appendFile(
+      this.getMessagesFilePath(),
+      JSON.stringify(message) + "\n",
+      "utf8",
+    );
+  }
+
   private async withWriteLock<T>(fn: () => Promise<T>): Promise<T> {
     await this.ensureLayout();
     const lockPath = this.getLockFilePath();
@@ -361,11 +476,48 @@ export class JsonlSessionHistoryStore implements SessionHistoryStore {
 
   async append(message: SessionMessageV1): Promise<void> {
     await this.withWriteLock(async () => {
-      await fs.appendFile(
-        this.getMessagesFilePath(),
-        JSON.stringify(message) + "\n",
-        "utf8",
-      );
+      const normalized = this.normalizePersistedMessage(message);
+      if (!normalized) return;
+
+      // 关键点（中文）：若上一次 assistant 在运行中中断，新的 user 到来前先把残留快照收口到正式历史，
+      // 避免 `list()` 时旧 inflight 跑到新 user 后面，打乱时序。
+      if (normalized.role === "user") {
+        const current_inflight = await this.readInflightUnsafe();
+        if (current_inflight) {
+          await this.appendMessageUnsafe(current_inflight);
+          await this.removeInflightUnsafe();
+        }
+      }
+
+      await this.appendMessageUnsafe(normalized);
+    });
+  }
+
+  async readInflight(): Promise<SessionMessageV1 | null> {
+    await this.ensureLayout();
+    return this.readInflightUnsafe();
+  }
+
+  async writeInflight(message: SessionMessageV1): Promise<void> {
+    await this.withWriteLock(async () => {
+      await this.writeInflightUnsafe(message);
+    });
+  }
+
+  async finalizeInflight(message?: SessionMessageV1 | null): Promise<void> {
+    await this.withWriteLock(async () => {
+      const current_inflight = await this.readInflightUnsafe();
+      const normalized_message = this.normalizePersistedMessage(message);
+      const final_message =
+        current_inflight && normalized_message
+          ? this.mergeInflightWithFinal(current_inflight, normalized_message)
+          : normalized_message || current_inflight;
+      if (final_message) {
+        await this.appendMessageUnsafe(final_message);
+      }
+      if (current_inflight) {
+        await this.removeInflightUnsafe();
+      }
     });
   }
 
@@ -377,16 +529,17 @@ export class JsonlSessionHistoryStore implements SessionHistoryStore {
     const out: SessionMessageV1[] = [];
     for (const line of lines) {
       try {
-        const obj = JSON.parse(line) as Partial<SessionMessageV1>;
-        if (!obj || typeof obj !== "object") continue;
-        const role = String(obj.role || "");
-        if (role !== "user" && role !== "assistant") continue;
-        if (!Array.isArray(obj.parts)) continue;
-        out.push(obj as SessionMessageV1);
+        const obj = this.normalizePersistedMessage(JSON.parse(line));
+        if (!obj) continue;
+        out.push(obj);
       } catch {
         // ignore invalid lines
       }
     }
+    const current_inflight = await this.readInflightUnsafe();
+    if (current_inflight) {
+      out.push(current_inflight);
+    }
     return out;
   }
 

package/src/executor/tools/shell/ShellToolFormatting.ts

@@ -3,35 +3,9 @@
  *
  * 关键点（中文）
  * - shell 会话生命周期已经统一收敛到 shell plugin runtime。
- * - 这里仅保留当前仍被 tool 与测试复用的最小能力：命令安全校验与 env 注入。
+ * - 这里仅保留当前仍被 tool 与测试复用的最小能力：命令安全校验。
  */
 
-import { stripInvocationAuthEnv } from "@/runtime/auth/AuthEnv.js";
-import { getSessionRunScope } from "@executor/SessionRunScope.js";
-
-function setEnvString(
-  env: NodeJS.ProcessEnv,
-  key: string,
-  value: string | undefined,
-): void {
-  if (typeof value !== "string") return;
-  const trimmed = value.trim();
-  if (!trimmed) return;
-  env[key] = trimmed;
-}
-
-function applyEnvMap(
-  env: NodeJS.ProcessEnv,
-  entries?: Record<string, string>,
-): void {
-  if (!entries) return;
-  for (const [rawKey, rawValue] of Object.entries(entries)) {
-    const key = String(rawKey || "").trim();
-    if (!key) continue;
-    setEnvString(env, key, rawValue);
-  }
-}
-
 /**
  * 对 `town chat send` 命令做前置安全校验。
  *
@@ -58,26 +32,3 @@ export function validateChatSendCommand(cmd: string): string | null {
     "If your message is multi-line, use `town chat send --stdin` (with heredoc/pipe), `--text-file`, or explicit `--text`.",
   ].join(" ");
 }
-
-/**
- * 构建 shell 子进程环境变量。
- *
- * 关键点（中文）
- * - 当前仍用于 shell tool / shell runtime 与相关测试。
- * - 优先级：显式注入 > 当前请求上下文变量 > 宿主进程环境。
- * - 默认剥离 Bearer Token，避免通用 shell 隐式走本地 HTTP。
- */
-export function buildShellContextEnv(
-  injected?: Record<string, string>,
-): NodeJS.ProcessEnv {
-  const env: NodeJS.ProcessEnv = { ...process.env };
-  const contextCtx = getSessionRunScope();
-
-  applyEnvMap(env, injected);
-  setEnvString(env, "DC_SESSION_ID", contextCtx?.sessionId);
-  setEnvString(env, "DC_CITY_HOST", process.env.DC_CITY_HOST);
-  setEnvString(env, "DC_CITY_PORT", process.env.DC_CITY_PORT);
-  stripInvocationAuthEnv(env);
-
-  return env;
-}

package/src/executor/types/SessionHistoryPaths.ts

@@ -30,4 +30,9 @@ export type SessionHistoryPathOverrides = {
    * 历史归档目录（通常是 `.../messages/archive`）。
    */
   archiveDirPath?: string;
+
+  /**
+   * 运行中 assistant 快照路径（通常是 `.../messages/inflight.json`）。
+   */
+  inflightFilePath?: string;
 };

package/src/index.ts

@@ -8,8 +8,8 @@
  */
 
 // Agent 入口
-export { Agent } from "./agent/Agent.js";
-export { RemoteAgent } from "./agent/RemoteAgent.js";
+export { Agent } from "./agent/local/Agent.js";
+export { RemoteAgent } from "./agent/remote/RemoteAgent.js";
 export {
   inferAgentModelLabel,
   normalizeAgentModel,
@@ -134,7 +134,7 @@ export {
 export { loadDowncityConfig } from "./config/Config.js";
 export {
   ensureRuntimeProjectReady,
-} from "./runtime/host/ProjectSetup.js";
+} from "./agent/local/ProjectSetup.js";
 export { assertProjectExecutionTarget } from "./config/ExecutionBinding.js";
 
 // 日志
@@ -144,7 +144,7 @@ export { getLogger, logger, type Logger } from "./utils/logger/Logger.js";
 export type {
   AgentPathRuntime,
   AgentPluginConfigRuntime,
-} from "./types/runtime/host/AgentHost.js";
+} from "./types/agent/AgentRuntimeAssembly.js";
 
 // 项目协议类型
 export type {
@@ -273,7 +273,7 @@ export type {
   UpsertChannelAccountInput,
   UpsertEnvEntryInput,
   UpsertGlobalEnvEntryInput,
-} from "./types/runtime/host/Store.js";
+} from "./types/platform/Store.js";
 
 // HTTP auth 协议类型
 export {

package/src/plugin/core/PluginCommandRequest.ts

@@ -2,7 +2,7 @@
  * PluginCommandRequest：统一 plugin runtime command 请求解析模块。
  *
  * 关键点（中文）
- * - 统一收口当前 HTTP 入口的请求体解析。
+ * - 统一收口 Town gateway command 入口的请求体解析。
  * - plugin runtime 远程调用统一走 runtime command 协议，不再让 action 自带 HTTP route。
  * - ActionSchedule 参数（`schedule` / `delay` / `time`）也在这里一次性归一化。
  */

package/src/plugin/core/PluginLocalExecution.ts

@@ -15,7 +15,7 @@ import { findPluginByName } from "@/plugin/core/PluginCatalog.js";
 import {
   createAgentPathRuntime,
   createAgentPluginConfigRuntime,
-} from "@/runtime/host/AgentHostRuntime.js";
+} from "@/agent/local/AgentRuntimeAssembly.js";
 import type { JsonValue } from "@/types/common/Json.js";
 import type {
   Plugin,