@dudousxd/nestjs-agent 1.36.0 → 1.36.2

package/dist/{index-NF93YDF4.d.cts → index-CJdTomOT.d.cts}

@@ -1,8 +1,8 @@
 import { A2uiStreamOptions, a2uiThreadReplay } from '@dudousxd/nestjs-agent-core/a2ui';
-import { AgentAttachmentConfig, AttachmentStagingStore, AgentStore, Actor, ListActionProposals, ActionProposalView, ActionProposalMutationView, TextActionProposalVocabulary, AgentRunner, ModelCatalog, QuotaProvider, ActionApprovalMode, MessageAttachment, QuotaReport, ModelCatalogView, AgentHostContext, AttachmentRef, PageContext, ChatQueueState, HumanReply, ThreadSummary, ThreadDetail, UpdateThreadInput, MessageFeedbackValue, MessageFeedback, StagedAttachment, ActorResolver } from '@dudousxd/nestjs-agent-core';
+import { AgentAttachmentConfig, AttachmentStagingStore, AgentStore, Actor, ListActionProposals, ActionProposalView, ActionProposalMutationView, TextActionProposalVocabulary, AgentRunner, ModelCatalog, QuotaProvider, ActionApprovalMode, MessageAttachment, QuotaReport, ModelCatalogView, AgentHostContext, AttachmentRef, PageContext, ChatQueueState, SubscribeOptions, HumanReply, ThreadSummary, ThreadDetail, UpdateThreadInput, MessageFeedbackValue, MessageFeedback, StagedAttachment, ActorResolver } from '@dudousxd/nestjs-agent-core';
 import { Request, Response } from 'express';
 import { UiCapabilities } from '@dudousxd/nestjs-agent-core/genui';
-import { b as AgentModuleOptions, A as AgentDepsFactory, C as ChatQueueService, d as AgentProtocolAdapter } from './chat-queue.service-CF2fcJDx.cjs';
+import { b as AgentModuleOptions, A as AgentDepsFactory, C as ChatQueueService, d as AgentProtocolAdapter } from './chat-queue.service-fopUN313.cjs';
 
 /** Default per-file size cap (20 MiB). */
 declare const DEFAULT_MAX_ATTACHMENT_BYTES: number;
@@ -355,14 +355,14 @@ declare class AgentService {
      * {@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: string): AsyncIterable<Uint8Array>;
+    subscribe(runId: string, options?: SubscribeOptions): AsyncIterable<Uint8Array>;
     /**
      * {@link subscribe}, gated the way {@link cancel} is: only the actor whose thread is currently
      * streaming this run may read it. A run that has already finished is reported missing rather than
      * replayed — the runner clears the thread's active stream as the run ends, and that field is what
      * ownership is derived from.
      */
-    subscribeAs(actor: Actor, runId: string): Promise<AsyncIterable<Uint8Array>>;
+    subscribeAs(actor: Actor, runId: string, options?: SubscribeOptions): Promise<AsyncIterable<Uint8Array>>;
     /**
      * Approve a parked action call as `actor`. Who may is the call's recorded approver's business
      * (see {@link assertMayDecide}); `remember` approves later calls of the same tool in the same
@@ -460,6 +460,8 @@ declare class AgentService {
      * the full read.
      */
     private resolveAgentName;
+    /** Everything a send reads off `threadId`, in one read where the store allows it. */
+    private threadReads;
     private threadDefaultAgent;
     private toSummaryView;
     private toDetailView;

package/dist/{index-DpS9P7so.d.ts → index-D1xRrnCq.d.ts}

@@ -1,8 +1,8 @@
 import { A2uiStreamOptions, a2uiThreadReplay } from '@dudousxd/nestjs-agent-core/a2ui';
-import { AgentAttachmentConfig, AttachmentStagingStore, AgentStore, Actor, ListActionProposals, ActionProposalView, ActionProposalMutationView, TextActionProposalVocabulary, AgentRunner, ModelCatalog, QuotaProvider, ActionApprovalMode, MessageAttachment, QuotaReport, ModelCatalogView, AgentHostContext, AttachmentRef, PageContext, ChatQueueState, HumanReply, ThreadSummary, ThreadDetail, UpdateThreadInput, MessageFeedbackValue, MessageFeedback, StagedAttachment, ActorResolver } from '@dudousxd/nestjs-agent-core';
+import { AgentAttachmentConfig, AttachmentStagingStore, AgentStore, Actor, ListActionProposals, ActionProposalView, ActionProposalMutationView, TextActionProposalVocabulary, AgentRunner, ModelCatalog, QuotaProvider, ActionApprovalMode, MessageAttachment, QuotaReport, ModelCatalogView, AgentHostContext, AttachmentRef, PageContext, ChatQueueState, SubscribeOptions, HumanReply, ThreadSummary, ThreadDetail, UpdateThreadInput, MessageFeedbackValue, MessageFeedback, StagedAttachment, ActorResolver } from '@dudousxd/nestjs-agent-core';
 import { Request, Response } from 'express';
 import { UiCapabilities } from '@dudousxd/nestjs-agent-core/genui';
-import { b as AgentModuleOptions, A as AgentDepsFactory, C as ChatQueueService, d as AgentProtocolAdapter } from './chat-queue.service-CzXsKVb1.js';
+import { b as AgentModuleOptions, A as AgentDepsFactory, C as ChatQueueService, d as AgentProtocolAdapter } from './chat-queue.service-YjiKVTKE.js';
 
 /** Default per-file size cap (20 MiB). */
 declare const DEFAULT_MAX_ATTACHMENT_BYTES: number;
@@ -355,14 +355,14 @@ declare class AgentService {
      * {@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: string): AsyncIterable<Uint8Array>;
+    subscribe(runId: string, options?: SubscribeOptions): AsyncIterable<Uint8Array>;
     /**
      * {@link subscribe}, gated the way {@link cancel} is: only the actor whose thread is currently
      * streaming this run may read it. A run that has already finished is reported missing rather than
      * replayed — the runner clears the thread's active stream as the run ends, and that field is what
      * ownership is derived from.
      */
-    subscribeAs(actor: Actor, runId: string): Promise<AsyncIterable<Uint8Array>>;
+    subscribeAs(actor: Actor, runId: string, options?: SubscribeOptions): Promise<AsyncIterable<Uint8Array>>;
     /**
      * Approve a parked action call as `actor`. Who may is the call's recorded approver's business
      * (see {@link assertMayDecide}); `remember` approves later calls of the same tool in the same
@@ -460,6 +460,8 @@ declare class AgentService {
      * the full read.
      */
     private resolveAgentName;
+    /** Everything a send reads off `threadId`, in one read where the store allows it. */
+    private threadReads;
     private threadDefaultAgent;
     private toSummaryView;
     private toDetailView;

package/dist/index.cjs

@@ -1676,6 +1676,26 @@ var RunNotActiveException = class extends import_common5.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_decorate5(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -1939,7 +1959,7 @@ var AgentService2 = 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
@@ -1950,7 +1970,7 @@ var AgentService2 = 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;
     }
@@ -2010,10 +2030,11 @@ var AgentService2 = 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) {
@@ -2037,9 +2058,9 @@ var AgentService2 = 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 = {
@@ -2365,8 +2386,8 @@ var AgentService2 = 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
@@ -2374,9 +2395,9 @@ var AgentService2 = 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
@@ -2583,7 +2604,7 @@ var AgentService2 = 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,
@@ -2591,16 +2612,16 @@ var AgentService2 = 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
       });
@@ -2627,18 +2648,27 @@ var AgentService2 = 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") {
@@ -2808,8 +2838,8 @@ var AgentService2 = 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 import_common6.NotFoundException(`thread ${threadId} not found`);
     }
@@ -3249,6 +3279,18 @@ AttachmentsController = _ts_decorate8([
 var import_nestjs_agent_core12 = require("@dudousxd/nestjs-agent-core");
 var import_genui2 = require("@dudousxd/nestjs-agent-core/genui");
 var import_common10 = require("@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_decorate9(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") {
@@ -3382,7 +3424,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
@@ -3392,7 +3435,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);
@@ -3408,8 +3452,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");
@@ -3438,6 +3485,9 @@ data: ${line}
     }, "forward");
     try {
       for await (const chunk of events) {
+        if (gone?.aborted) {
+          return;
+        }
         buffer += decoder.decode(chunk, {
           stream: true
         });
@@ -3451,11 +3501,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 import_nestjs_agent_core12.AgentStreamError ? {
         code: error.code,
         message: error.message
@@ -5385,49 +5441,121 @@ SkillDiscoveryService = _ts_decorate22([
 
 // src/in-process-sink.ts
 var import_nestjs_agent_core27 = require("@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) {
@@ -5443,13 +5571,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/ledger-quota-provider.ts
 var import_nestjs_agent_core28 = require("@dudousxd/nestjs-agent-core");
@@ -5468,13 +5639,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 = (0, import_nestjs_agent_core28.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 = (0, import_nestjs_agent_core28.quotaPeriodRange)("day", now);
+    const month = (0, import_nestjs_agent_core28.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 = (0, import_nestjs_agent_core28.exhaustedWindow)(windows);
     const warning = (0, import_nestjs_agent_core28.quotaWarning)(windows);
@@ -5488,10 +5668,8 @@ var LedgerQuotaProvider = class {
       } : {}
     };
   }
-  async dayWindow(actorRef, now) {
-    const range = (0, import_nestjs_agent_core28.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) {
@@ -7336,7 +7514,7 @@ var AgUiRunHandler = class {
       seq: 0
     };
     try {
-      const frames = (0, import_ag_ui.agUiFramesFromNdjson)(this.agent.subscribe(runId));
+      const frames = (0, import_ag_ui.agUiFramesFromNdjson)(this.agent.subscribe(runId, readerGone(res)));
       for await (const event of (0, import_ag_ui.agUiEvents)(frames, {
         ...options,
         cursor
@@ -7667,7 +7845,7 @@ var A2uiRunHandler = class {
 `);
     }, "write");
     try {
-      const frames = (0, import_ag_ui2.agUiFramesFromNdjson)(this.agent.subscribe(runId));
+      const frames = (0, import_ag_ui2.agUiFramesFromNdjson)(this.agent.subscribe(runId, readerGone(res)));
       for await (const event of (0, import_ag_ui2.agUiEvents)(frames, {
         threadId: options.threadId ?? runId,
         runId,