@dudousxd/nestjs-agent 1.36.1 → 1.37.0

package/dist/index.d.cts

@@ -1,14 +1,14 @@
 import { DynamicModule, Type, OnApplicationBootstrap, OnModuleInit, ConflictException, OnModuleDestroy } from '@nestjs/common';
-import { b as AgentModuleOptions, c as AgentModuleAsyncOptions, d as AgentProtocolAdapter, A as AgentDepsFactory, e as AgentSkillsOptions, C as ChatQueueService } from './chat-queue.service-CF2fcJDx.cjs';
-export { f as AGENT_TOOL_BRAND, g as AgentAttachmentsOptions, h as AgentDeps, i as AgentEngine, j as AgentMemoryOptions, a as AgentSurface, F as FunctionalTool, L as LedgerQuotaProvider, Q as QueuePlan, k as QueueSettleOutcome, l as QueuedTurn, m as QueuedTurnStarter, n as QuotaLimits, o as QuotaWindowLimits, p as defineTool, q as delegateToolName, r as provideAgentTool, s as provideAgentTools, u as utcDay } from './chat-queue.service-CF2fcJDx.cjs';
+import { b as AgentModuleOptions, c as AgentModuleAsyncOptions, d as AgentProtocolAdapter, A as AgentDepsFactory, e as AgentSkillsOptions, C as ChatQueueService } from './chat-queue.service-fopUN313.cjs';
+export { f as AGENT_TOOL_BRAND, g as AgentAttachmentsOptions, h as AgentDeps, i as AgentEngine, j as AgentMemoryOptions, a as AgentSurface, F as FunctionalTool, L as LedgerQuotaProvider, Q as QueuePlan, k as QueueSettleOutcome, l as QueuedTurn, m as QueuedTurnStarter, n as QuotaLimits, o as QuotaWindowLimits, p as defineTool, q as delegateToolName, r as provideAgentTool, s as provideAgentTools, u as utcDay } from './chat-queue.service-fopUN313.cjs';
 import * as _dudousxd_nestjs_agent_core from '@dudousxd/nestjs-agent-core';
-import { ActorResolver, AttachmentStagingStore, AgentApprovalPort, Actor, AgentStore, StagedAttachment, MessageAttachment, ModelCatalog, AgentClientConfig, ToolSpec, ToolPresentation, AgentHistoryWindow, AgentIntake, Persona, SkillContext, ToolRegistry, AgentRegistry, PromptContributor, SkillsConfig, SkillCatalogEntry, MessageFeedbackValue, MessageFeedback, ModelCatalogView, ToolCatalogEntry, MemoryConfig, MemoryDigestEntry, SkillProvider, AgentRunner, AgentRunInput, AgentRunStartOptions, HumanReply, ChatQueueState, TokenStreamSink, SinkWriter, ActionProposalOutcome, ActionProposal } from '@dudousxd/nestjs-agent-core';
+import { ActorResolver, AttachmentStagingStore, AgentApprovalPort, Actor, AgentStore, StagedAttachment, MessageAttachment, ModelCatalog, AgentClientConfig, ToolSpec, ToolPresentation, AgentHistoryWindow, AgentIntake, Persona, SkillContext, ToolRegistry, AgentRegistry, PromptContributor, SkillsConfig, SkillCatalogEntry, MessageFeedbackValue, MessageFeedback, ModelCatalogView, ToolCatalogEntry, MemoryConfig, MemoryDigestEntry, SkillProvider, AgentRunner, AgentRunInput, AgentRunStartOptions, HumanReply, ChatQueueState, TokenStreamSink, SinkWriter, SubscribeOptions, ActionProposalOutcome, ActionProposal } from '@dudousxd/nestjs-agent-core';
 export * from '@dudousxd/nestjs-agent-core';
 export { FunctionalToolDefinition } from '@dudousxd/nestjs-agent-core';
 import { A2uiOptions } from '@dudousxd/nestjs-agent-core/a2ui';
 import { Request, Response } from 'express';
-import { A as AgentService, a as ActionProposalService } from './index-NF93YDF4.cjs';
-export { b as A2uiAdapterOptions, c as A2uiRunHandler, d as AttachmentLimits, C as ChatParams, e as ChatSendMode, f as ChatSendResult, D as DEFAULT_ALLOWED_ATTACHMENT_CONTENT_TYPES, g as DEFAULT_MAX_ATTACHMENT_BYTES, M as MAX_ATTACHMENTS_PER_MESSAGE, N as NO_USER_MESSAGE_CODE, Q as QueuedSend, T as ThreadDefaultAgentReader, h as ThreadModelReader, i as a2uiAdapter, j as attachmentLimits } from './index-NF93YDF4.cjs';
+import { A as AgentService, a as ActionProposalService } from './index-4caNqEQ-.cjs';
+export { b as A2uiAdapterOptions, c as A2uiRunHandler, d as AttachmentLimits, C as ChatParams, e as ChatSendMode, f as ChatSendResult, D as DEFAULT_ALLOWED_ATTACHMENT_CONTENT_TYPES, g as DEFAULT_MAX_ATTACHMENT_BYTES, F as ForkThreadParams, M as MAX_ATTACHMENTS_PER_MESSAGE, N as NO_USER_MESSAGE_CODE, Q as QueuedSend, T as ThreadDefaultAgentReader, h as ThreadModelReader, i as a2uiAdapter, j as attachmentLimits } from './index-4caNqEQ-.cjs';
 import { AgentGenui } from './genui/index.cjs';
 import { StandardSchemaV1 } from '@standard-schema/spec';
 import { DiscoveryService, MetadataScanner } from '@nestjs/core';
@@ -870,7 +870,8 @@ declare const AGENT_SERVICE: unique symbol;
 
 /**
  * The default `TokenStreamSink`: buffers chunks per run in-process so a reconnecting subscriber
- * replays everything so far, then follows live.
+ * replays everything so far, then follows live. A run's buffer is dropped {@link ENDED_GRACE_MS}
+ * after it ends, or {@link LIVE_TTL_MS} after its last write if it never does.
  *
  * Single-replica only. Because the buffer lives in one process's memory, a resume/reconnect that
  * lands on a different replica than the one running the turn finds an empty buffer — the stream
@@ -879,10 +880,21 @@ declare const AGENT_SERVICE: unique symbol;
  */
 declare class InProcessTokenStreamSink implements TokenStreamSink {
     private readonly runs;
+    /** Subscribers of a run nothing has opened yet, woken by its `open()`. */
+    private readonly waiting;
     private buffer;
+    private expireAfter;
+    /** Forget the run, and let anyone still following it finish as if it had ended. */
+    private drop;
     private wake;
+    private finish;
+    /**
+     * 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: string): SinkWriter;
-    subscribe(runId: string): AsyncIterable<Uint8Array>;
+    subscribe(runId: string, options?: SubscribeOptions): AsyncIterable<Uint8Array>;
     close(runId: string): void;
 }
 

package/dist/index.d.ts

@@ -1,14 +1,14 @@
 import { DynamicModule, Type, OnApplicationBootstrap, OnModuleInit, ConflictException, OnModuleDestroy } from '@nestjs/common';
-import { b as AgentModuleOptions, c as AgentModuleAsyncOptions, d as AgentProtocolAdapter, A as AgentDepsFactory, e as AgentSkillsOptions, C as ChatQueueService } from './chat-queue.service-CzXsKVb1.js';
-export { f as AGENT_TOOL_BRAND, g as AgentAttachmentsOptions, h as AgentDeps, i as AgentEngine, j as AgentMemoryOptions, a as AgentSurface, F as FunctionalTool, L as LedgerQuotaProvider, Q as QueuePlan, k as QueueSettleOutcome, l as QueuedTurn, m as QueuedTurnStarter, n as QuotaLimits, o as QuotaWindowLimits, p as defineTool, q as delegateToolName, r as provideAgentTool, s as provideAgentTools, u as utcDay } from './chat-queue.service-CzXsKVb1.js';
+import { b as AgentModuleOptions, c as AgentModuleAsyncOptions, d as AgentProtocolAdapter, A as AgentDepsFactory, e as AgentSkillsOptions, C as ChatQueueService } from './chat-queue.service-YjiKVTKE.js';
+export { f as AGENT_TOOL_BRAND, g as AgentAttachmentsOptions, h as AgentDeps, i as AgentEngine, j as AgentMemoryOptions, a as AgentSurface, F as FunctionalTool, L as LedgerQuotaProvider, Q as QueuePlan, k as QueueSettleOutcome, l as QueuedTurn, m as QueuedTurnStarter, n as QuotaLimits, o as QuotaWindowLimits, p as defineTool, q as delegateToolName, r as provideAgentTool, s as provideAgentTools, u as utcDay } from './chat-queue.service-YjiKVTKE.js';
 import * as _dudousxd_nestjs_agent_core from '@dudousxd/nestjs-agent-core';
-import { ActorResolver, AttachmentStagingStore, AgentApprovalPort, Actor, AgentStore, StagedAttachment, MessageAttachment, ModelCatalog, AgentClientConfig, ToolSpec, ToolPresentation, AgentHistoryWindow, AgentIntake, Persona, SkillContext, ToolRegistry, AgentRegistry, PromptContributor, SkillsConfig, SkillCatalogEntry, MessageFeedbackValue, MessageFeedback, ModelCatalogView, ToolCatalogEntry, MemoryConfig, MemoryDigestEntry, SkillProvider, AgentRunner, AgentRunInput, AgentRunStartOptions, HumanReply, ChatQueueState, TokenStreamSink, SinkWriter, ActionProposalOutcome, ActionProposal } from '@dudousxd/nestjs-agent-core';
+import { ActorResolver, AttachmentStagingStore, AgentApprovalPort, Actor, AgentStore, StagedAttachment, MessageAttachment, ModelCatalog, AgentClientConfig, ToolSpec, ToolPresentation, AgentHistoryWindow, AgentIntake, Persona, SkillContext, ToolRegistry, AgentRegistry, PromptContributor, SkillsConfig, SkillCatalogEntry, MessageFeedbackValue, MessageFeedback, ModelCatalogView, ToolCatalogEntry, MemoryConfig, MemoryDigestEntry, SkillProvider, AgentRunner, AgentRunInput, AgentRunStartOptions, HumanReply, ChatQueueState, TokenStreamSink, SinkWriter, SubscribeOptions, ActionProposalOutcome, ActionProposal } from '@dudousxd/nestjs-agent-core';
 export * from '@dudousxd/nestjs-agent-core';
 export { FunctionalToolDefinition } from '@dudousxd/nestjs-agent-core';
 import { A2uiOptions } from '@dudousxd/nestjs-agent-core/a2ui';
 import { Request, Response } from 'express';
-import { A as AgentService, a as ActionProposalService } from './index-DpS9P7so.js';
-export { b as A2uiAdapterOptions, c as A2uiRunHandler, d as AttachmentLimits, C as ChatParams, e as ChatSendMode, f as ChatSendResult, D as DEFAULT_ALLOWED_ATTACHMENT_CONTENT_TYPES, g as DEFAULT_MAX_ATTACHMENT_BYTES, M as MAX_ATTACHMENTS_PER_MESSAGE, N as NO_USER_MESSAGE_CODE, Q as QueuedSend, T as ThreadDefaultAgentReader, h as ThreadModelReader, i as a2uiAdapter, j as attachmentLimits } from './index-DpS9P7so.js';
+import { A as AgentService, a as ActionProposalService } from './index-yC_Ra3CE.js';
+export { b as A2uiAdapterOptions, c as A2uiRunHandler, d as AttachmentLimits, C as ChatParams, e as ChatSendMode, f as ChatSendResult, D as DEFAULT_ALLOWED_ATTACHMENT_CONTENT_TYPES, g as DEFAULT_MAX_ATTACHMENT_BYTES, F as ForkThreadParams, M as MAX_ATTACHMENTS_PER_MESSAGE, N as NO_USER_MESSAGE_CODE, Q as QueuedSend, T as ThreadDefaultAgentReader, h as ThreadModelReader, i as a2uiAdapter, j as attachmentLimits } from './index-yC_Ra3CE.js';
 import { AgentGenui } from './genui/index.js';
 import { StandardSchemaV1 } from '@standard-schema/spec';
 import { DiscoveryService, MetadataScanner } from '@nestjs/core';
@@ -870,7 +870,8 @@ declare const AGENT_SERVICE: unique symbol;
 
 /**
  * The default `TokenStreamSink`: buffers chunks per run in-process so a reconnecting subscriber
- * replays everything so far, then follows live.
+ * replays everything so far, then follows live. A run's buffer is dropped {@link ENDED_GRACE_MS}
+ * after it ends, or {@link LIVE_TTL_MS} after its last write if it never does.
  *
  * Single-replica only. Because the buffer lives in one process's memory, a resume/reconnect that
  * lands on a different replica than the one running the turn finds an empty buffer — the stream
@@ -879,10 +880,21 @@ declare const AGENT_SERVICE: unique symbol;
  */
 declare class InProcessTokenStreamSink implements TokenStreamSink {
     private readonly runs;
+    /** Subscribers of a run nothing has opened yet, woken by its `open()`. */
+    private readonly waiting;
     private buffer;
+    private expireAfter;
+    /** Forget the run, and let anyone still following it finish as if it had ended. */
+    private drop;
     private wake;
+    private finish;
+    /**
+     * 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: string): SinkWriter;
-    subscribe(runId: string): AsyncIterable<Uint8Array>;
+    subscribe(runId: string, options?: SubscribeOptions): AsyncIterable<Uint8Array>;
     close(runId: string): void;
 }
 

package/dist/index.js

@@ -1584,6 +1584,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_decorate5(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -1847,7 +1867,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
@@ -1858,7 +1878,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;
     }
@@ -1918,10 +1938,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) {
@@ -1945,9 +1966,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 = {
@@ -2273,8 +2294,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
@@ -2282,9 +2303,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
@@ -2437,9 +2458,28 @@ var AgentService2 = 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) {
@@ -2491,7 +2531,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,
@@ -2499,16 +2539,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
       });
@@ -2535,18 +2575,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") {
@@ -2716,8 +2765,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 NotFoundException2(`thread ${threadId} not found`);
     }
@@ -3157,6 +3206,18 @@ AttachmentsController = _ts_decorate8([
 import { AGENT_ACTOR_RESOLVER as AGENT_ACTOR_RESOLVER2, AgentStreamError, streamFailure } 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 Inject8, 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_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") {
@@ -3290,7 +3351,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
@@ -3300,7 +3362,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);
@@ -3316,8 +3379,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");
@@ -3346,6 +3412,9 @@ data: ${line}
     }, "forward");
     try {
       for await (const chunk of events) {
+        if (gone?.aborted) {
+          return;
+        }
         buffer += decoder.decode(chunk, {
           stream: true
         });
@@ -3359,11 +3428,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 AgentStreamError ? {
         code: error.code,
         message: error.message
@@ -5293,49 +5368,121 @@ SkillDiscoveryService = _ts_decorate22([
 
 // src/in-process-sink.ts
 import { AgentStreamError as AgentStreamError2 } 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) {
@@ -5351,13 +5498,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
 import { exhaustedWindow, quotaPeriodRange, quotaWarning } from "@dudousxd/nestjs-agent-core";
@@ -5376,13 +5566,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);
@@ -5396,10 +5595,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) {
@@ -7244,7 +7441,7 @@ var AgUiRunHandler = class {
       seq: 0
     };
     try {
-      const frames = agUiFramesFromNdjson(this.agent.subscribe(runId));
+      const frames = agUiFramesFromNdjson(this.agent.subscribe(runId, readerGone(res)));
       for await (const event of agUiEvents(frames, {
         ...options,
         cursor
@@ -7575,7 +7772,7 @@ var A2uiRunHandler = class {
 `);
     }, "write");
     try {
-      const frames = agUiFramesFromNdjson2(this.agent.subscribe(runId));
+      const frames = agUiFramesFromNdjson2(this.agent.subscribe(runId, readerGone(res)));
       for await (const event of agUiEvents2(frames, {
         threadId: options.threadId ?? runId,
         runId,