@downcity/agent 1.1.401 → 1.1.408

package/scripts/agent-multi-workspace.test.mjs

@@ -77,6 +77,73 @@ test("one Agent enters multiple Workspaces with contextual Plugin execution", as
 
 });
 
+test("PluginContext sessions keep the current Workspace binding", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-plugin-sessions-"));
+  let linked_session_id = "";
+  const plugin = create_plugin({
+    name: "session_probe",
+    title: "Session Probe",
+    description: "Validates the current Workspace Session view.",
+    actions: {
+      inspect: {
+        description: "Restore one Session and create another in the current Workspace.",
+        execute: async ({ context }) => {
+          const linked_session = await context.sessions.get(linked_session_id);
+          const task_session = await context.sessions.create();
+          await context.sessions.runtime(linked_session_id).append_assistant_message({
+            text: "task completed",
+          });
+          return {
+            success: true,
+            data: {
+              linked_workspace_id: linked_session.workspace_id,
+              task_workspace_id: task_session.workspace_id,
+            },
+          };
+        },
+      },
+    },
+  });
+  const agent = new Agent({ id: "plugin-session-agent", plugins: [plugin] });
+  const entry = create_workspace_entry(agent, new Workspace({
+    id: "plugin-session-workspace",
+    path: root,
+    data_root_path: path.join(root, "data"),
+  }));
+
+  try {
+    const linked_session = await entry.sessions.create();
+    linked_session_id = linked_session.id;
+    const mutations = [];
+    const unsubscribe = linked_session.subscribe((mutation) => {
+      mutations.push(mutation);
+    });
+    const result = await entry.plugins.run_action({
+      plugin: "session_probe",
+      action: "inspect",
+    });
+    unsubscribe();
+    assert.equal(result.success, true);
+    assert.deepEqual(result.data, {
+      linked_workspace_id: "plugin-session-workspace",
+      task_workspace_id: "plugin-session-workspace",
+    });
+    const messages = await linked_session.messages();
+    assert.equal(messages.items.at(-1)?.type, "assistant");
+    assert.equal(messages.items.at(-1)?.parts.at(-1)?.type, "text");
+    assert.equal(messages.items.at(-1)?.parts.at(-1)?.text, "task completed");
+    assert.equal(
+      mutations.some((mutation) =>
+        mutation.variant === "message" && mutation.type === "assistant"
+      ),
+      true,
+    );
+  } finally {
+    await agent.dispose();
+    await fs.rm(root, { recursive: true, force: true });
+  }
+});
+
 test("Plugin runtime data is isolated by Agent and shared across Workspaces", async () => {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), "downcity-agent-plugin-data-"));
   const contexts = [];

package/scripts/core-engine-context-compaction.test.mjs

@@ -146,6 +146,55 @@ test("新的持久化 Summary 只按 50% 水位验收一次", async () => {
   assert.equal(second.compact_required, undefined);
 });
 
+test("Provider 在输出前发生可重试流错误时自动重试", async () => {
+  let call_count = 0;
+  const model = {
+    id: "retryable-stream-model",
+    async stream() {
+      call_count += 1;
+      return new ReadableStream({
+        start(controller) {
+          controller.enqueue({
+            type: "model_start",
+            request_id: `request_${call_count}`,
+            model_id: "retryable-stream-model",
+          });
+          if (call_count === 1) {
+            controller.enqueue({
+              type: "model_error",
+              error: {
+                code: "transport_error",
+                message: "temporary disconnect",
+                retryable: true,
+              },
+            });
+          } else {
+            controller.enqueue({ type: "text_start", content_id: "text_1" });
+            controller.enqueue({ type: "text_delta", content_id: "text_1", delta: "done" });
+            controller.enqueue({ type: "text_finish", content_id: "text_1" });
+            controller.enqueue({
+              type: "model_usage",
+              usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 },
+            });
+            controller.enqueue({ type: "model_finish", finish_reason: "stop" });
+          }
+          controller.close();
+        },
+      });
+    },
+  };
+  const messages = [{
+    role: "user",
+    content: [{ type: "text", text: "latest request" }],
+  }];
+
+  const result = await create_runner().execute(create_turn_input(model, messages));
+
+  assert.equal(call_count, 2);
+  assert.equal(result.success, true);
+  assert.equal(result.text, "done");
+});
+
 test("显式 compact 后在下一次 provider 调用前重载 canonical history", async () => {
   const provider_prompts = [];
   const compacted_messages = [{

package/scripts/core-engine-model-stream.test.mjs

@@ -85,3 +85,72 @@ test("Agent 拒绝不合法的 Downcity 模型流状态", async () => {
     }), /Invalid Downcity model stream/);
   }
 });
+
+test("模型生成无效工具输入时向下一 Step 返回 failed tool_result", async () => {
+  let executed = false;
+  const model = {
+    id: "invalid-tool-input-model",
+    async stream() {
+      return new ReadableStream({
+        start(controller) {
+          controller.enqueue({ type: "model_start", request_id: "request_1", model_id: "invalid-tool-input-model" });
+          controller.enqueue({ type: "tool_call_start", content_id: "tool_1", tool_call_id: "call_1", tool_name: "write" });
+          controller.enqueue({ type: "tool_call_delta", content_id: "tool_1", input_delta: "{\"content\":\"partial" });
+          controller.enqueue({
+            type: "tool_call_finish",
+            content_id: "tool_1",
+            input: {},
+            input_error: "Tool call arguments are invalid JSON: Unterminated string",
+          });
+          controller.enqueue({ type: "model_usage", usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 } });
+          controller.enqueue({ type: "model_finish", finish_reason: "tool_call" });
+          controller.close();
+        },
+      });
+    },
+  };
+
+  const result = await run_model_step({
+    model,
+    system: [],
+    messages: [{ role: "user", content: [{ type: "text", text: "write" }] }],
+    tools: { write: { execute: async () => { executed = true; } } },
+    abort_signal: new AbortController().signal,
+  });
+
+  assert.equal(executed, false);
+  assert.equal(result.step_result.tool_results[0].success, false);
+  const tool_message = result.step_result.response.messages[1];
+  assert.equal(tool_message.content[0].outcome, "failed");
+  assert.match(tool_message.content[0].content[0].value.error, /invalid JSON/);
+});
+
+test("Tool 返回 success false 时不会被标记为成功", async () => {
+  const model = {
+    id: "structured-tool-failure-model",
+    async stream() {
+      return new ReadableStream({
+        start(controller) {
+          controller.enqueue({ type: "model_start", request_id: "request_1", model_id: "structured-tool-failure-model" });
+          controller.enqueue({ type: "tool_call_start", content_id: "tool_1", tool_call_id: "call_1", tool_name: "shell" });
+          controller.enqueue({ type: "tool_call_finish", content_id: "tool_1", input: {} });
+          controller.enqueue({ type: "model_usage", usage: { input_tokens: 1, output_tokens: 1, total_tokens: 2 } });
+          controller.enqueue({ type: "model_finish", finish_reason: "tool_call" });
+          controller.close();
+        },
+      });
+    },
+  };
+
+  const result = await run_model_step({
+    model,
+    system: [],
+    messages: [{ role: "user", content: [{ type: "text", text: "run" }] }],
+    tools: { shell: { execute: async () => ({ success: false, exit_code: 1, error: "command failed" }) } },
+    abort_signal: new AbortController().signal,
+  });
+
+  assert.equal(result.step_result.tool_results[0].success, false);
+  assert.equal(result.assistant_parts[0].state, "failed");
+  assert.equal(result.step_result.response.messages[1].content[0].outcome, "failed");
+});

package/src/agent/WorkspaceEntry.ts

@@ -125,7 +125,7 @@ export class WorkspaceEntry {
         return contextual_plugins;
       },
       get_sessions: () => {
-        return this.agent.sessions;
+        return this.sessions;
       },
     } satisfies Parameters<typeof create_plugin_context>[0];
     this.context = create_plugin_context(context_input);

package/src/city/types/PluginHostContext.ts

@@ -9,6 +9,7 @@
  */
 
 import type { JsonObject, Logger } from "@/index.js";
+import type { PluginNotificationPublisher } from "@/types/plugin/PluginNotification.js";
 
 /** City 可以为未来宿主能力增加的显式扩展集合。 */
 export type PluginHostExtensions = Readonly<Record<string, unknown>>;
@@ -27,6 +28,9 @@ export interface PluginHostContext {
   /** City 提供的宿主日志器。 */
   readonly logger: Logger;
 
+  /** 宿主可选提供的通知发布能力；不支持通知的宿主省略。 */
+  readonly notifications?: PluginNotificationPublisher;
+
   /** City 为未来宿主能力保留的显式扩展区。 */
   readonly extensions: PluginHostExtensions;
 }

package/src/executor/core-engine/CoreEngineError.ts

@@ -38,10 +38,16 @@ export function resolve_effective_core_engine_error(params: {
    */
   streamError?: unknown;
 }): string {
-  const outerError = String(params.error ?? "").trim();
-  const innerError = String(params.streamError ?? "").trim();
+  const outerError = read_error_message(params.error);
+  const innerError = read_error_message(params.streamError);
   if (/AI_NoOutputGeneratedError|No output generated/i.test(outerError) && innerError) {
     return innerError;
   }
   return outerError || innerError || "Unknown execution error";
 }
+
+/** 读取适合向上层展示的错误正文，避免泄漏内部 Error class 名称。 */
+function read_error_message(error: unknown): string {
+  if (error instanceof Error) return error.message.trim();
+  return String(error ?? "").trim();
+}

package/src/executor/core-engine/CoreEngineRunner.ts

@@ -34,6 +34,7 @@ import {
   type ModelStepResult,
   type ModelStepToolCall,
 } from "@executor/model/ModelStepRunner.js";
+import { is_retryable_empty_model_stream_failure } from "@executor/model/ModelStreamFailure.js";
 import { CoreEngineMessageState } from "@executor/core-engine/CoreEngineMessageState.js";
 import {
   deep_compact_model_messages,
@@ -58,6 +59,10 @@ const TURN_STOPPED_MESSAGE = "Turn stopped";
 
 /** Provider context-length error 在当前 step 内最多压缩重试三次。 */
 const MAX_CONTEXT_ERROR_COMPACTION_RETRIES = 3;
+/** 无任何可见输出时，临时 Provider 流错误的最大自动重试次数。 */
+const MAX_EMPTY_STREAM_RETRIES = 2;
+/** 无输出流错误的重试退避，避免立即重复冲击同一 Provider。 */
+const EMPTY_STREAM_RETRY_DELAYS_MS = [300, 1_000] as const;
 
 interface CoreEngineRunnerOptions {
   /** 当前 Session 稳定标识。 */
@@ -181,6 +186,7 @@ export class CoreEngineRunner {
 
       let incomplete_response_recovery_count = 0;
       let context_error_compaction_retries = 0;
+      let empty_stream_retry_count = 0;
       let compact_pending = false;
       let compact_validation_pending = Boolean(
         persisted_compaction_summary_id &&
@@ -293,6 +299,24 @@ export class CoreEngineRunner {
           ) {
             await input.turn_context.output.assistant.abort_step();
           }
+          if (
+            is_retryable_empty_model_stream_failure(error) &&
+            empty_stream_retry_count < MAX_EMPTY_STREAM_RETRIES
+          ) {
+            empty_stream_retry_count += 1;
+            await this.logger.log("warn", "[agent] model_stream.retry", {
+              session_id,
+              retry_count: empty_stream_retry_count,
+              error_code: error.code,
+              error: error.message,
+              provider_request_id: error.provider_request_id ?? null,
+            });
+            await wait_for_stream_retry(
+              EMPTY_STREAM_RETRY_DELAYS_MS[empty_stream_retry_count - 1] ?? 1_000,
+              input.turn_context.lifecycle.abort_signal,
+            );
+            continue;
+          }
           const compact_error = this.should_compact_on_error(error)
             ? error
             : last_observed_stream_error;
@@ -328,6 +352,7 @@ export class CoreEngineRunner {
         }
 
         context_error_compaction_retries = 0;
+        empty_stream_retry_count = 0;
         const last_step = executed_steps[executed_steps.length - 1];
         if (!last_step) break;
 
@@ -533,6 +558,25 @@ export class CoreEngineRunner {
   }
 }
 
+/** 等待下一次模型流重试，并在 Turn 停止时立即结束等待。 */
+async function wait_for_stream_retry(
+  delay_ms: number,
+  abort_signal: AbortSignal,
+): Promise<void> {
+  if (abort_signal.aborted) throw abort_signal.reason;
+  await new Promise<void>((resolve, reject) => {
+    const timer = setTimeout(() => {
+      abort_signal.removeEventListener("abort", on_abort);
+      resolve();
+    }, delay_ms);
+    const on_abort = (): void => {
+      clearTimeout(timer);
+      reject(abort_signal.reason);
+    };
+    abort_signal.addEventListener("abort", on_abort, { once: true });
+  });
+}
+
 /** 在工具执行前接入 Session canonical Interaction 生命周期。 */
 async function resolve_tool_approval(input: {
   call: ModelStepToolCall;

package/src/executor/model/ModelGenerate.ts

@@ -51,7 +51,9 @@ export async function generate_model(
       tools.set(event.content_id, { tool_call_id: event.tool_call_id, tool_name: event.tool_name });
     } else if (event.type === "tool_call_finish") {
       const tool = tools.get(event.content_id);
-      if (tool) tool_calls.push({ type: "tool_call", ...tool, input: event.input });
+      if (tool && !event.input_error) {
+        tool_calls.push({ type: "tool_call", ...tool, input: event.input });
+      }
     } else if (event.type === "model_usage") usage = event.usage;
     else if (event.type === "model_finish") finish_reason = event.finish_reason;
   }

package/src/executor/model/ModelStepRunner.ts

@@ -26,6 +26,7 @@ import type {
   SessionAssistantMessagePart,
   SessionAssistantToolPart,
 } from "@/types/session/SessionMessage.js";
+import { ModelStreamFailure } from "@/executor/model/ModelStreamFailure.js";
 
 /** 单个工具调用的执行事实。 */
 export interface ModelStepToolCall {
@@ -35,6 +36,8 @@ export interface ModelStepToolCall {
   tool_name: string;
   /** 已解析工具输入。 */
   input: ModelJsonValue;
+  /** 模型生成的工具输入无法解析时记录的错误。 */
+  input_error?: string;
 }
 
 /** 单个工具结果的执行事实。 */
@@ -162,7 +165,14 @@ class StepEventCollector {
 
   /** 消费单个标准模型事件。 */
   accept(event: ModelStreamEvent): void {
-    if (event.type === "model_error") throw new Error(event.error.message);
+    if (event.type === "model_error") {
+      throw new ModelStreamFailure(
+        event.error,
+        this.text.length > 0 ||
+          this.reasoning_by_id.size > 0 ||
+          this.tool_by_content_id.size > 0,
+      );
+    }
     if (event.type === "text_start") {
       this.text_by_id.set(event.content_id, "");
     } else if (event.type === "text_delta") {
@@ -213,6 +223,7 @@ class StepEventCollector {
       const tool = this.tool_by_content_id.get(event.content_id);
       if (tool) {
         tool.input = event.input;
+        if (event.input_error) tool.input_error = event.input_error;
         this.model_content.push({
           type: "tool_call",
           tool_call_id: tool.tool_call_id,
@@ -265,6 +276,14 @@ async function execute_tools(
 ): Promise<ModelStepToolResult[]> {
   const results: ModelStepToolResult[] = [];
   for (const call of calls) {
+    if (call.input_error) {
+      results.push({
+        ...call,
+        success: false,
+        output: { error: call.input_error },
+      });
+      continue;
+    }
     const tool = input.tools[call.tool_name];
     if (!tool || typeof tool.execute !== "function") {
       results.push({
@@ -292,7 +311,11 @@ async function execute_tools(
         abort_signal: input.abort_signal,
       };
       const output = await tool.execute(call.input, options);
-      results.push({ ...call, success: true, output });
+      results.push({
+        ...call,
+        success: !is_structured_tool_failure(output),
+        output,
+      });
     } catch (error) {
       results.push({
         ...call,
@@ -304,6 +327,12 @@ async function execute_tools(
   return results;
 }
 
+/** 识别 Tool 正常返回的结构化失败，避免把业务失败标记成执行成功。 */
+function is_structured_tool_failure(output: unknown): boolean {
+  if (!output || typeof output !== "object" || Array.isArray(output)) return false;
+  return (output as { success?: unknown }).success === false;
+}
+
 /** 把 System 快照转换成标准 ModelMessage。 */
 function convert_system_messages(messages: SessionSystemMessage[]): ModelMessage[] {
   return messages.map((message) => ({
@@ -373,9 +402,11 @@ function append_tool_results(
 
 /** 从结构化工具失败结果中提取可展示错误文本。 */
 function read_tool_error(value: unknown): string {
-  if (value && typeof value === "object" && "error" in value) {
-    const error = (value as { error?: unknown }).error;
-    if (typeof error === "string" && error.trim()) return error;
+  if (value && typeof value === "object") {
+    const result = value as { error?: unknown; message?: unknown; output?: unknown };
+    for (const candidate of [result.error, result.message, result.output]) {
+      if (typeof candidate === "string" && candidate.trim()) return candidate;
+    }
   }
   return "Tool execution failed";
 }

package/src/executor/model/ModelStreamFailure.ts

@@ -0,0 +1,44 @@
+/**
+ * 模型流失败对象。
+ *
+ * 该对象完整保留 Model Protocol 的错误分类，避免 Executor 只能依赖错误文本
+ * 判断是否可以重试。它只描述一次模型流失败，不负责决定恢复策略。
+ */
+
+import type { ModelError } from "@downcity/type";
+
+/** 一次具有稳定协议语义的模型流失败。 */
+export class ModelStreamFailure extends Error {
+  /** Downcity 稳定模型错误码。 */
+  readonly code: ModelError["code"];
+
+  /** 当前模型调用是否可以安全重试。 */
+  readonly retryable: boolean;
+
+  /** 失败前是否已经向用户发布正文或工具输入。 */
+  readonly has_partial_output: boolean;
+
+  /** Provider 返回的可观测请求标识。 */
+  readonly provider_request_id?: string;
+
+  constructor(error: ModelError, has_partial_output: boolean) {
+    super(error.message);
+    this.name = "ModelStreamFailure";
+    this.code = error.code;
+    this.retryable = error.retryable;
+    this.has_partial_output = has_partial_output;
+    if (error.provider_request_id) {
+      this.provider_request_id = error.provider_request_id;
+    }
+  }
+}
+
+/** 判断未知错误是否为可安全自动重试的无输出模型流失败。 */
+export function is_retryable_empty_model_stream_failure(
+  error: unknown,
+): error is ModelStreamFailure {
+  return error instanceof ModelStreamFailure &&
+    error.retryable &&
+    !error.has_partial_output &&
+    error.code !== "cancelled";
+}

package/src/group/GroupDispatchSession.ts

@@ -0,0 +1,175 @@
+/**
+ * GroupDispatchSession：单个 GroupSession 独享的持久化调度执行边界。
+ *
+ * 本对象统一拥有调度队列、当前模型取消信号和调度 Turn 状态。调度策略只负责决策，
+ * 不再自行拥有跨 GroupSession 的运行状态或停止语义。
+ */
+
+import { nanoid } from "nanoid";
+import type {
+  GroupDispatchSessionDataStore,
+  GroupDispatchSessionInput,
+  GroupDispatchSessionOptions,
+  GroupDispatchSessionResult,
+  GroupDispatchTurnRecord,
+} from "@/types/group/GroupDispatchSession.js";
+
+/** 主动停止 Dispatch Session 时使用的内部错误。 */
+export class GroupDispatchStoppedError extends Error {
+  constructor() {
+    super("Group dispatch stopped");
+    this.name = "GroupDispatchStoppedError";
+  }
+}
+
+/** GroupSession 私有的调度 Session。 */
+export class GroupDispatchSession {
+  private readonly dispatch_strategy: GroupDispatchSessionOptions["dispatch_strategy"];
+  private store?: GroupDispatchSessionDataStore;
+  private queue_tail: Promise<void> = Promise.resolve();
+  private active_abort_controller?: AbortController;
+  private stopping = false;
+  private disposed = false;
+
+  constructor(options: GroupDispatchSessionOptions) {
+    this.dispatch_strategy = options.dispatch_strategy;
+  }
+
+  /** 绑定持久化视图，并把进程中断留下的运行态明确收口为 stopped。 */
+  async initialize(store: GroupDispatchSessionDataStore): Promise<this> {
+    if (this.store && this.store !== store) {
+      throw new Error("GroupDispatchSession is already initialized with another Store");
+    }
+    if (this.store === store) return this;
+    this.store = store;
+    const interrupted_turns = (await store.list_turns()).filter((turn) => (
+      turn.status === "queued" || turn.status === "running"
+    ));
+    for (const turn of interrupted_turns) {
+      await store.append_turn({
+        ...turn,
+        status: "stopped",
+        error: "Group dispatch interrupted before recovery",
+        updated_at: Date.now(),
+      });
+    }
+    return this;
+  }
+
+  /** 按提交顺序执行一次调度，并在返回前持久化最终决定。 */
+  decide(input: GroupDispatchSessionInput): Promise<GroupDispatchSessionResult> {
+    this.assert_available();
+    const store = this.require_store();
+    const created_at = Date.now();
+    const queued_turn: GroupDispatchTurnRecord = {
+      dispatch_id: `group-dispatch-${nanoid(12)}`,
+      trigger: input.trigger,
+      message_id: input.message.id,
+      pending_message_ids: input.pending_messages.map((message) => message.id),
+      status: "queued",
+      created_at,
+      updated_at: created_at,
+    };
+    const persist_queued = store.append_turn(queued_turn);
+    const operation = this.queue_tail.then(async () => {
+      await persist_queued;
+      return await this.execute_turn(input, queued_turn);
+    });
+    this.queue_tail = operation.then(() => undefined, () => undefined);
+    return operation;
+  }
+
+  /** 中断当前模型调用，并让尚未开始的调度 Turn 按队列顺序收口。 */
+  async stop(): Promise<void> {
+    if (this.disposed || this.stopping) return;
+    this.stopping = true;
+    this.active_abort_controller?.abort(new GroupDispatchStoppedError());
+    await this.queue_tail;
+    this.active_abort_controller = undefined;
+    this.stopping = false;
+  }
+
+  /** 永久释放当前 Dispatch Session。 */
+  async dispose(): Promise<void> {
+    if (this.disposed) return;
+    await this.stop();
+    this.disposed = true;
+    this.store = undefined;
+  }
+
+  /** 执行队首调度 Turn，确保成功、失败和停止都形成持久化终态。 */
+  private async execute_turn(
+    input: GroupDispatchSessionInput,
+    queued_turn: GroupDispatchTurnRecord,
+  ): Promise<GroupDispatchSessionResult> {
+    const store = this.require_store();
+    if (this.stopping || this.disposed) {
+      await this.persist_terminal_turn(queued_turn, "stopped", "Group dispatch stopped");
+      throw new GroupDispatchStoppedError();
+    }
+    const abort_controller = new AbortController();
+    this.active_abort_controller = abort_controller;
+    await store.append_turn({
+      ...queued_turn,
+      status: "running",
+      updated_at: Date.now(),
+    });
+    try {
+      const decision = await this.dispatch_strategy.decide_dispatch({
+        ...input,
+        abort_signal: abort_controller.signal,
+      });
+      if (this.stopping || this.disposed || abort_controller.signal.aborted) {
+        throw new GroupDispatchStoppedError();
+      }
+      await store.append_turn({
+        ...queued_turn,
+        status: "completed",
+        decision,
+        updated_at: Date.now(),
+      });
+      return { dispatch_id: queued_turn.dispatch_id, decision };
+    } catch (error) {
+      if (
+        error instanceof GroupDispatchStoppedError ||
+        this.stopping ||
+        this.disposed ||
+        abort_controller.signal.aborted
+      ) {
+        await this.persist_terminal_turn(queued_turn, "stopped", "Group dispatch stopped");
+        throw new GroupDispatchStoppedError();
+      }
+      const detail = error instanceof Error ? error.message : String(error);
+      await this.persist_terminal_turn(queued_turn, "failed", detail);
+      throw error;
+    } finally {
+      if (this.active_abort_controller === abort_controller) {
+        this.active_abort_controller = undefined;
+      }
+    }
+  }
+
+  /** 提交没有 decision 的失败或停止终态。 */
+  private async persist_terminal_turn(
+    turn: GroupDispatchTurnRecord,
+    status: "failed" | "stopped",
+    error: string,
+  ): Promise<void> {
+    await this.require_store().append_turn({
+      ...turn,
+      status,
+      error,
+      updated_at: Date.now(),
+    });
+  }
+
+  private require_store(): GroupDispatchSessionDataStore {
+    if (!this.store) throw new Error("GroupDispatchSession is not initialized");
+    return this.store;
+  }
+
+  private assert_available(): void {
+    if (this.disposed) throw new Error("GroupDispatchSession is disposed");
+    if (this.stopping) throw new Error("GroupDispatchSession is stopping");
+  }
+}