@dudousxd/nestjs-agent 1.3.0 → 1.5.0

package/dist/durable/index.cjs

@@ -143,8 +143,15 @@ var AgentRunSteps = class {
     if (deps.registry.spec(input.toolName)?.kind === "action" && input.toolType !== "action") {
       throw new Error(`tool "${input.toolName}" is an action tool but was dispatched without approval: the dispatching process resolved its kind against a registry that does not have it`);
     }
+    const sinkRunId = input.sinkRunId;
+    let opened;
+    const ui = (0, import_nestjs_agent_core.createUiCollector)(input.toolCallId, sinkRunId === void 0 ? void 0 : async (event) => {
+      opened ??= Promise.resolve(deps.sink.open(sinkRunId)).then((writer) => input.childSink === true ? childSinkWriter(writer) : writer);
+      await (await opened).write((0, import_nestjs_agent_core.encodeStreamEvent)(event));
+    });
     const ctx = {
-      ...input.ctx
+      ...input.ctx,
+      emitUi: ui.emit
     };
     const localClassify = deps.toolTransientRetry !== false ? deps.toolTransientRetry?.classify : void 0;
     const transientRetry = input.transientRetry === false ? false : {
@@ -154,11 +161,12 @@ var AgentRunSteps = class {
         classify: localClassify
       } : {}
     };
-    return (0, import_nestjs_agent_core.traceToolExecution)(input.ctx.runId, {
+    const output = await (0, import_nestjs_agent_core.traceToolExecution)(input.ctx.runId, {
       toolCallId: input.toolCallId,
       toolName: input.toolName,
       toolType: input.toolType
     }, () => (0, import_nestjs_agent_core.invokeWithTransientRetry)(() => {
+      ui.restart();
       const invocation = deps.registry.invoke(input.toolName, input.input, ctx, deps.rolesPolicy);
       return input.timeoutMs !== void 0 ? (0, import_nestjs_agent_core.withToolTimeout)(invocation, input.timeoutMs, input.toolName) : invocation;
     }, transientRetry, {
@@ -171,6 +179,7 @@ var AgentRunSteps = class {
         });
       }, "onRetry")
     }));
+    return input.collectUi === true ? (0, import_nestjs_agent_core.wrapToolStepOutput)(output, ui.components()) : output;
   }
 };
 _ts_decorate([
@@ -414,7 +423,10 @@ var AgentRunWorkflow = class _AgentRunWorkflow {
         dispatchTool: /* @__PURE__ */ __name((call, envelope) => ctx.step(AgentRunSteps.prototype.tool, {
           ...envelope,
           toolCallId: call.id,
-          toolType: call.kind === "action" ? "action" : "read"
+          toolType: call.kind === "action" ? "action" : "read",
+          // Where `ctx.emitUi` streams from the worker — the llm step's routing.
+          sinkRunId,
+          childSink: input.sinkRunId !== void 0
         }), "dispatchTool")
       } : {}
     };
@@ -1252,6 +1264,7 @@ var AgentService = class {
   */
   async answer(actor, toolCallId2, answers2 = {}) {
     await this.assertOwnsToolCall(actor, toolCallId2);
+    await this.assertAnswersFit(toolCallId2, answers2);
     const reply = {
       answers: answers2,
       answeredByRef: actor.id
@@ -1520,6 +1533,27 @@ var AgentService = class {
     }
   }
   /**
+  * Check a reply against the questions it answers before it is signalled: every submitted value a
+  * question's own rules accept (a typed input's type, bounds and pattern; a pick from the offered
+  * options), and every `required` question answered — by the reply, or by the defaults an omitted
+  * question falls back to. A reply the loop would have to drop parts of is refused here instead, so
+  * the person who typed it hears why. Needs the store to hand back the call's recorded questions;
+  * without that seam the loop's own filtering is the only check.
+  */
+  async assertAnswersFit(toolCallId2, answers2) {
+    if (this.store.toolCallInput === void 0) {
+      return;
+    }
+    const questions = (0, import_nestjs_agent_core8.readElicitationQuestions)(await this.store.toolCallInput(toolCallId2));
+    for (const question of questions) {
+      const submitted = Object.hasOwn(answers2, question.id) ? answers2[question.id] : void 0;
+      const problem = (0, import_nestjs_agent_core8.validateElicitationAnswer)(question, submitted ?? question.defaults ?? []);
+      if (problem !== null) {
+        throw new import_common6.BadRequestException(`answers["${question.id}"] ${problem}`);
+      }
+    }
+  }
+  /**
   * Authorization seam for approve/reject. The call's recorded approver decides who may settle it:
   * the requester (the default, and every call recorded before approvers existed) is the thread's
   * own actor — the ownership check this always was; any other approver goes through the policy's
@@ -3124,6 +3158,9 @@ var AiToolDiscoveryService = class _AiToolDiscoveryService {
         } : {},
         ...meta.presentation !== void 0 ? {
           presentation: meta.presentation
+        } : {},
+        ...meta.terminal === true ? {
+          terminal: true
         } : {}
       }, {
         execute: /* @__PURE__ */ __name((input, ctx) => instance.execute(input, ctx), "execute"),