@dudousxd/nestjs-agent 1.36.1 → 1.37.0

package/dist/durable/index.d.cts

@@ -1,25 +1,12 @@
 import { AgentStore, AgentRunInput, AgentLoopResult, LlmStepEnvelope, BufferedModelTurnResult, ToolStepEnvelope, AgentRunner, TokenStreamSink, AgentRunStartOptions, HumanReply } from '@dudousxd/nestjs-agent-core';
 import { WorkflowService } from '@dudousxd/nestjs-durable';
 import { RunGateway, WorkflowCtx } from '@dudousxd/nestjs-durable-core';
-import { A as AgentDepsFactory, C as ChatQueueService, a as AgentSurface, b as AgentModuleOptions } from '../chat-queue.service-CF2fcJDx.cjs';
+import { A as AgentDepsFactory, C as ChatQueueService, a as AgentSurface, b as AgentModuleOptions } from '../chat-queue.service-fopUN313.cjs';
 import { DynamicModule } from '@nestjs/common';
 import '@dudousxd/nestjs-agent-core/genui';
 import '@standard-schema/spec';
 import '../genui/index.cjs';
 
-/**
- * The agent turn AS a durable workflow. Persist/stream checkpoints are `ctx.localStep`s — the
- * in-process primitive, NOT the always-dispatched `ctx.step`: their names are dynamic checkpoint
- * identities (`persist:toolcall:<id>`), not routable worker groups, and their deps (store, sink)
- * live in THIS workflow worker's DI. The two LONG steps (model call, tool execution) are `ctx.step`s
- * routed to `AgentRunSteps`, so the run is never pinned to this pod while they execute — the same
- * thing `ctx.step` means anywhere in this ecosystem, and the reason a `@AiTool` handler must
- * establish whatever execution context it needs itself. HITL is `ctx.waitForSignal`, and sub-agent
- * delegation is `ctx.child(AgentRunWorkflow)` — a replay-safe, observable child run (it shows up as
- * a node in the durable dashboard). A child streams into its top-level ancestor's sink
- * (`sinkRunId`) so the human watching the parent sees it and can approve its action tools; the
- * approval routes to the child's own run via `runForToolCall`.
- */
 declare class AgentRunWorkflow {
     private readonly factory;
     private readonly store;
@@ -65,10 +52,11 @@ declare class AgentRunWorkflow {
      * `DurableAgentRunner.cancel` puts it — `cancelling` while a compensating cancel is in flight,
      * `cancelled` once it has settled.
      *
-     * Costs a run read at each of the loop's observation points (two per step). That is a row the
-     * control plane already has, against a turn that is otherwise making model calls, and it buys the
-     * property that matters: the answer comes from a place BOTH the canceller and every pod that might
-     * replay this run can see.
+     * Costs a run read at each of the loop's observation points (two per step): the run's own row
+     * where the gateway can read it alone, else its detail, which carries every checkpoint of the run.
+     * That row is one the control plane already has, against a turn that is otherwise making model
+     * calls, and it buys the property that matters: the answer comes from a place BOTH the canceller
+     * and every pod that might replay this run can see.
      *
      * Failing to ask is not a cancel. A tenant with no gateway wired, or an operator briefly
      * unreachable, answers "no" and the run carries on — the alternative is failing healthy runs

package/dist/durable/index.d.ts

@@ -1,25 +1,12 @@
 import { AgentStore, AgentRunInput, AgentLoopResult, LlmStepEnvelope, BufferedModelTurnResult, ToolStepEnvelope, AgentRunner, TokenStreamSink, AgentRunStartOptions, HumanReply } from '@dudousxd/nestjs-agent-core';
 import { WorkflowService } from '@dudousxd/nestjs-durable';
 import { RunGateway, WorkflowCtx } from '@dudousxd/nestjs-durable-core';
-import { A as AgentDepsFactory, C as ChatQueueService, a as AgentSurface, b as AgentModuleOptions } from '../chat-queue.service-CzXsKVb1.js';
+import { A as AgentDepsFactory, C as ChatQueueService, a as AgentSurface, b as AgentModuleOptions } from '../chat-queue.service-YjiKVTKE.js';
 import { DynamicModule } from '@nestjs/common';
 import '@dudousxd/nestjs-agent-core/genui';
 import '@standard-schema/spec';
 import '../genui/index.js';
 
-/**
- * The agent turn AS a durable workflow. Persist/stream checkpoints are `ctx.localStep`s — the
- * in-process primitive, NOT the always-dispatched `ctx.step`: their names are dynamic checkpoint
- * identities (`persist:toolcall:<id>`), not routable worker groups, and their deps (store, sink)
- * live in THIS workflow worker's DI. The two LONG steps (model call, tool execution) are `ctx.step`s
- * routed to `AgentRunSteps`, so the run is never pinned to this pod while they execute — the same
- * thing `ctx.step` means anywhere in this ecosystem, and the reason a `@AiTool` handler must
- * establish whatever execution context it needs itself. HITL is `ctx.waitForSignal`, and sub-agent
- * delegation is `ctx.child(AgentRunWorkflow)` — a replay-safe, observable child run (it shows up as
- * a node in the durable dashboard). A child streams into its top-level ancestor's sink
- * (`sinkRunId`) so the human watching the parent sees it and can approve its action tools; the
- * approval routes to the child's own run via `runForToolCall`.
- */
 declare class AgentRunWorkflow {
     private readonly factory;
     private readonly store;
@@ -65,10 +52,11 @@ declare class AgentRunWorkflow {
      * `DurableAgentRunner.cancel` puts it — `cancelling` while a compensating cancel is in flight,
      * `cancelled` once it has settled.
      *
-     * Costs a run read at each of the loop's observation points (two per step). That is a row the
-     * control plane already has, against a turn that is otherwise making model calls, and it buys the
-     * property that matters: the answer comes from a place BOTH the canceller and every pod that might
-     * replay this run can see.
+     * Costs a run read at each of the loop's observation points (two per step): the run's own row
+     * where the gateway can read it alone, else its detail, which carries every checkpoint of the run.
+     * That row is one the control plane already has, against a turn that is otherwise making model
+     * calls, and it buys the property that matters: the answer comes from a place BOTH the canceller
+     * and every pod that might replay this run can see.
      *
      * Failing to ask is not a cancel. A tenant with no gateway wired, or an operator briefly
      * unreachable, answers "no" and the run carries on — the alternative is failing healthy runs

package/dist/durable/index.js

@@ -552,10 +552,11 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
   * `DurableAgentRunner.cancel` puts it — `cancelling` while a compensating cancel is in flight,
   * `cancelled` once it has settled.
   *
-  * Costs a run read at each of the loop's observation points (two per step). That is a row the
-  * control plane already has, against a turn that is otherwise making model calls, and it buys the
-  * property that matters: the answer comes from a place BOTH the canceller and every pod that might
-  * replay this run can see.
+  * Costs a run read at each of the loop's observation points (two per step): the run's own row
+  * where the gateway can read it alone, else its detail, which carries every checkpoint of the run.
+  * That row is one the control plane already has, against a turn that is otherwise making model
+  * calls, and it buys the property that matters: the answer comes from a place BOTH the canceller
+  * and every pod that might replay this run can see.
   *
   * Failing to ask is not a cancel. A tenant with no gateway wired, or an operator briefly
   * unreachable, answers "no" and the run carries on — the alternative is failing healthy runs
@@ -563,8 +564,10 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
   * can never disagree about what was seen here.
   */
   async isCancelled(runId) {
+    const runs = this.runs;
     try {
-      const status = (await this.runs?.getRunDetail(runId))?.run.status;
+      const run = typeof runs?.getRun === "function" ? await runs.getRun(runId) : (await runs?.getRunDetail(runId))?.run;
+      const status = run?.status;
       return status === "cancelled" || status === "cancelling";
     } catch {
       return false;
@@ -876,49 +879,121 @@ import { Inject as Inject3, Injectable as Injectable3, Logger as Logger2, Option
 
 // src/in-process-sink.ts
 import { AgentStreamError } from "@dudousxd/nestjs-agent-core";
+var LIVE_TTL_MS = 36e5;
+var ENDED_GRACE_MS = 6e4;
 var InProcessTokenStreamSink = class {
   static {
     __name(this, "InProcessTokenStreamSink");
   }
   runs = /* @__PURE__ */ new Map();
+  /** Subscribers of a run nothing has opened yet, woken by its `open()`. */
+  waiting = /* @__PURE__ */ new Map();
   buffer(runId) {
     let buf = this.runs.get(runId);
     if (buf === void 0) {
       buf = {
         chunks: [],
         ended: false,
-        notify: /* @__PURE__ */ new Set()
+        notify: /* @__PURE__ */ new Set(),
+        lastWriteAt: Date.now(),
+        expiry: void 0
       };
       this.runs.set(runId, buf);
+      this.expireAfter(runId, buf, LIVE_TTL_MS);
+      const waiters = this.waiting.get(runId);
+      this.waiting.delete(runId);
+      for (const resolve2 of waiters ?? []) {
+        resolve2();
+      }
     }
     return buf;
   }
+  expireAfter(runId, buf, ms) {
+    if (buf.expiry !== void 0) {
+      clearTimeout(buf.expiry);
+    }
+    buf.expiry = setTimeout(() => {
+      buf.expiry = void 0;
+      const idle = Date.now() - buf.lastWriteAt;
+      if (!buf.ended && idle < LIVE_TTL_MS) {
+        this.expireAfter(runId, buf, LIVE_TTL_MS - idle);
+        return;
+      }
+      this.drop(runId, buf);
+    }, ms);
+    buf.expiry.unref?.();
+  }
+  /** Forget the run, and let anyone still following it finish as if it had ended. */
+  drop(runId, buf) {
+    if (buf.expiry !== void 0) {
+      clearTimeout(buf.expiry);
+      buf.expiry = void 0;
+    }
+    if (this.runs.get(runId) === buf) {
+      this.runs.delete(runId);
+    }
+    buf.ended = true;
+    this.wake(buf);
+  }
   wake(buf) {
     for (const resolve2 of buf.notify) {
       resolve2();
     }
     buf.notify.clear();
   }
+  finish(runId, buf) {
+    buf.ended = true;
+    this.wake(buf);
+    this.expireAfter(runId, buf, ENDED_GRACE_MS);
+  }
+  /**
+  * The run's writer. Each call finds the run's buffer afresh, so a run that went quiet past the
+  * live TTL (parked on a person) and then writes again starts a new buffer its next subscriber
+  * follows, rather than writing into one nothing reads.
+  */
   open(runId) {
-    const buf = this.buffer(runId);
+    this.buffer(runId);
     return {
       write: /* @__PURE__ */ __name((chunk) => {
+        const buf = this.buffer(runId);
         buf.chunks.push(chunk);
+        buf.lastWriteAt = Date.now();
         this.wake(buf);
       }, "write"),
       end: /* @__PURE__ */ __name(() => {
-        buf.ended = true;
-        this.wake(buf);
+        this.finish(runId, this.buffer(runId));
       }, "end"),
       fail: /* @__PURE__ */ __name((error) => {
+        const buf = this.buffer(runId);
         buf.failure = error;
-        buf.ended = true;
-        this.wake(buf);
+        this.finish(runId, buf);
       }, "fail")
     };
   }
-  async *subscribe(runId) {
-    const buf = this.buffer(runId);
+  async *subscribe(runId, options = {}) {
+    const { signal } = options;
+    let buf = this.runs.get(runId);
+    while (buf === void 0) {
+      const waiters = this.waiting.get(runId) ?? /* @__PURE__ */ new Set();
+      this.waiting.set(runId, waiters);
+      let resolve2 = /* @__PURE__ */ __name(() => {
+      }, "resolve");
+      const opened = new Promise((r) => {
+        resolve2 = r;
+      });
+      waiters.add(resolve2);
+      try {
+        if (!await untilAborted(opened, signal)) {
+          return;
+        }
+      } finally {
+        waiters.delete(resolve2);
+        if (waiters.size === 0 && this.waiting.get(runId) === waiters) {
+          this.waiting.delete(runId);
+        }
+      }
+      buf = this.runs.get(runId);
+    }
     let index = 0;
     while (true) {
       while (index < buf.chunks.length) {
@@ -934,13 +1009,56 @@ var InProcessTokenStreamSink = class {
         }
         return;
       }
-      await new Promise((resolve2) => buf.notify.add(resolve2));
+      const current = buf;
+      let resolve2 = /* @__PURE__ */ __name(() => {
+      }, "resolve");
+      const woken = new Promise((r) => {
+        resolve2 = r;
+      });
+      current.notify.add(resolve2);
+      try {
+        if (!await untilAborted(woken, signal)) {
+          return;
+        }
+      } finally {
+        current.notify.delete(resolve2);
+      }
     }
   }
   close(runId) {
+    const buf = this.runs.get(runId);
+    if (buf?.expiry !== void 0) {
+      clearTimeout(buf.expiry);
+    }
     this.runs.delete(runId);
   }
 };
+async function untilAborted(promise, signal) {
+  if (signal === void 0) {
+    await promise;
+    return true;
+  }
+  if (signal.aborted) {
+    return false;
+  }
+  let onAbort = /* @__PURE__ */ __name(() => {
+  }, "onAbort");
+  const aborted = new Promise((resolve2) => {
+    onAbort = /* @__PURE__ */ __name(() => resolve2(false), "onAbort");
+    signal.addEventListener("abort", onAbort, {
+      once: true
+    });
+  });
+  try {
+    return await Promise.race([
+      promise.then(() => true),
+      aborted
+    ]);
+  } finally {
+    signal.removeEventListener("abort", onAbort);
+  }
+}
+__name(untilAborted, "untilAborted");
 
 // src/durable/durable-agent-runner.ts
 function _ts_decorate3(decorators, target, key, desc) {
@@ -2816,6 +2934,26 @@ var RunNotActiveException = class extends ConflictException {
   }
 };
 
+// src/thread-reads.ts
+function threadReads(store, threadId, separately) {
+  const projecting = store;
+  if (typeof projecting.threadSettings !== "function") {
+    return separately;
+  }
+  let settings;
+  const read = /* @__PURE__ */ __name(() => {
+    settings ??= projecting.threadSettings?.(threadId) ?? Promise.resolve(null);
+    return settings;
+  }, "read");
+  return {
+    owner: /* @__PURE__ */ __name(async () => (await read())?.actorRef ?? null, "owner"),
+    defaultAgent: /* @__PURE__ */ __name(async () => (await read())?.defaultAgent ?? null, "defaultAgent"),
+    persona: /* @__PURE__ */ __name(async () => (await read())?.persona ?? null, "persona"),
+    model: /* @__PURE__ */ __name(async () => (await read())?.model ?? null, "model")
+  };
+}
+__name(threadReads, "threadReads");
+
 // src/agent.service.ts
 function _ts_decorate9(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -3079,7 +3217,7 @@ var AgentService = class {
   * else the thread's pinned one, else none. An agent the catalog locks to one model runs on it
   * whatever was sent or pinned, and a send naming another model is refused.
   */
-  async resolveModel(actor, agent, requested, threadId) {
+  async resolveModel(actor, agent, requested, threadId, reads) {
     const locked = this.models !== void 0 ? (await this.models.list({
       actor,
       agent
@@ -3090,7 +3228,7 @@ var AgentService = class {
       }
       return locked.model;
     }
-    const model = requested ?? (threadId !== void 0 ? await this.threadModel(threadId) : null);
+    const model = requested ?? (threadId !== void 0 ? await (reads?.model() ?? this.threadModel(threadId)) : null);
     if (model === null || model === void 0) {
       return void 0;
     }
@@ -3150,10 +3288,11 @@ var AgentService = class {
       if ("proposalDecision" in decision) return decision;
     }
     await this.assertWithinQuota(params.actor);
-    const target = this.deps.resolveAgent(await this.resolveAgentName(params.agentName, params.threadId));
+    const reads = params.threadId !== void 0 ? this.threadReads(params.threadId) : void 0;
+    const target = this.deps.resolveAgent(await this.resolveAgentName(params.agentName, params.threadId, reads));
     const agentName = target.agentName;
-    const persona = await this.resolvePersona(agentName, params.personaId ?? target.persona, params.threadId);
-    const model = await this.resolveModel(params.actor, agentName, params.model, params.threadId);
+    const persona = await this.resolvePersona(agentName, params.personaId ?? target.persona, params.threadId, reads);
+    const model = await this.resolveModel(params.actor, agentName, params.model, params.threadId, reads);
     const attachments = await this.resolveAttachments(params.actor, params.attachments ?? []);
     let threadId = params.threadId;
     if (threadId === void 0) {
@@ -3177,9 +3316,9 @@ var AgentService = class {
       });
       threadId = created.id;
     } else {
-      if (params.authorized !== true) await this.assertOwnsThread(params.actor, threadId);
+      if (params.authorized !== true) await this.assertOwnsThread(params.actor, threadId, reads);
       if (params.personaId !== void 0) {
-        await this.pinThreadPersona(threadId, params.personaId);
+        await this.pinThreadPersona(threadId, params.personaId, reads);
       }
     }
     const input = {
@@ -3505,8 +3644,8 @@ var AgentService = class {
   * {@link subscribeAs} instead: a runId is the only thing standing between a caller and another
   * actor's answer, tool arguments and tool results.
   */
-  subscribe(runId) {
-    return this.deps.forAgent().sink.subscribe(runId);
+  subscribe(runId, options) {
+    return this.deps.forAgent().sink.subscribe(runId, options);
   }
   /**
   * {@link subscribe}, gated the way {@link cancel} is: only the actor whose thread is currently
@@ -3514,9 +3653,9 @@ var AgentService = class {
   * replayed — the runner clears the thread's active stream as the run ends, and that field is what
   * ownership is derived from.
   */
-  async subscribeAs(actor, runId) {
+  async subscribeAs(actor, runId, options) {
     await this.assertOwnsActiveStream(actor, runId);
-    return this.subscribe(runId);
+    return this.subscribe(runId, options);
   }
   /**
   * Approve a parked action call as `actor`. Who may is the call's recorded approver's business
@@ -3669,9 +3808,28 @@ var AgentService = class {
     await this.assertOwnsThread(actor, threadId);
     return this.store.softDeleteThread(threadId);
   }
-  async forkThread(actor, threadId, fromMessageId) {
-    await this.assertOwnsThread(actor, threadId);
-    return this.store.forkThread(threadId, fromMessageId);
+  /**
+  * Copy a thread up to `fromMessageId` (inclusive) into a new one. By default only the thread's
+  * owner may, and the copy is theirs. With `params.authorized`, the host has vouched for `actor`
+  * (a share link it checked) and the copy is `actor`'s — see {@link ForkThreadParams}.
+  */
+  async forkThread(actor, threadId, fromMessageId, params = {}) {
+    if (params.authorized === true) {
+      if (await this.store.ownerOfThread(threadId) === null) {
+        throw new NotFoundException2(`thread ${threadId} not found`);
+      }
+    } else {
+      await this.assertOwnsThread(actor, threadId);
+    }
+    const options = {
+      ...params.authorized === true ? {
+        actorRef: actor.id
+      } : {},
+      ...params.tenantRef !== void 0 ? {
+        tenantRef: params.tenantRef
+      } : {}
+    };
+    return this.store.forkThread(threadId, fromMessageId, options);
   }
   /** Kept for source compatibility — a thin wrapper over the more general `updateThread`. */
   async renameThread(actor, threadId, title) {
@@ -3723,7 +3881,7 @@ var AgentService = class {
   * The persona this send runs under — see {@link AgentDepsFactory.resolvePersona}. The thread's
   * pinned persona is read only when the send names none AND the agent has personas to pick from.
   */
-  async resolvePersona(agentName, requested, threadId) {
+  async resolvePersona(agentName, requested, threadId, reads) {
     const needsThread = requested === void 0 && threadId !== void 0 && this.deps.personaCatalog(agentName).length > 0;
     return this.deps.resolvePersona({
       agentName,
@@ -3731,16 +3889,16 @@ var AgentService = class {
         requested
       } : {},
       ...needsThread ? {
-        threadPersona: await threadPersona(this.store, threadId)
+        threadPersona: await (reads?.persona() ?? threadPersona(this.store, threadId))
       } : {}
     });
   }
   /** Pin `persona` on the thread when it is not already — a no-op on a store that cannot. */
-  async pinThreadPersona(threadId, persona) {
+  async pinThreadPersona(threadId, persona, reads) {
     if (this.store.updateThread === void 0) {
       return;
     }
-    if (await threadPersona(this.store, threadId) !== persona) {
+    if (await (reads?.persona() ?? threadPersona(this.store, threadId)) !== persona) {
       await this.store.updateThread(threadId, {
         persona
       });
@@ -3767,18 +3925,27 @@ var AgentService = class {
   * workflow, for a string. A store predating {@link ThreadDefaultAgentReader} still answers, via
   * the full read.
   */
-  async resolveAgentName(agentName, threadId) {
+  async resolveAgentName(agentName, threadId, reads) {
     if (agentName !== void 0) {
       return agentName;
     }
     if (threadId !== void 0) {
-      const threadDefault = await this.threadDefaultAgent(threadId);
+      const threadDefault = await (reads?.defaultAgent() ?? this.threadDefaultAgent(threadId));
       if (threadDefault !== null) {
         return threadDefault;
       }
     }
     return this.deps.defaultAgentName();
   }
+  /** Everything a send reads off `threadId`, in one read where the store allows it. */
+  threadReads(threadId) {
+    return threadReads(this.store, threadId, {
+      owner: /* @__PURE__ */ __name(() => this.store.ownerOfThread(threadId), "owner"),
+      defaultAgent: /* @__PURE__ */ __name(() => this.threadDefaultAgent(threadId), "defaultAgent"),
+      persona: /* @__PURE__ */ __name(() => threadPersona(this.store, threadId), "persona"),
+      model: /* @__PURE__ */ __name(() => this.threadModel(threadId), "model")
+    });
+  }
   async threadDefaultAgent(threadId) {
     const projecting = this.store;
     if (typeof projecting.defaultAgentForThread === "function") {
@@ -3948,8 +4115,8 @@ var AgentService = class {
   * Authorization seam for thread-scoped endpoints: the caller must own the thread. A missing
   * thread is a 404; someone else's thread is a 403 — one actor never touches another's thread.
   */
-  async assertOwnsThread(actor, threadId) {
-    const owner = await this.store.ownerOfThread(threadId);
+  async assertOwnsThread(actor, threadId, reads) {
+    const owner = await (reads?.owner() ?? this.store.ownerOfThread(threadId));
     if (owner === null) {
       throw new NotFoundException2(`thread ${threadId} not found`);
     }
@@ -4389,6 +4556,18 @@ AttachmentsController = _ts_decorate12([
 import { AGENT_ACTOR_RESOLVER as AGENT_ACTOR_RESOLVER2, AgentStreamError as AgentStreamError2, streamFailure as streamFailure2 } from "@dudousxd/nestjs-agent-core";
 import { validateUiCapabilities } from "@dudousxd/nestjs-agent-core/genui";
 import { BadRequestException as BadRequestException4, Body, Controller as Controller3, Get as Get3, Inject as Inject11, Param, Post as Post2, Query, Req as Req2, Res } from "@nestjs/common";
+
+// src/controller/reader-gone.ts
+function readerGone(res) {
+  const controller = new AbortController();
+  res.once("close", () => controller.abort());
+  return {
+    signal: controller.signal
+  };
+}
+__name(readerGone, "readerGone");
+
+// src/controller/chat.controller.ts
 function _ts_decorate13(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
@@ -4522,7 +4701,8 @@ var ChatController = class {
       return;
     }
     const { runId, threadId } = result;
-    await this.pipe(res, runId, this.agent.subscribe(runId), threadId);
+    const gone = readerGone(res);
+    await this.pipe(res, runId, this.agent.subscribe(runId, gone), threadId, 0, gone.signal);
   }
   /**
   * Attach to a run's stream: every buffered frame, then live ones. `?after=<seq>` (or the SSE
@@ -4532,7 +4712,8 @@ var ChatController = class {
   async stream(req, runId, res, after) {
     const actor = await this.actorResolver.resolve(req);
     const cursor = parseCursor(after) ?? parseCursor(req.headers["last-event-id"]) ?? 0;
-    await this.pipe(res, runId, await this.agent.subscribeAs(actor, runId), void 0, cursor);
+    const gone = readerGone(res);
+    await this.pipe(res, runId, await this.agent.subscribeAs(actor, runId, gone), void 0, cursor, gone.signal);
   }
   async cancel(req, runId) {
     const actor = await this.actorResolver.resolve(req);
@@ -4548,8 +4729,11 @@ var ChatController = class {
   * and on any later `GET …/stream`, whichever replica serves it. A reconnecting client passes the
   * last one it saw as `?after=`; frames at or below it are read off the sink but not re-sent.
   * `meta`, `done` and `error` carry no id: `meta` is re-sent on every attach, the terminals once.
+  *
+  * A reader that disconnects aborts `gone`, which the sink honours by ending the subscription even
+  * while the run is silent (parked on a person, or never writing again).
   */
-  async pipe(res, runId, events, threadId, after = 0) {
+  async pipe(res, runId, events, threadId, after = 0, gone) {
     res.setHeader("Content-Type", "text/event-stream");
     res.setHeader("Cache-Control", "no-cache");
     res.setHeader("Connection", "keep-alive");
@@ -4578,6 +4762,9 @@ data: ${line}
     }, "forward");
     try {
       for await (const chunk of events) {
+        if (gone?.aborted) {
+          return;
+        }
         buffer += decoder.decode(chunk, {
           stream: true
         });
@@ -4591,11 +4778,17 @@ data: ${line}
           newline = buffer.indexOf("\n");
         }
       }
+      if (gone?.aborted) {
+        return;
+      }
       if (buffer.length > 0) {
         forward(buffer);
       }
       res.write("event: done\ndata: {}\n\n");
     } catch (error) {
+      if (gone?.aborted) {
+        return;
+      }
       const payload = error instanceof AgentStreamError2 ? {
         code: error.code,
         message: error.message
@@ -6496,13 +6689,22 @@ var LedgerQuotaProvider = class {
   async report(query) {
     const now = query.now ?? /* @__PURE__ */ new Date();
     const actorRef = query.actor.id;
-    const windows = [
-      await this.dayWindow(actorRef, now)
-    ];
-    if (this.store.usageBetween !== void 0) {
-      const range = quotaPeriodRange("month", now);
-      const used = await this.store.usageBetween(actorRef, range.fromDay, range.toDay);
-      windows.push(this.window("month", used.usedTokens, this.usd(used), range.resetsAt));
+    const day = quotaPeriodRange("day", now);
+    const month = quotaPeriodRange("month", now);
+    const windows = [];
+    if (this.store.usageWindows !== void 0) {
+      const [dayUsed, monthUsed] = await this.store.usageWindows(actorRef, [
+        day,
+        month
+      ]);
+      windows.push(this.usedWindow("day", dayUsed, day.resetsAt));
+      windows.push(this.usedWindow("month", monthUsed, month.resetsAt));
+    } else {
+      windows.push(this.usedWindow("day", await this.store.quotaToday(actorRef, day.fromDay), day.resetsAt));
+      if (this.store.usageBetween !== void 0) {
+        const used = await this.store.usageBetween(actorRef, month.fromDay, month.toDay);
+        windows.push(this.usedWindow("month", used, month.resetsAt));
+      }
     }
     const blocked = exhaustedWindow(windows);
     const warning = quotaWarning(windows);
@@ -6516,10 +6718,8 @@ var LedgerQuotaProvider = class {
       } : {}
     };
   }
-  async dayWindow(actorRef, now) {
-    const range = quotaPeriodRange("day", now);
-    const used = await this.store.quotaToday(actorRef, range.fromDay);
-    return this.window("day", used.usedTokens, this.usd(used), range.resetsAt);
+  usedWindow(period, used, resetsAt) {
+    return this.window(period, used?.usedTokens ?? 0, used === void 0 ? 0 : this.usd(used), resetsAt);
   }
   /** The window's USD: every priced row, or (with `countEstimatedCost: false`) reported cost only. */
   usd(used) {