@downcity/agent 1.1.10 → 1.1.12

package/src/sdk/SdkSessionSystemComposer.ts

@@ -0,0 +1,261 @@
+/**
+ * SDK Session 默认 system composer。
+ *
+ * 关键点（中文）
+ * - 面向 `Agent` SDK 的本地会话执行场景。
+ * - 注入调用方显式传入的静态 instruction、显式注入 service system 与显式注册 plugin system。
+ * - SDK 不在 system 中注入动态变量；动态上下文应由调用方放入 user message。
+ */
+
+import { SessionSystemComposer } from "@session/composer/system/SessionSystemComposer.js";
+import { getSessionRunScope } from "@session/SessionRunScope.js";
+import type { SessionSystemMessage } from "@/session/types/SessionPrompts.js";
+import type {
+  AgentSessionSystemBlock,
+  AgentSessionSystemSessionInfo,
+} from "@/sdk/AgentSdkTypes.js";
+
+/**
+ * 解析 SDK session system blocks 的输入。
+ */
+export interface ResolveSdkSessionSystemBlocksParams {
+  /**
+   * 当前 agent 的稳定标识。
+   */
+  agentId: string;
+
+  /**
+   * 当前 agent 绑定的项目根目录。
+   */
+  projectRoot: string;
+
+  /**
+   * 当前 sessionId。
+   */
+  sessionId: string;
+
+  /**
+   * 当前 session 首次创建时间（ms）。
+   */
+  createdAt: number;
+
+  /**
+   * 当前 session 初始化时解析到的系统时区。
+   */
+  timezone: string;
+
+  /**
+   * 读取当前 SDK 调用方传入的 instruction system blocks。
+   */
+  getInstructionSystemBlocks: () => AgentSessionSystemBlock[];
+
+  /**
+   * 读取当前显式注入 service 的 system blocks。
+   */
+  getServiceSystemBlocks: () => Promise<AgentSessionSystemBlock[]>;
+
+  /**
+   * 读取当前显式注册 plugin 的 system blocks。
+   */
+  getPluginSystemBlocks: () => Promise<AgentSessionSystemBlock[]>;
+}
+
+type SdkSessionSystemComposerOptions = {
+  /**
+   * 当前 agent 的稳定标识。
+   */
+  agentId: string;
+
+  /**
+   * 当前 agent 绑定的项目根目录。
+   */
+  projectRoot: string;
+
+  /**
+   * 读取当前 session 首次创建时间（ms）。
+   */
+  getSessionCreatedAt: () => number;
+
+  /**
+   * 读取当前 session 初始化时解析到的系统时区。
+   */
+  getSessionTimezone: () => string;
+
+  /**
+   * 读取当前 SDK 调用方传入的 instruction system blocks。
+   */
+  getInstructionSystemBlocks: () => AgentSessionSystemBlock[];
+
+  /**
+   * 读取当前显式注册 plugin 的 system blocks。
+   */
+  getPluginSystemBlocks: () => Promise<AgentSessionSystemBlock[]>;
+
+  /**
+   * 读取当前显式注入 service 的 system blocks。
+   */
+  getServiceSystemBlocks: () => Promise<AgentSessionSystemBlock[]>;
+};
+
+function normalizeSystemBlocks(
+  blocks: AgentSessionSystemBlock[],
+): AgentSessionSystemBlock[] {
+  if (!Array.isArray(blocks)) return [];
+  return blocks
+    .map((block) => {
+      const content = String(block?.content || "").trim();
+      if (!content) return null;
+      const source = block.source;
+      if (
+        source !== "core" &&
+        source !== "instruction" &&
+        source !== "service" &&
+        source !== "plugin" &&
+        source !== "session"
+      ) {
+        return null;
+      }
+      return {
+        source,
+        name: String(block.name || source).trim() || source,
+        content,
+      } satisfies AgentSessionSystemBlock;
+    })
+    .filter((block): block is AgentSessionSystemBlock => Boolean(block));
+}
+
+function createSessionInfo(
+  params: Pick<
+    ResolveSdkSessionSystemBlocksParams,
+    "agentId" | "sessionId" | "projectRoot" | "createdAt" | "timezone"
+  >,
+): AgentSessionSystemSessionInfo {
+  const createdAt = Number.isFinite(params.createdAt) ? params.createdAt : 0;
+  return {
+    agentId: String(params.agentId || "").trim(),
+    sessionId: String(params.sessionId || "").trim(),
+    projectRoot: String(params.projectRoot || "").trim(),
+    createdAt: new Date(createdAt).toISOString(),
+    timezone: String(params.timezone || "").trim() || "UTC",
+  };
+}
+
+function createSessionSystemBlock(
+  session: AgentSessionSystemSessionInfo,
+): AgentSessionSystemBlock {
+  const content = [
+    "当前会话上下文：",
+    `你正在服务 agent "${session.agentId}" 的 session "${session.sessionId}"。`,
+    `当前项目根目录是 "${session.projectRoot}"。`,
+    `本会话创建于 ${session.createdAt}，参考时区是 ${session.timezone}。`,
+    "这个创建时间是当前会话的稳定参考时间，不代表每轮运行时的当前时间。",
+    "如果用户消息中提供了新的当前时间、相对时间或其他动态上下文，应优先使用用户消息中的动态信息。",
+  ].join("\n");
+  return {
+    source: "session",
+    name: "context",
+    content,
+  };
+}
+
+/**
+ * 解析 SDK session 当前生效的 system blocks。
+ */
+export async function resolveSdkSessionSystemBlocks(
+  params: ResolveSdkSessionSystemBlocksParams,
+): Promise<AgentSessionSystemBlock[]> {
+  const agentId = String(params.agentId || "").trim();
+  const projectRoot = String(params.projectRoot || "").trim();
+  const sessionId = String(params.sessionId || "").trim();
+  const createdAt = Number(params.createdAt || 0);
+  const timezone = String(params.timezone || "").trim();
+  if (!agentId) {
+    throw new Error("resolveSdkSessionSystemBlocks requires a non-empty agentId");
+  }
+  if (!projectRoot) {
+    throw new Error("resolveSdkSessionSystemBlocks requires a non-empty projectRoot");
+  }
+  if (!sessionId) {
+    throw new Error("resolveSdkSessionSystemBlocks requires a non-empty sessionId");
+  }
+  if (!Number.isFinite(createdAt) || createdAt <= 0) {
+    throw new Error("resolveSdkSessionSystemBlocks requires a valid createdAt");
+  }
+  if (!timezone) {
+    throw new Error("resolveSdkSessionSystemBlocks requires a non-empty timezone");
+  }
+  return [
+    ...normalizeSystemBlocks(params.getInstructionSystemBlocks()),
+    ...normalizeSystemBlocks(await params.getServiceSystemBlocks()),
+    ...normalizeSystemBlocks(await params.getPluginSystemBlocks()),
+    // session block 放在最后，尽量保留前缀 system blocks 的跨 session 缓存命中。
+    createSessionSystemBlock(
+      createSessionInfo({ agentId, projectRoot, sessionId, createdAt, timezone }),
+    ),
+  ];
+}
+
+/**
+ * 解析 SDK session 当前生效的 system messages。
+ */
+export async function resolveSdkSessionSystemMessages(
+  params: ResolveSdkSessionSystemBlocksParams,
+): Promise<SessionSystemMessage[]> {
+  const blocks = await resolveSdkSessionSystemBlocks(params);
+  return blocks.map((block) => ({
+    role: "system" as const,
+    content: block.content,
+  }));
+}
+
+/**
+ * SDK Session system composer 实现。
+ */
+export class SdkSessionSystemComposer extends SessionSystemComposer {
+  readonly name = "sdk_prompt_system";
+
+  private readonly agentId: string;
+  private readonly projectRoot: string;
+  private readonly getSessionCreatedAt: SdkSessionSystemComposerOptions["getSessionCreatedAt"];
+  private readonly getSessionTimezone: SdkSessionSystemComposerOptions["getSessionTimezone"];
+  private readonly getInstructionSystemBlocks: SdkSessionSystemComposerOptions["getInstructionSystemBlocks"];
+  private readonly getServiceSystemBlocks: SdkSessionSystemComposerOptions["getServiceSystemBlocks"];
+  private readonly getPluginSystemBlocks: SdkSessionSystemComposerOptions["getPluginSystemBlocks"];
+
+  constructor(options: SdkSessionSystemComposerOptions) {
+    super();
+    this.agentId = String(options.agentId || "").trim();
+    this.projectRoot = String(options.projectRoot || "").trim();
+    this.getSessionCreatedAt = options.getSessionCreatedAt;
+    this.getSessionTimezone = options.getSessionTimezone;
+    this.getInstructionSystemBlocks = options.getInstructionSystemBlocks;
+    this.getServiceSystemBlocks = options.getServiceSystemBlocks;
+    this.getPluginSystemBlocks = options.getPluginSystemBlocks;
+    if (!this.agentId) {
+      throw new Error("SdkSessionSystemComposer requires a non-empty agentId");
+    }
+    if (!this.projectRoot) {
+      throw new Error("SdkSessionSystemComposer requires a non-empty projectRoot");
+    }
+  }
+
+  /**
+   * 解析本轮 SDK session system messages。
+   */
+  async resolve() {
+    const sessionId = String(getSessionRunScope()?.sessionId || "").trim();
+    if (!sessionId) {
+      throw new Error("SdkSessionSystemComposer.resolve requires a non-empty sessionId");
+    }
+    return await resolveSdkSessionSystemMessages({
+      agentId: this.agentId,
+      projectRoot: this.projectRoot,
+      sessionId,
+      createdAt: this.getSessionCreatedAt(),
+      timezone: this.getSessionTimezone(),
+      getInstructionSystemBlocks: this.getInstructionSystemBlocks,
+      getServiceSystemBlocks: this.getServiceSystemBlocks,
+      getPluginSystemBlocks: this.getPluginSystemBlocks,
+    });
+  }
+}

package/src/{host/sdk → sdk}/Session.ts

@@ -8,12 +8,11 @@
  */
 
 import { nanoid } from "nanoid";
-import type { LanguageModel, Tool, UIMessageChunk } from "ai";
+import type { LanguageModel, Tool } from "ai";
 import { Session as CoreSession } from "@session/Session.js";
 import { JsonlSessionHistoryComposer } from "@session/composer/history/jsonl/JsonlSessionHistoryComposer.js";
 import { JsonlSessionCompactionComposer } from "@session/composer/compaction/jsonl/JsonlSessionCompactionComposer.js";
 import { LocalSessionExecutor } from "@session/executors/local/LocalSessionExecutor.js";
-import { resolveAssistantMessageForPersistence } from "@/service/builtins/chat/runtime/UserVisibleText.js";
 import { extractTextFromUiMessage } from "@/service/builtins/chat/runtime/UIMessageTransformer.js";
 import type {
   AgentSessionConfigSnapshot,
@@ -23,22 +22,33 @@ import type {
   AgentSessionRunResult,
   AgentSessionSetInput,
   AgentSessionStreamEvent,
-} from "@/host/sdk/AgentSdkTypes.js";
-import type { SessionHistoryMetaV1 } from "@/session/types/SessionHistoryMeta.js";
+  AgentSessionSystemBlock,
+  AgentSessionSystemSnapshot,
+} from "@/sdk/AgentSdkTypes.js";
 import type { SessionMessageV1 } from "@/session/types/SessionMessages.js";
-import { SdkSessionSystemComposer } from "@/host/sdk/SdkSessionSystemComposer.js";
+import {
+  resolveSdkSessionSystemBlocks,
+  SdkSessionSystemComposer,
+} from "@/sdk/SdkSessionSystemComposer.js";
 import {
   inferModelLabel,
   patchSdkSessionModelLabel,
   readSdkSessionMetadata,
+  resolveSystemTimezone,
   writeSdkSessionMetadata,
-} from "@/host/sdk/SessionMetadata.js";
+} from "@/sdk/SessionMetadata.js";
 import {
   getSdkAgentSessionArchiveDirPath,
   getSdkAgentSessionDirPath,
-} from "@/host/sdk/Paths.js";
-import { AsyncQueue } from "@/host/sdk/AsyncQueue.js";
-import type { SessionPort } from "@/agent/AgentContextTypes.js";
+} from "@/sdk/Paths.js";
+import { AsyncQueue } from "@/sdk/AsyncQueue.js";
+import type { SessionPort } from "@/runtime/AgentContextTypes.js";
+import { pushUiMessageChunkAsSdkEvent } from "@/sdk/StreamEvents.js";
+import {
+  persistSdkAssistantResult,
+  touchSdkSessionMetadata,
+} from "@/sdk/SessionPersistence.js";
+import { createSdkSessionServicePort } from "@/sdk/SessionServicePort.js";
 
 type SdkSessionOptions = {
   /**
@@ -70,19 +80,19 @@ type SdkSessionOptions = {
   };
 
   /**
-   * 读取静态 system 文本集合。
+   * 读取当前 SDK 调用方传入的 instruction system blocks。
    */
-  getStaticSystemPrompts: () => string[];
+  getInstructionSystemBlocks: () => AgentSessionSystemBlock[];
 
   /**
-   * 读取当前 agent 显式注入 service 的 system 文本集合。
+   * 读取当前 agent 显式注入 service 的 system blocks。
    */
-  getServiceSystemPrompts: () => Promise<string[]>;
+  getServiceSystemBlocks: () => Promise<AgentSessionSystemBlock[]>;
 
   /**
-   * 读取当前 agent 显式注册 plugin 的 system 文本集合。
+   * 读取当前 agent 显式注册 plugin 的 system blocks。
    */
-  getPluginSystemPrompts: () => Promise<string[]>;
+  getPluginSystemBlocks: () => Promise<AgentSessionSystemBlock[]>;
 };
 
 /**
@@ -95,12 +105,14 @@ export class SdkSession {
   private readonly projectRoot: string;
   private readonly tools: Record<string, Tool>;
   private readonly logger: SdkSessionOptions["logger"];
-  private readonly getStaticSystemPrompts: SdkSessionOptions["getStaticSystemPrompts"];
-  private readonly getServiceSystemPrompts: SdkSessionOptions["getServiceSystemPrompts"];
-  private readonly getPluginSystemPrompts: SdkSessionOptions["getPluginSystemPrompts"];
+  private readonly getInstructionSystemBlocks: SdkSessionOptions["getInstructionSystemBlocks"];
+  private readonly getServiceSystemBlocks: SdkSessionOptions["getServiceSystemBlocks"];
+  private readonly getPluginSystemBlocks: SdkSessionOptions["getPluginSystemBlocks"];
   private readonly historyComposer: JsonlSessionHistoryComposer;
   private readonly coreSession: CoreSession;
   private sessionConfig: AgentSessionConfigSnapshot = {};
+  private createdAt = Date.now();
+  private timezone = resolveSystemTimezone();
   private initializePromise: Promise<this> | null = null;
   private servicePort: SessionPort | null = null;
 
@@ -110,9 +122,9 @@ export class SdkSession {
     this.projectRoot = String(options.projectRoot || "").trim();
     this.tools = options.tools;
     this.logger = options.logger;
-    this.getStaticSystemPrompts = options.getStaticSystemPrompts;
-    this.getServiceSystemPrompts = options.getServiceSystemPrompts;
-    this.getPluginSystemPrompts = options.getPluginSystemPrompts;
+    this.getInstructionSystemBlocks = options.getInstructionSystemBlocks;
+    this.getServiceSystemBlocks = options.getServiceSystemBlocks;
+    this.getPluginSystemBlocks = options.getPluginSystemBlocks;
     if (!this.id) {
       throw new Error("SdkSession requires a non-empty sessionId");
     }
@@ -161,10 +173,13 @@ export class SdkSession {
           historyComposer,
           compactionComposer: new JsonlSessionCompactionComposer(),
           systemComposer: new SdkSessionSystemComposer({
+            agentId: this.agentId,
             projectRoot: this.projectRoot,
-            getStaticSystemPrompts: this.getStaticSystemPrompts,
-            getServiceSystemPrompts: this.getServiceSystemPrompts,
-            getPluginSystemPrompts: this.getPluginSystemPrompts,
+            getSessionCreatedAt: () => this.createdAt,
+            getSessionTimezone: () => this.timezone,
+            getInstructionSystemBlocks: this.getInstructionSystemBlocks,
+            getServiceSystemBlocks: this.getServiceSystemBlocks,
+            getPluginSystemBlocks: this.getPluginSystemBlocks,
           }),
           getTools: () => this.tools,
         });
@@ -185,6 +200,12 @@ export class SdkSession {
         agentId: this.agentId,
         sessionId: this.id,
       });
+      const createdAt =
+        typeof metadata.createdAt === "number" ? metadata.createdAt : Date.now();
+      const timezone =
+        typeof metadata.timezone === "string" && metadata.timezone.trim()
+          ? metadata.timezone.trim()
+          : resolveSystemTimezone();
       await writeSdkSessionMetadata({
         projectRoot: this.projectRoot,
         agentId: this.agentId,
@@ -192,10 +213,12 @@ export class SdkSession {
         meta: {
           ...metadata,
           agentId: this.agentId,
-          createdAt:
-            typeof metadata.createdAt === "number" ? metadata.createdAt : Date.now(),
+          createdAt,
+          timezone,
         },
       });
+      this.createdAt = createdAt;
+      this.timezone = timezone;
       this.sessionConfig = {
         ...(metadata.sdkConfig?.modelLabel
           ? { modelLabel: metadata.sdkConfig.modelLabel }
@@ -269,6 +292,38 @@ export class SdkSession {
     return await this.historyComposer.list();
   }
 
+  /**
+   * 读取当前 session 生效的 system prompt 文本集合。
+   *
+   * 关键点（中文）
+   * - 返回内容与实际 run 时使用的 SDK system composer 同源。
+   * - 包含 instruction/core、显式注入 service system、显式注册 plugin system 与 session 上下文。
+   * - 返回结构化快照，不把 system prompt 写入会话历史。
+   */
+  async system(): Promise<AgentSessionSystemSnapshot> {
+    const blocks = await resolveSdkSessionSystemBlocks({
+      agentId: this.agentId,
+      projectRoot: this.projectRoot,
+      sessionId: this.id,
+      createdAt: this.createdAt,
+      timezone: this.timezone,
+      getInstructionSystemBlocks: this.getInstructionSystemBlocks,
+      getServiceSystemBlocks: this.getServiceSystemBlocks,
+      getPluginSystemBlocks: this.getPluginSystemBlocks,
+    });
+    return {
+      sessionId: this.id,
+      session: {
+        agentId: this.agentId,
+        sessionId: this.id,
+        projectRoot: this.projectRoot,
+        createdAt: new Date(this.createdAt).toISOString(),
+        timezone: this.timezone,
+      },
+      blocks,
+    };
+  }
+
   /**
    * 返回当前 session 是否正在执行。
    */
@@ -323,7 +378,11 @@ export class SdkSession {
         const result = await this.coreSession.run({
           query,
           onUiMessageChunkCallback: async (chunk) => {
-            this.pushChunkEvent(queue, chunk, toolNameByCallId);
+            pushUiMessageChunkAsSdkEvent({
+              queue,
+              chunk,
+              toolNameByCallId,
+            });
           },
         });
         await this.persistAssistantResult(result.assistantMessage);
@@ -371,9 +430,9 @@ export class SdkSession {
       sessionId: `fork-${Date.now()}-${nanoid(8)}`,
       tools: this.tools,
       logger: this.logger,
-      getStaticSystemPrompts: this.getStaticSystemPrompts,
-      getServiceSystemPrompts: this.getServiceSystemPrompts,
-      getPluginSystemPrompts: this.getPluginSystemPrompts,
+      getInstructionSystemBlocks: this.getInstructionSystemBlocks,
+      getServiceSystemBlocks: this.getServiceSystemBlocks,
+      getPluginSystemBlocks: this.getPluginSystemBlocks,
     });
     await forked.initialize();
     if (this.sessionConfig.model) {
@@ -410,173 +469,39 @@ export class SdkSession {
 
   /**
    * 返回供 chat service 使用的 session 端口。
-   *
-   * 关键点（中文）
-   * - 这里不走 SDK `run()` 包装层，而是直接暴露底层 `CoreSession` 协议。
-   * - 这样 chat queue worker 可以复用既有 `SessionPort` 契约，不会重复补写消息。
    */
   getServicePort(): SessionPort {
     if (this.servicePort) return this.servicePort;
-    this.servicePort = {
+    this.servicePort = createSdkSessionServicePort({
       sessionId: this.id,
-      getExecutor: () => this.coreSession.getExecutor(),
-      getHistoryComposer: () => this.historyComposer,
-      run: async (params) => {
-        return await this.coreSession.run(params);
-      },
-      clearExecutor: () => {
-        this.coreSession.clearExecutor();
-      },
-      afterSessionUpdatedAsync: async () => {
-        await this.coreSession.afterSessionUpdatedAsync();
-      },
-      appendUserMessage: async (params) => {
-        await this.coreSession.appendUserMessage(params);
-        await this.touchMetadata();
-      },
-      appendAssistantMessage: async (params) => {
-        await this.coreSession.appendAssistantMessage(params);
+      coreSession: this.coreSession,
+      historyComposer: this.historyComposer,
+      touchMetadata: async () => {
         await this.touchMetadata();
       },
-      isExecuting: () => this.coreSession.isExecuting(),
-    };
+    });
     return this.servicePort;
   }
 
   private async touchMetadata(): Promise<void> {
-    const current = await readSdkSessionMetadata({
+    await touchSdkSessionMetadata({
       projectRoot: this.projectRoot,
       agentId: this.agentId,
       sessionId: this.id,
-    });
-    const next: SessionHistoryMetaV1 = {
-      ...current,
-      agentId: this.agentId,
-      createdAt:
-        typeof current.createdAt === "number" ? current.createdAt : Date.now(),
-      updatedAt: Date.now(),
-      ...(this.sessionConfig.modelLabel
-        ? {
-            sdkConfig: {
-              ...(current.sdkConfig || {}),
-              modelLabel: this.sessionConfig.modelLabel,
-            },
-          }
-        : {}),
-    };
-    await writeSdkSessionMetadata({
-      projectRoot: this.projectRoot,
-      agentId: this.agentId,
-      sessionId: this.id,
-      meta: next,
+      sessionConfig: this.sessionConfig,
     });
   }
 
   private async persistAssistantResult(
     assistantMessage: SessionMessageV1,
   ): Promise<void> {
-    const persisted = resolveAssistantMessageForPersistence(assistantMessage);
-    await this.coreSession.appendAssistantMessage({
-      ...(persisted ? { message: persisted } : {}),
-      fallbackText: extractTextFromUiMessage(assistantMessage),
+    await persistSdkAssistantResult({
+      projectRoot: this.projectRoot,
+      agentId: this.agentId,
+      sessionId: this.id,
+      sessionConfig: this.sessionConfig,
+      coreSession: this.coreSession,
+      assistantMessage,
     });
-    await this.touchMetadata();
-  }
-
-  private pushChunkEvent(
-    queue: AsyncQueue<AgentSessionStreamEvent>,
-    chunk: UIMessageChunk,
-    toolNameByCallId: Map<string, string>,
-  ): void {
-    switch (chunk.type) {
-      case "text-delta":
-        queue.push({
-          type: "text-delta",
-          text: chunk.delta,
-        });
-        return;
-      case "reasoning-delta":
-        queue.push({
-          type: "reasoning-delta",
-          text: chunk.delta,
-        });
-        return;
-      case "tool-input-start":
-        toolNameByCallId.set(chunk.toolCallId, chunk.toolName);
-        return;
-      case "tool-input-available":
-        toolNameByCallId.set(chunk.toolCallId, chunk.toolName);
-        queue.push({
-          type: "tool-call",
-          toolCallId: chunk.toolCallId,
-          toolName: chunk.toolName,
-          args: this.toJsonValue(chunk.input),
-        });
-        return;
-      case "tool-output-available":
-        queue.push({
-          type: "tool-result",
-          toolCallId: chunk.toolCallId,
-          toolName: toolNameByCallId.get(chunk.toolCallId) || "unknown",
-          result: this.toJsonValue(chunk.output),
-        });
-        return;
-      case "tool-output-error":
-        queue.push({
-          type: "tool-error",
-          toolCallId: chunk.toolCallId,
-          toolName: toolNameByCallId.get(chunk.toolCallId) || "unknown",
-          error: chunk.errorText,
-        });
-        return;
-      case "tool-input-error":
-        toolNameByCallId.set(chunk.toolCallId, chunk.toolName);
-        queue.push({
-          type: "tool-error",
-          toolCallId: chunk.toolCallId,
-          toolName: chunk.toolName,
-          error: chunk.errorText,
-        });
-        return;
-      case "error":
-        queue.push({
-          type: "error",
-          error: chunk.errorText,
-        });
-        return;
-      case "abort":
-        queue.push({
-          type: "error",
-          error: String(chunk.reason || "stream aborted"),
-        });
-        return;
-      case "finish":
-        queue.push({
-          type: "finish",
-          ...(typeof chunk.finishReason === "string"
-            ? { finishReason: chunk.finishReason }
-            : {}),
-        });
-        return;
-      default:
-        return;
-    }
-  }
-
-  private toJsonValue(value: unknown) {
-    if (value === undefined) return null;
-    if (value === null) return null;
-    if (
-      typeof value === "string" ||
-      typeof value === "number" ||
-      typeof value === "boolean"
-    ) {
-      return value;
-    }
-    try {
-      return JSON.parse(JSON.stringify(value));
-    } catch {
-      return String(value);
-    }
   }
 }