@dudousxd/nestjs-agent 1.36.2 → 1.38.0

package/dist/a2ui/index.d.cts

@@ -1,5 +1,5 @@
 export * from '@dudousxd/nestjs-agent-core/a2ui';
-export { b as A2uiAdapterOptions, c as A2uiRunHandler, i as a2uiAdapter } from '../index-CJdTomOT.cjs';
+export { b as A2uiAdapterOptions, c as A2uiRunHandler, i as a2uiAdapter } from '../index-BJFM1tG8.cjs';
 import '@dudousxd/nestjs-agent-core';
 import 'express';
 import '@dudousxd/nestjs-agent-core/genui';

package/dist/a2ui/index.d.ts

@@ -1,5 +1,5 @@
 export * from '@dudousxd/nestjs-agent-core/a2ui';
-export { b as A2uiAdapterOptions, c as A2uiRunHandler, i as a2uiAdapter } from '../index-D1xRrnCq.js';
+export { b as A2uiAdapterOptions, c as A2uiRunHandler, i as a2uiAdapter } from '../index-De98CGXa.js';
 import '@dudousxd/nestjs-agent-core';
 import 'express';
 import '@dudousxd/nestjs-agent-core/genui';

package/dist/durable/index.cjs

@@ -646,6 +646,18 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
     ];
     const hooks = {
       runId: ctx.runId,
+      // The runtime's own enqueue stamp: the run row's `createdAt` is written when the run is
+      // started (a send, a parent's `ctx.child`, the queue's `ctx.startChild`), so now − createdAt,
+      // read on the body's first execution (inside `persist:run:start`), is how long it waited for a
+      // worker. The clocks are the enqueuing process's and the worker's.
+      queueMs: /* @__PURE__ */ __name(async () => {
+        const runs = this.runs;
+        const run = typeof runs?.getRun === "function" ? await runs.getRun(ctx.runId) : (await runs?.getRunDetail(ctx.runId))?.run;
+        const createdAt = run?.createdAt;
+        if (createdAt === void 0) return void 0;
+        const at = new Date(createdAt).getTime();
+        return Number.isFinite(at) ? Date.now() - at : void 0;
+      }, "queueMs"),
       // A child forwards into the top-level sink but must not end/fail it (the top-level run owns it).
       // A thread's own turn hands the thread to its queue just before the loop ends the stream, so
       // the reader learns what runs next from the `queue` frame, before the end.
@@ -816,6 +828,7 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
       const timed = durationMs !== void 0 ? {
         durationMs
       } : {};
+      const measured = (0, import_nestjs_agent_core4.runEndTimings)(error);
       if ((0, import_nestjs_agent_core4.isReplayIntegrityError)(error)) {
         const detail = error.message;
         const code2 = (0, import_nestjs_agent_core4.agentFailureCode)(error);
@@ -826,6 +839,7 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
           code: code2,
           message: detail,
           ...timed,
+          ...measured,
           context: (0, import_nestjs_agent_core4.agentRunContext)(input)
         });
         await (0, import_nestjs_agent_core4.settleDeadRun)(this.store, {
@@ -849,6 +863,7 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
         code,
         message,
         ...timed,
+        ...measured,
         context: (0, import_nestjs_agent_core4.agentRunContext)(input)
       });
       await stepOf(ctx)("persist:run:fail", async () => {
@@ -3014,6 +3029,7 @@ function _ts_param7(paramIndex, decorator) {
   };
 }
 __name(_ts_param7, "_ts_param");
+var usageLogger = new import_common10.Logger("AgentService");
 var NO_USER_MESSAGE_CODE = "no_user_message";
 function sendableParams(params) {
   const message = params.message;
@@ -3841,9 +3857,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 import_common10.NotFoundException(`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) {
@@ -4238,6 +4273,31 @@ var AgentService = class {
       throw new import_common10.ForbiddenException("run belongs to another actor");
     }
   }
+  /**
+  * Record AI spend that did not come from an agent turn — a transcription, a TTS render, a batch of
+  * embeddings, a direct OpenAI/OpenRouter SDK call — on the same ledger the agent's turns write, so
+  * cost, quota and the dashboard see one figure.
+  *
+  * Never throws into the caller's flow by default: a failed write or an invalid input is logged and
+  * answered with `{ recorded: false, error }`. Pass `{ throwOnError: true }` where losing the row
+  * must fail the caller.
+  *
+  * Counted against `actorRef` like an agent turn: the ledger is the budget (`LedgerQuotaProvider`),
+  * so its tokens count in the token windows (a row with no tokens adds 0 there) and its `costUsd` in
+  * the USD windows. A `QuotaStore` counter is bumped only where loop deps carry one (`AgentModule`
+  * wires none). `actorRef: null` is platform cost, recorded under `PLATFORM_ACTOR_REF` and counted
+  * against nobody.
+  */
+  recordUsage(input, options = {}) {
+    return (0, import_nestjs_agent_core16.recordAiUsage)({
+      store: this.store,
+      quota: this.deps.forAgent().quota,
+      day: utcDay(),
+      input,
+      options,
+      warn: /* @__PURE__ */ __name((message) => usageLogger.warn(message), "warn")
+    });
+  }
 };
 AgentService = _ts_decorate9([
   (0, import_common10.Injectable)(),
@@ -7218,10 +7278,12 @@ var InlineAgentRunner = class _InlineAgentRunner {
   }
   async start(input, options = {}) {
     const runId = options.runId ?? crypto.randomUUID();
+    const acceptedAt = Date.now();
     const day = input.day ?? utcDay();
     const deps = this.factory.forAgent(input.agentName);
     this.live.add(runId);
     const hooks = this.topLevelHooks({
+      acceptedAt,
       runId,
       deps,
       actor: input.actor,
@@ -7243,8 +7305,9 @@ var InlineAgentRunner = class _InlineAgentRunner {
       const timed = durationMs !== void 0 ? {
         durationMs
       } : {};
+      const measured = (0, import_nestjs_agent_core38.runEndTimings)(error);
       if (error instanceof import_nestjs_agent_core38.RunCancelledError) {
-        await this.settleCancelled(runId, input, deps, durationMs);
+        await this.settleCancelled(runId, input, deps, durationMs, measured);
         return;
       }
       const message = error instanceof Error ? error.message : String(error);
@@ -7256,6 +7319,7 @@ var InlineAgentRunner = class _InlineAgentRunner {
         code,
         message,
         ...timed,
+        ...measured,
         context: (0, import_nestjs_agent_core38.agentRunContext)(input)
       });
       await this.store.recordRunEnd?.({
@@ -7333,7 +7397,7 @@ var InlineAgentRunner = class _InlineAgentRunner {
   * the stream ENDED after a `cancelled` frame rather than failed, so a client that retries failed
   * streams does not retry this one.
   */
-  async settleCancelled(runId, input, deps, durationMs) {
+  async settleCancelled(runId, input, deps, durationMs, measured = {}) {
     this.logger.log(`agent run ${runId} cancelled`);
     const timed = durationMs !== void 0 ? {
       durationMs
@@ -7342,6 +7406,7 @@ var InlineAgentRunner = class _InlineAgentRunner {
       runId,
       threadId: input.threadId,
       ...timed,
+      ...measured,
       context: (0, import_nestjs_agent_core38.agentRunContext)(input)
     });
     const writer = await deps.sink.open(runId);
@@ -7434,9 +7499,10 @@ var InlineAgentRunner = class _InlineAgentRunner {
     });
   }
   topLevelHooks(args) {
-    const { runId, deps, actor, day, threadId, chainBelow, input } = args;
+    const { runId, deps, actor, day, threadId, chainBelow, input, acceptedAt } = args;
     return {
       runId,
+      queueMs: /* @__PURE__ */ __name(() => Date.now() - acceptedAt, "queueMs"),
       // The loop ends the stream when the turn completes. Just before, the thread passes to the next
       // queued message (or is released), and the reader is told which — so by the time a client
       // sees the run end, the thread is already free or already running what it queued.
@@ -7561,10 +7627,12 @@ var InlineAgentRunner = class _InlineAgentRunner {
       const timed = durationMs !== void 0 ? {
         durationMs
       } : {};
+      const measured = (0, import_nestjs_agent_core38.runEndTimings)(error);
       const settled = {
         runId,
         threadId: subThread.id,
         ...timed,
+        ...measured,
         context: (0, import_nestjs_agent_core38.agentRunContext)(childInput)
       };
       if (cancelled) {