@dudousxd/nestjs-agent 1.39.1 → 2.0.1

package/dist/workflows/index.js

@@ -0,0 +1,1464 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/workflows/agent-workflows.module.ts
+import { AGENT_WORKFLOWS_RUNNER } from "@dudousxd/nestjs-agent-core";
+import { Global, Module } from "@nestjs/common";
+
+// src/workflows/agent-run.flow.ts
+import { Workflow } from "@nestjs/workflows";
+
+// src/workflows/agent-turn.executor.ts
+import { AGENT_DEPS_FACTORY, AGENT_OPTIONS, AGENT_STORE, RUN_ENDED_BEFORE_TOOL_CALL, RunCancelledError as RunCancelledError2, agentFailureCode, agentRunContext, encodeStreamEvent as encodeStreamEvent2, isReplayIntegrityError as isReplayIntegrityError2, publishAgentRunFailed, releaseThreadRun, runAgentLoop, runDurationMs, runEndTimings, settleAll, settleDeadRun, settleUnsettledDelegation, streamFailure } from "@dudousxd/nestjs-agent-core";
+import { Inject, Injectable, Logger, Optional } from "@nestjs/common";
+import { ChildWorkflowFailedError, NonRetryableStepError, StepFailedError, WORKFLOWS_MODULE_OPTIONS, WorkflowClient } from "@nestjs/workflows";
+
+// src/agent-deps.ts
+function utcDay(date = /* @__PURE__ */ new Date()) {
+  return date.toISOString().slice(0, 10);
+}
+__name(utcDay, "utcDay");
+function childSinkWriter(writer) {
+  return {
+    write: /* @__PURE__ */ __name((chunk) => writer.write(chunk), "write"),
+    // The top-level run owns end/fail — but what the child wrote must not be held back past it.
+    end: /* @__PURE__ */ __name(async () => {
+      await writer.flush?.();
+    }, "end"),
+    fail: /* @__PURE__ */ __name(async () => {
+      await writer.flush?.();
+    }, "fail"),
+    flush: /* @__PURE__ */ __name(async () => {
+      await writer.flush?.();
+    }, "flush")
+  };
+}
+__name(childSinkWriter, "childSinkWriter");
+
+// src/agent.options.ts
+function durableEngineOf(durable) {
+  if (durable === void 0 || durable === false) return void 0;
+  if (durable === true) return "workflows";
+  return durable.engine ?? "workflows";
+}
+__name(durableEngineOf, "durableEngineOf");
+
+// src/queue/chat-queue.token.ts
+var AGENT_CHAT_QUEUE = /* @__PURE__ */ Symbol.for("@dudousxd/nestjs-agent:chat-queue");
+
+// src/runner/agent-step-bodies.ts
+import { createNegotiatedUiCollector } from "@dudousxd/nestjs-agent-core";
+import { prepareActionProposal, resolveActionProposalApproval } from "@dudousxd/nestjs-agent-core";
+import { announcedToolCalls, createFrameBuffer, createNoopEmitUi, encodeStreamEvent, intersectAllowLists, invokeWithTransientRetry, isControlFlowSignal, isReplayIntegrityError, observeFirstText, observeTurnFrames, previewToolInputs, publishAgentToolRetry, registryInputPreviews, stampToolKinds, toolCallContext, traceLlmTurn, traceToolExecution, withAskTool, withChannelDelivery, withMemoryTool, withSkillTool, withToolTimeout, withTurnFrames, wrapToolPreflightDenied, wrapToolStepOutput } from "@dudousxd/nestjs-agent-core";
+import { turnChannel } from "@dudousxd/nestjs-agent-core/genui";
+async function runLlmStep(factory, input, options = {}) {
+  const deps = factory.forAgent(input.agentName);
+  const tools = withMemoryTool({
+    tools: withSkillTool({
+      tools: withAskTool({
+        tools: await deps.registry.definitionsFor(
+          input.actor,
+          deps.rolesPolicy,
+          // The persona narrowing the loop journaled in `persona:resolve` rides the envelope:
+          // this worker's own persona config may already say something else.
+          intersectAllowLists(deps.toolAllowList, input.personaAllowedTools),
+          {
+            ...input.threadId !== void 0 ? {
+              threadId: input.threadId
+            } : {},
+            ...input.preflightContext?.uiCapabilities !== void 0 ? {
+              uiCapabilities: input.preflightContext.uiCapabilities
+            } : {},
+            channel: turnChannel(input.preflightContext?.pageContext),
+            ...input.agentName !== void 0 ? {
+              agentName: input.agentName
+            } : {}
+          }
+        ),
+        ask: deps.ask
+      }),
+      enabled: deps.skills !== void 0 && input.builtins?.skills !== false
+    }),
+    enabled: deps.memory?.provider.write !== void 0 && input.builtins?.memory !== false
+  });
+  const buffer = input.bufferOutput === true ? createFrameBuffer() : void 0;
+  let writer;
+  let firstText;
+  if (buffer !== void 0) {
+    writer = buffer.writer;
+  } else {
+    const opened = await deps.sink.open(input.sinkRunId);
+    firstText = observeFirstText(input.childSink ? childSinkWriter(opened) : opened);
+    writer = firstText.writer;
+  }
+  const announced = announcedToolCalls(writer);
+  const previews = previewToolInputs(announced.writer, registryInputPreviews(deps.registry, tools, {
+    actor: input.actor,
+    ...input.threadId !== void 0 ? {
+      threadId: input.threadId
+    } : {},
+    ...input.agentName !== void 0 ? {
+      agentName: input.agentName
+    } : {},
+    ...input.preflightContext?.uiCapabilities !== void 0 ? {
+      uiCapabilities: input.preflightContext.uiCapabilities
+    } : {},
+    channel: turnChannel(input.preflightContext?.pageContext)
+  }));
+  const frames = observeTurnFrames(previews.writer);
+  const turn = withTurnFrames(await traceLlmTurn(input.runId, input.step, () => deps.model.runTurn({
+    system: input.system,
+    messages: input.messages,
+    tools,
+    sink: frames.writer,
+    ...input.model !== void 0 ? {
+      model: input.model
+    } : {},
+    ...options.abortSignal !== void 0 ? {
+      abortSignal: options.abortSignal
+    } : {}
+  })), frames.summary());
+  const stamped = stampToolKinds(turn, deps);
+  await announced.announceRest(stamped.toolCalls, tools);
+  const allowedTools = intersectAllowLists(deps.toolAllowList, input.personaAllowedTools);
+  for (const call of stamped.toolCalls) {
+    if (call.kind !== "action") continue;
+    try {
+      const context = input.preflightContext ?? {
+        actor: input.actor,
+        threadId: input.threadId ?? "",
+        runId: input.runId,
+        requestId: input.runId,
+        ...input.agentName !== void 0 ? {
+          agentName: input.agentName
+        } : {}
+      };
+      if (input.actionApprovalMode === "independent") {
+        const spec = deps.registry.spec(call.name);
+        call.actionApproval = await resolveActionProposalApproval({
+          actor: input.actor,
+          store: deps.store,
+          tool: {
+            name: call.name,
+            kind: "action",
+            ...spec !== void 0 ? {
+              spec
+            } : {}
+          },
+          thread: {
+            threadId: context.threadId,
+            runId: input.runId,
+            ...input.agentName !== void 0 ? {
+              agentName: input.agentName
+            } : {}
+          },
+          ...deps.approvalPolicy !== void 0 ? {
+            policy: deps.approvalPolicy
+          } : {}
+        });
+      }
+      if (call.actionApproval?.mode === "ask") {
+        call.prepared = await prepareActionProposal(deps.registry, call.name, call.input, {
+          ...toolCallContext(context, call.id),
+          emitUi: createNoopEmitUi(call.id)
+        }, deps.rolesPolicy, allowedTools === void 0 ? {} : {
+          allowedTools
+        });
+        call.preflight = call.prepared.preflight;
+      } else {
+        call.preflight = await deps.registry.prepare(call.name, call.input, {
+          ...toolCallContext(context, call.id),
+          emitUi: createNoopEmitUi(call.id)
+        }, deps.rolesPolicy, allowedTools === void 0 ? {} : {
+          allowedTools
+        });
+      }
+    } catch (error) {
+      if (isControlFlowSignal(error) || isReplayIntegrityError(error)) throw error;
+      call.preflight = {
+        status: "failed",
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  const shown = previews.shown();
+  const previewed = shown.length > 0 ? {
+    ...stamped,
+    previews: shown
+  } : stamped;
+  const firstTextAt = firstText?.firstTextAt();
+  if (buffer !== void 0) {
+    return {
+      ...previewed,
+      bufferedFrames: buffer.frames()
+    };
+  }
+  return firstTextAt === void 0 ? previewed : {
+    ...previewed,
+    firstTextAt
+  };
+}
+__name(runLlmStep, "runLlmStep");
+async function runToolStep(factory, input, options = {}) {
+  const deps = factory.forAgent(input.ctx.agentName);
+  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 = createNegotiatedUiCollector(input.toolCallId, input.ctx, deps.resolveUiCatalog, 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(encodeStreamEvent(event));
+  });
+  const ctx = {
+    ...toolCallContext(input.ctx, input.toolCallId),
+    emitUi: ui.emit,
+    ...options.abortSignal !== void 0 ? {
+      abortSignal: options.abortSignal
+    } : {}
+  };
+  const localClassify = deps.toolTransientRetry !== false ? deps.toolTransientRetry?.classify : void 0;
+  const transientRetry = input.transientRetry === false ? false : {
+    attempts: input.transientRetry.attempts,
+    backoffMs: input.transientRetry.backoffMs,
+    ...localClassify !== void 0 ? {
+      classify: localClassify
+    } : {}
+  };
+  const allowedTools = intersectAllowLists(deps.toolAllowList, input.allowedTools === void 0 ? void 0 : [
+    ...input.allowedTools
+  ]);
+  let output;
+  const toolStartedAt = Date.now();
+  try {
+    output = await traceToolExecution(input.ctx.runId, {
+      toolCallId: input.toolCallId,
+      toolName: input.toolName,
+      toolType: input.toolType
+    }, () => invokeWithTransientRetry(() => {
+      ui.restart();
+      const invocation = deps.registry.invoke(input.toolName, input.input, ctx, deps.rolesPolicy, allowedTools === void 0 ? {} : {
+        allowedTools
+      });
+      return input.timeoutMs !== void 0 ? withToolTimeout(invocation, input.timeoutMs, input.toolName) : invocation;
+    }, transientRetry, {
+      onRetry: /* @__PURE__ */ __name((attempt, error) => {
+        publishAgentToolRetry({
+          toolName: input.toolName,
+          toolCallId: input.toolCallId,
+          attempt,
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }, "onRetry")
+    }));
+  } catch (error) {
+    if (error instanceof Error && error.name === "ToolPreflightDeniedError") {
+      return wrapToolPreflightDenied(error.message);
+    }
+    throw error;
+  }
+  const executionMs = Date.now() - toolStartedAt;
+  output = await withChannelDelivery(deps, input.ctx, output, ui.components());
+  return input.collectUi === true ? wrapToolStepOutput(output, ui.components(), ui.text(), executionMs) : output;
+}
+__name(runToolStep, "runToolStep");
+
+// src/workflows/agent-reply.signal.ts
+import { WorkflowSignal } from "@nestjs/workflows";
+var AGENT_REPLY = new WorkflowSignal("aviary.agent.reply");
+function replyKey(runId, toolCallId) {
+  return `${runId}:${toolCallId}`;
+}
+__name(replyKey, "replyKey");
+
+// src/workflows/turn-journal.ts
+import { OutputRejectedError, QuotaExceededError, RunCancelledError, StructuredOutputError } from "@dudousxd/nestjs-agent-core";
+import { isWorkflowInterrupt } from "@nestjs/workflows";
+var CONTROL_FLOW_SIGNAL = /* @__PURE__ */ Symbol.for("aviary:durable:control-flow");
+function markControlFlow(error) {
+  if (isWorkflowInterrupt(error) && typeof error === "object" && error !== null) {
+    error[CONTROL_FLOW_SIGNAL] = true;
+  }
+  return error;
+}
+__name(markControlFlow, "markControlFlow");
+var SegmentBoundary = class extends Error {
+  static {
+    __name(this, "SegmentBoundary");
+  }
+  constructor() {
+    super("The turn goes on in a child workflow instance");
+    this.name = "SegmentBoundary";
+    this[CONTROL_FLOW_SIGNAL] = true;
+  }
+};
+function isEngineControlFlow(error) {
+  return isWorkflowInterrupt(error) || error instanceof SegmentBoundary;
+}
+__name(isEngineControlFlow, "isEngineControlFlow");
+function serializeTurnError(error) {
+  if (!(error instanceof Error)) {
+    return {
+      name: "Error",
+      message: String(error)
+    };
+  }
+  const props = {};
+  for (const [key, value] of Object.entries(error)) {
+    if (key === "name" || key === "message" || key === "stack") continue;
+    try {
+      const json = JSON.stringify(value);
+      if (json !== void 0) props[key] = JSON.parse(json);
+    } catch {
+    }
+  }
+  return {
+    name: error.name,
+    message: error.message,
+    ...Object.keys(props).length > 0 ? {
+      props
+    } : {}
+  };
+}
+__name(serializeTurnError, "serializeTurnError");
+function stepFailureCause(error) {
+  const cause = error.cause;
+  if (typeof cause === "object" && cause !== null) {
+    const { name, message } = cause;
+    if (typeof message === "string") {
+      return {
+        name: typeof name === "string" ? name : "Error",
+        message
+      };
+    }
+  }
+  if (cause === void 0 || cause === null) return {
+    name: "Error",
+    message: error.message
+  };
+  return {
+    name: "Error",
+    message: typeof cause === "string" ? cause : safeString(cause)
+  };
+}
+__name(stepFailureCause, "stepFailureCause");
+function safeString(value) {
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+__name(safeString, "safeString");
+var KNOWN_ERRORS = {
+  QuotaExceededError,
+  RunCancelledError,
+  OutputRejectedError,
+  StructuredOutputError
+};
+function rebuildTurnError(serialized) {
+  const prototype = KNOWN_ERRORS[serialized.name]?.prototype ?? Error.prototype;
+  const error = Object.create(prototype);
+  Object.assign(error, serialized.props ?? {});
+  Object.defineProperty(error, "name", {
+    value: serialized.name,
+    writable: true,
+    configurable: true
+  });
+  Object.defineProperty(error, "message", {
+    value: serialized.message,
+    writable: true,
+    configurable: true
+  });
+  Object.defineProperty(error, "stack", {
+    value: `${serialized.name}: ${serialized.message}`,
+    writable: true,
+    configurable: true
+  });
+  return error;
+}
+__name(rebuildTurnError, "rebuildTurnError");
+var TurnJournal = class {
+  static {
+    __name(this, "TurnJournal");
+  }
+  counts = /* @__PURE__ */ new Map();
+  /** Every operation's outcome so far: the carried ones, then this instance's. */
+  outcomes;
+  /** Model calls this instance made itself (not carried). */
+  liveModelCalls = 0;
+  constructor(carried = {}) {
+    this.outcomes = {
+      ...carried
+    };
+  }
+  /** `base` the first time, `base#2` the second, ... */
+  unique(base) {
+    const count = (this.counts.get(base) ?? 0) + 1;
+    this.counts.set(base, count);
+    return count === 1 ? base : `${base}#${count}`;
+  }
+  /** Was `name` carried from an earlier segment, or already settled in this one? */
+  has(name) {
+    return name in this.outcomes;
+  }
+  /**
+  * Run `live` (a `ctx` operation) once per run: a name an earlier segment settled answers from
+  * `carried`. A failure is recorded too, so a later segment replays it as the same failure; the
+  * engine's own control flow is not.
+  */
+  async op(name, live) {
+    const known = this.outcomes[name];
+    if (known !== void 0) {
+      if ("e" in known) throw rebuildTurnError(known.e);
+      return known.v;
+    }
+    try {
+      const value = await live();
+      this.outcomes[name] = value === void 0 ? {} : {
+        v: value
+      };
+      return value;
+    } catch (error) {
+      if (isEngineControlFlow(error)) throw markControlFlow(error);
+      this.outcomes[name] = {
+        e: serializeTurnError(error)
+      };
+      throw error;
+    }
+  }
+};
+
+// src/workflows/agent-turn.executor.ts
+function _ts_decorate(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") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var AGENT_RUN_WORKFLOW = "aviary.agent.run";
+var AGENT_RUN_SEGMENT_WORKFLOW = "aviary.agent.run.segment";
+var DEFAULT_STEPS_PER_INSTANCE = 10;
+var SegmentFailed = class SegmentFailed2 extends Error {
+  static {
+    __name(this, "SegmentFailed");
+  }
+  cause;
+  constructor(cause) {
+    super(cause.message), this.cause = cause;
+    this.name = "SegmentFailed";
+  }
+};
+function isConfigurationError(error) {
+  return error instanceof Error && (error.name === "AiConfigurationError" || error.name === "AgentConfigurationError");
+}
+__name(isConfigurationError, "isConfigurationError");
+function isFatalDefinitionError(error) {
+  return isReplayIntegrityError2(error) || error instanceof Error && (error.name === "WorkflowDefinitionError" || error.name === "WorkflowJournalLimitError");
+}
+__name(isFatalDefinitionError, "isFatalDefinitionError");
+var AgentTurnExecutor = class {
+  static {
+    __name(this, "AgentTurnExecutor");
+  }
+  factory;
+  store;
+  queue;
+  client;
+  workflowsOptions;
+  logger = new Logger("AgentRunFlow");
+  stepsPerInstance;
+  constructor(factory, store, options, queue, client, workflowsOptions) {
+    this.factory = factory;
+    this.store = store;
+    this.queue = queue;
+    this.client = client;
+    this.workflowsOptions = workflowsOptions;
+    const durable = options?.durable;
+    const configured = durableEngineOf(durable) === "workflows" && typeof durable === "object" ? durable.stepsPerInstance : void 0;
+    this.stepsPerInstance = configured !== void 0 && Number.isInteger(configured) && configured > 0 ? configured : DEFAULT_STEPS_PER_INSTANCE;
+  }
+  /** A turn from its first instance. */
+  run(ctx, input) {
+    return this.execute(ctx, {
+      input,
+      runId: ctx.workflowId,
+      segment: 0,
+      carried: {}
+    });
+  }
+  async execute(ctx, segment) {
+    const { input, runId } = segment;
+    const journal = new TurnJournal(segment.carried);
+    const day = input.day ?? utcDay();
+    const deps = this.factory.forAgent(input.agentName);
+    const sinkRunId = input.sinkRunId ?? runId;
+    const childSink = input.sinkRunId !== void 0;
+    const originals = /* @__PURE__ */ new Map();
+    const pending = /* @__PURE__ */ new Map();
+    const showPending = /* @__PURE__ */ __name(() => ctx.setStatus(pending.size > 0 ? {
+      pendingReplies: [
+        ...pending.values()
+      ]
+    } : null), "showPending");
+    const checkpoint = /* @__PURE__ */ __name((name, fn) => journal.op(name, async () => {
+      const envelope = await this.ctxCall(() => ctx.step(name, async () => {
+        try {
+          const value = await fn();
+          return value === void 0 ? {} : {
+            v: value
+          };
+        } catch (error) {
+          originals.set(name, error);
+          return {
+            e: serializeTurnError(error)
+          };
+        }
+      }));
+      if ("e" in envelope) {
+        throw originals.get(name) ?? rebuildTurnError(envelope.e);
+      }
+      return envelope.v;
+    }), "checkpoint");
+    const step = /* @__PURE__ */ __name((name, fn) => checkpoint(journal.unique(name), fn), "step");
+    const awaitReply = /* @__PURE__ */ __name(async (call, timeoutMs) => {
+      const name = journal.unique(`reply:${call.id}`);
+      pending.set(call.id, {
+        key: replyKey(runId, call.id),
+        runId,
+        toolCallId: call.id,
+        toolName: call.toolName,
+        kind: call.kind
+      });
+      showPending();
+      const reply = await journal.op(name, () => this.ctxCall(() => ctx.waitForSignal(name, AGENT_REPLY, {
+        key: replyKey(runId, call.id),
+        ...timeoutMs !== void 0 ? {
+          timeout: timeoutMs
+        } : {}
+      })));
+      pending.delete(call.id);
+      showPending();
+      return reply;
+    }, "awaitReply");
+    const chainBelow = [
+      ...input.delegationPath ?? [],
+      ...input.agentName !== void 0 ? [
+        input.agentName
+      ] : []
+    ];
+    const subThread = /* @__PURE__ */ __name((agentName) => step(`subthread:${agentName}`, async () => {
+      const thread = await this.store.createThread({
+        actor: input.actor,
+        transient: true
+      });
+      return thread.id;
+    }), "subThread");
+    if (input.sinkRunId !== void 0 || input.deliverTo !== void 0) {
+      await step("activate", () => this.store.setActiveStream(input.threadId, runId));
+    }
+    const hooks = {
+      runId,
+      queueMs: /* @__PURE__ */ __name(async () => {
+        const status = await this.client?.getStatus(runId);
+        if (status === void 0 || status === null) return void 0;
+        const now = this.workflowsOptions?.clock?.now() ?? Date.now();
+        const waited = now - status.createdAt;
+        return Number.isFinite(waited) && waited >= 0 ? waited : void 0;
+      }, "queueMs"),
+      openSink: /* @__PURE__ */ __name(async () => {
+        if (childSink) {
+          return childSinkWriter(await deps.sink.open(sinkRunId));
+        }
+        const writer = await deps.sink.open(runId);
+        return {
+          write: /* @__PURE__ */ __name((chunk) => writer.write(chunk), "write"),
+          fail: /* @__PURE__ */ __name((failure) => writer.fail(failure), "fail"),
+          end: /* @__PURE__ */ __name(async () => {
+            const frame = await this.advanceQueue(ctx, step, journal, runId, input, "completed");
+            if (frame !== void 0) {
+              await writer.write(encodeStreamEvent2(frame));
+            }
+            await writer.end();
+          }, "end")
+        };
+      }, "openSink"),
+      awaitApproval: /* @__PURE__ */ __name(async (call, _toolCtx, opts) => {
+        const reply = await awaitReply({
+          id: call.id,
+          toolName: call.name,
+          kind: "approval"
+        }, opts?.timeoutMs);
+        return reply === null ? {
+          approved: false,
+          expired: true
+        } : reply;
+      }, "awaitApproval"),
+      awaitAnswers: /* @__PURE__ */ __name(async (request) => {
+        const reply = await awaitReply({
+          id: request.id,
+          toolName: request.source,
+          kind: "elicitation"
+        });
+        return reply ?? {
+          approved: false
+        };
+      }, "awaitAnswers"),
+      step,
+      parallel: settleAll,
+      isControlFlowError: isEngineControlFlow,
+      runAgent: /* @__PURE__ */ __name(async (agentName, task) => {
+        const name = journal.unique(`delegate:${agentName}`);
+        const subThreadId = await subThread(agentName);
+        const child = {
+          agentName,
+          threadId: subThreadId,
+          actor: input.actor,
+          userText: task,
+          day,
+          delegationDepth: (input.delegationDepth ?? 0) + 1,
+          delegationPath: chainBelow,
+          parentRunId: runId,
+          sinkRunId
+        };
+        return journal.op(name, () => this.ctxCall(() => ctx.executeChild(AGENT_RUN_WORKFLOW, child, {
+          id: `${ctx.workflowId}/${name}`
+        })));
+      }, "runAgent"),
+      // A detached delegation outlives the turn that started it, and a Stop on that turn: an
+      // abandoned child, not a cancelled one.
+      startAgent: /* @__PURE__ */ __name(async ({ agentName, task, toolCallId }) => {
+        const name = journal.unique(`detach:${toolCallId}`);
+        const subThreadId = await subThread(agentName);
+        const child = {
+          agentName,
+          threadId: subThreadId,
+          actor: input.actor,
+          userText: task,
+          day,
+          delegationDepth: (input.delegationDepth ?? 0) + 1,
+          delegationPath: chainBelow,
+          parentRunId: runId,
+          deliverTo: {
+            threadId: input.threadId,
+            toolCallId
+          }
+        };
+        const childRunId = await journal.op(name, async () => {
+          const handle = await this.ctxCall(() => ctx.startChild(AGENT_RUN_WORKFLOW, child, {
+            id: `${runId}.detached.${toolCallId}`,
+            parentClose: "abandon"
+          }));
+          return handle.id;
+        });
+        return {
+          runId: childRunId
+        };
+      }, "startAgent"),
+      dispatchLlm: /* @__PURE__ */ __name((index, envelope) => {
+        const name = journal.unique(`llm:${index}`);
+        if (!journal.has(name)) {
+          if (journal.liveModelCalls >= this.stepsPerInstance) {
+            throw new SegmentBoundary();
+          }
+          journal.liveModelCalls += 1;
+        }
+        return journal.op(name, async () => {
+          try {
+            return await this.ctxCall(() => ctx.step(name, (attempt) => runLlmStep(this.factory, {
+              ...envelope,
+              runId,
+              step: index,
+              sinkRunId,
+              childSink
+            }, {
+              abortSignal: attempt.signal
+            }).catch((error) => {
+              if (!isConfigurationError(error)) throw error;
+              const fatal = new NonRetryableStepError(error.message);
+              fatal.name = error.name;
+              throw fatal;
+            })));
+          } catch (error) {
+            if (error instanceof StepFailedError) {
+              throw rebuildTurnError(stepFailureCause(error));
+            }
+            throw error;
+          }
+        });
+      }, "dispatchLlm"),
+      // A tool's failure is a result the model reads, not the step's: the step is retried only after
+      // a crash, and the tool's `ctx.idempotencyKey` (`<runId>:<toolCallId>`) is the same on that
+      // attempt, so a tool that passes it on does its side effect once.
+      dispatchTool: /* @__PURE__ */ __name((call, envelope) => checkpointTool(journal.unique(`tool:${call.id}`), call, envelope), "dispatchTool")
+    };
+    const checkpointTool = /* @__PURE__ */ __name((name, call, envelope) => journal.op(name, async () => {
+      const outcome = await this.ctxCall(() => ctx.step(name, async (attempt) => {
+        try {
+          const value = await runToolStep(this.factory, {
+            ...envelope,
+            toolCallId: call.id,
+            toolType: call.kind === "action" ? "action" : "read",
+            sinkRunId,
+            childSink
+          }, {
+            abortSignal: attempt.signal
+          });
+          return value === void 0 ? {} : {
+            v: value
+          };
+        } catch (error) {
+          originals.set(name, error);
+          return {
+            e: serializeTurnError(error)
+          };
+        }
+      }));
+      if ("e" in outcome) throw originals.get(name) ?? rebuildTurnError(outcome.e);
+      return outcome.v;
+    }), "checkpointTool");
+    try {
+      const result = await runAgentLoop({
+        ...deps,
+        day
+      }, input, hooks);
+      await step("deactivate", () => releaseThreadRun(this.store, input.threadId, runId));
+      return result;
+    } catch (error) {
+      if (error instanceof SegmentBoundary) {
+        return this.continueInSegment(ctx, {
+          ...segment,
+          carried: journal.outcomes
+        });
+      }
+      if (isEngineControlFlow(error) || error instanceof SegmentFailed) {
+        throw error;
+      }
+      if (error instanceof RunCancelledError2) {
+        await step("deactivate", () => releaseThreadRun(this.store, input.threadId, runId));
+        await this.settleDetachedParent(step, runId, input, {
+          status: "cancelled"
+        });
+        throw error;
+      }
+      const durationMs = runDurationMs(error);
+      const timed = durationMs !== void 0 ? {
+        durationMs
+      } : {};
+      const measured = runEndTimings(error);
+      const message = error instanceof Error ? error.message : String(error);
+      const code = agentFailureCode(error);
+      this.logger.error(`agent run ${runId} failed (${code}): ${message}`);
+      publishAgentRunFailed({
+        runId,
+        threadId: input.threadId,
+        code,
+        message,
+        ...timed,
+        ...measured,
+        context: agentRunContext(input)
+      });
+      if (isFatalDefinitionError(error)) {
+        await settleDeadRun(this.store, {
+          runId,
+          threadId: input.threadId,
+          failure: {
+            code,
+            message,
+            ...timed
+          }
+        });
+        await (await hooks.openSink()).fail(streamFailure(error));
+        throw error;
+      }
+      try {
+        await step("persist:run:fail", async () => {
+          await this.store.recordRunEnd?.({
+            runId,
+            status: "failed",
+            ...timed,
+            errorCode: code,
+            errorMessage: message
+          });
+          await Promise.resolve(this.store.failUnsettledToolCalls?.(runId, RUN_ENDED_BEFORE_TOOL_CALL)).catch(() => 0);
+        });
+        const queueFrame = await this.advanceQueue(ctx, step, journal, runId, input, "failed", message);
+        await step("deactivate", () => releaseThreadRun(this.store, input.threadId, runId));
+        await this.settleDetachedParent(step, runId, input, {
+          status: "failed",
+          error: message
+        });
+        const writer = await hooks.openSink();
+        if (queueFrame !== void 0) {
+          await writer.write(encodeStreamEvent2(queueFrame));
+        }
+        await writer.fail(streamFailure(error));
+      } catch (settling) {
+        if (isEngineControlFlow(settling)) throw markControlFlow(settling);
+        throw settling;
+      }
+      throw error;
+    }
+  }
+  /** The turn goes on in a child instance, from what this one (and those before it) settled. */
+  async continueInSegment(ctx, segment) {
+    const next = {
+      ...segment,
+      segment: segment.segment + 1
+    };
+    try {
+      return await this.ctxCall(() => ctx.executeChild(AGENT_RUN_SEGMENT_WORKFLOW, next, {
+        id: `${segment.runId}~${next.segment}`
+      }));
+    } catch (error) {
+      if (error instanceof ChildWorkflowFailedError) throw new SegmentFailed(error);
+      throw error;
+    }
+  }
+  /**
+  * Hand the thread on past this settling turn, as the `aviary` engine does: the decision is one
+  * checkpoint, and the next message starts as an abandoned child under its own id, so the turn
+  * ending doesn't cancel it.
+  */
+  async advanceQueue(ctx, step, journal, runId, input, outcome, error) {
+    const queue = this.queue;
+    if (queue === void 0 || !queue.supported || input.sinkRunId !== void 0 || input.deliverTo !== void 0) {
+      return void 0;
+    }
+    const plan = await step(`queue:${outcome}`, async () => {
+      try {
+        const settled = outcome === "completed" && await this.isCancelled(runId) ? "cancelled" : outcome;
+        return await queue.plan({
+          threadId: input.threadId,
+          runId,
+          outcome: settled,
+          ...error !== void 0 ? {
+            error
+          } : {}
+        });
+      } catch {
+        return {};
+      }
+    });
+    const next = plan.next;
+    if (next === void 0) {
+      return plan.frame;
+    }
+    try {
+      await journal.op(journal.unique(`queue:start:${next.runId}`), async () => {
+        const handle = await this.ctxCall(() => ctx.startChild(AGENT_RUN_WORKFLOW, next.input, {
+          id: next.runId,
+          parentClose: "abandon"
+        }));
+        return handle.id;
+      });
+      return plan.frame;
+    } catch (failure) {
+      if (isEngineControlFlow(failure)) throw failure;
+      const reason = failure instanceof Error ? failure.message : String(failure);
+      return step("queue:restore", async () => {
+        await queue.restore(input.threadId, next, "start_failed", reason);
+        return queue.pausedFrame(input.threadId);
+      });
+    }
+  }
+  async isCancelled(runId) {
+    try {
+      return (await this.client?.getStatus(runId))?.cancelRequested === true;
+    } catch {
+      return false;
+    }
+  }
+  async settleDetachedParent(step, runId, input, outcome) {
+    const delivery = input.deliverTo;
+    if (delivery === void 0) return;
+    await step("deliver:detached:unsettled", () => settleUnsettledDelegation({
+      store: this.store,
+      delivery,
+      agent: input.agentName ?? "default",
+      runId,
+      status: outcome.status,
+      ...outcome.error !== void 0 ? {
+        error: outcome.error
+      } : {}
+    }));
+  }
+  /** A `ctx` call whose interrupt carries core's control-flow marker. */
+  async ctxCall(call) {
+    try {
+      return await call();
+    } catch (error) {
+      throw markControlFlow(error);
+    }
+  }
+};
+AgentTurnExecutor = _ts_decorate([
+  Injectable(),
+  _ts_param(0, Inject(AGENT_DEPS_FACTORY)),
+  _ts_param(1, Inject(AGENT_STORE)),
+  _ts_param(2, Optional()),
+  _ts_param(2, Inject(AGENT_OPTIONS)),
+  _ts_param(3, Optional()),
+  _ts_param(3, Inject(AGENT_CHAT_QUEUE)),
+  _ts_param(4, Optional()),
+  _ts_param(5, Optional()),
+  _ts_param(5, Inject(WORKFLOWS_MODULE_OPTIONS)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof AgentDepsFactory === "undefined" ? Object : AgentDepsFactory,
+    typeof AgentStore === "undefined" ? Object : AgentStore,
+    typeof AgentModuleOptions === "undefined" ? Object : AgentModuleOptions,
+    typeof ChatQueueService === "undefined" ? Object : ChatQueueService,
+    typeof WorkflowClient === "undefined" ? Object : WorkflowClient,
+    typeof WorkflowsModuleOptions === "undefined" ? Object : WorkflowsModuleOptions
+  ])
+], AgentTurnExecutor);
+
+// src/workflows/agent-run.flow.ts
+function _ts_decorate2(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") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata2(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata2, "_ts_metadata");
+var AgentRunFlow = class {
+  static {
+    __name(this, "AgentRunFlow");
+  }
+  turns;
+  constructor(turns) {
+    this.turns = turns;
+  }
+  run(ctx, input) {
+    return this.turns.run(ctx, input);
+  }
+};
+AgentRunFlow = _ts_decorate2([
+  Workflow(AGENT_RUN_WORKFLOW),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof AgentTurnExecutor === "undefined" ? Object : AgentTurnExecutor
+  ])
+], AgentRunFlow);
+var AgentRunSegmentFlow = class {
+  static {
+    __name(this, "AgentRunSegmentFlow");
+  }
+  turns;
+  constructor(turns) {
+    this.turns = turns;
+  }
+  run(ctx, segment) {
+    return this.turns.execute(ctx, segment);
+  }
+};
+AgentRunSegmentFlow = _ts_decorate2([
+  Workflow(AGENT_RUN_SEGMENT_WORKFLOW),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof AgentTurnExecutor === "undefined" ? Object : AgentTurnExecutor
+  ])
+], AgentRunSegmentFlow);
+
+// src/workflows/workflows-agent-runner.ts
+import { randomUUID } from "crypto";
+import { AGENT_SINK, AGENT_STORE as AGENT_STORE2, encodeStreamEvent as encodeStreamEvent3, publishAgentRunCancelled, releaseThreadRun as releaseThreadRun2, settleUnsettledDelegation as settleUnsettledDelegation2 } from "@dudousxd/nestjs-agent-core";
+import { Inject as Inject2, Injectable as Injectable2, Logger as Logger2, Optional as Optional2 } from "@nestjs/common";
+import { WorkflowClient as WorkflowClient2, WorkflowNotFoundError } from "@nestjs/workflows";
+
+// 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(),
+        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 resolve of waiters ?? []) {
+        resolve();
+      }
+    }
+    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 resolve of buf.notify) {
+      resolve();
+    }
+    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) {
+    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(() => {
+        this.finish(runId, this.buffer(runId));
+      }, "end"),
+      fail: /* @__PURE__ */ __name((error) => {
+        const buf = this.buffer(runId);
+        buf.failure = error;
+        this.finish(runId, buf);
+      }, "fail")
+    };
+  }
+  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 resolve = /* @__PURE__ */ __name(() => {
+      }, "resolve");
+      const opened = new Promise((r) => {
+        resolve = r;
+      });
+      waiters.add(resolve);
+      try {
+        if (!await untilAborted(opened, signal)) {
+          return;
+        }
+      } finally {
+        waiters.delete(resolve);
+        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) {
+        const chunk = buf.chunks[index];
+        index += 1;
+        if (chunk !== void 0) {
+          yield chunk;
+        }
+      }
+      if (buf.ended) {
+        if (buf.failure !== void 0) {
+          throw new AgentStreamError(buf.failure);
+        }
+        return;
+      }
+      const current = buf;
+      let resolve = /* @__PURE__ */ __name(() => {
+      }, "resolve");
+      const woken = new Promise((r) => {
+        resolve = r;
+      });
+      current.notify.add(resolve);
+      try {
+        if (!await untilAborted(woken, signal)) {
+          return;
+        }
+      } finally {
+        current.notify.delete(resolve);
+      }
+    }
+  }
+  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((resolve) => {
+    onAbort = /* @__PURE__ */ __name(() => resolve(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/workflows/workflows-agent-runner.ts
+function _ts_decorate3(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") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
+function _ts_metadata3(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata3, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+var ENDED = /* @__PURE__ */ new Set([
+  "completed",
+  "failed",
+  "cancelled",
+  "compensation_failed"
+]);
+function recorded(input) {
+  return typeof input === "object" && input !== null ? input : {};
+}
+__name(recorded, "recorded");
+function deliveryOf(input) {
+  const { deliverTo, agentName } = recorded(input);
+  if (typeof deliverTo !== "object" || deliverTo === null || typeof deliverTo.threadId !== "string" || typeof deliverTo.toolCallId !== "string") {
+    return void 0;
+  }
+  return {
+    delivery: deliverTo,
+    agent: typeof agentName === "string" ? agentName : "default"
+  };
+}
+__name(deliveryOf, "deliveryOf");
+function runContextOf(input) {
+  const { actor, agentName, parentRunId } = recorded(input);
+  if (typeof actor?.id !== "string") return void 0;
+  return {
+    actorId: actor.id,
+    ...typeof agentName === "string" ? {
+      agentName
+    } : {},
+    ...typeof actor.tenantRef === "string" ? {
+      tenantRef: actor.tenantRef
+    } : {},
+    ...typeof parentRunId === "string" ? {
+      parentRunId
+    } : {}
+  };
+}
+__name(runContextOf, "runContextOf");
+var WorkflowsAgentRunner = class _WorkflowsAgentRunner {
+  static {
+    __name(this, "WorkflowsAgentRunner");
+  }
+  store;
+  sink;
+  queue;
+  logger = new Logger2(_WorkflowsAgentRunner.name);
+  client;
+  constructor(store, sink, client, queue) {
+    this.store = store;
+    this.sink = sink;
+    this.queue = queue;
+    if (client === void 0) {
+      throw new Error("AgentWorkflowsModule runs turns on @nestjs/workflows: import WorkflowsModule.forRoot() from '@nestjs/workflows' (WorkflowsModule.forRoot({ worker: false }) on a process that must not run turns, such as an API pod). No WorkflowClient was found.");
+    }
+    this.client = client;
+    if (this.sink instanceof InProcessTokenStreamSink) {
+      this.logger.warn("durable turns with the default InProcessTokenStreamSink, which only buffers tokens in this process: fine while this process runs the workflow worker, but a turn claimed by another process cannot stream to this one. Wire a cross-process TokenStreamSink (e.g. the Redis one) before running several processes.");
+    }
+  }
+  async start(input, options = {}) {
+    const stamped = {
+      ...input,
+      day: input.day ?? utcDay()
+    };
+    const runId = options.runId ?? randomUUID();
+    await this.client.start(AgentRunFlow, stamped, {
+      id: runId
+    });
+    return {
+      runId
+    };
+  }
+  /** Not ended as far as the engine knows. An unknown run counts as running, and so does one it can't be asked about. */
+  async isRunActive(runId) {
+    try {
+      const status = (await this.client.getStatus(runId))?.status;
+      return status === void 0 || !ENDED.has(status);
+    } catch {
+      return true;
+    }
+  }
+  async signal(runId, toolCallId, reply) {
+    const key = replyKey(runId, toolCallId);
+    await this.client.signal(AGENT_REPLY, reply, {
+      key,
+      id: key
+    });
+  }
+  /** The engine's view of a run: status, custom status, waits, children. `null` for an unknown id. */
+  getStatus(runId) {
+    return this.client.getStatus(runId, {
+      children: true
+    });
+  }
+  /**
+  * The calls of run `runId` waiting for a person now, in the instance it started in, in the
+  * instances it went on in, and in the sub-agent runs it delegated to.
+  */
+  async pendingReplies(runId) {
+    const found = [];
+    const visit = /* @__PURE__ */ __name(async (id) => {
+      const details = await this.client.getStatus(id, {
+        children: true
+      });
+      if (details === null) return;
+      const status = details.customStatus;
+      found.push(...status?.pendingReplies ?? []);
+      for (const child of details.children ?? []) {
+        if (!ENDED.has(child.status) && child.parentClose !== "abandon") await visit(child.id);
+      }
+    }, "visit");
+    await visit(runId);
+    return found;
+  }
+  /**
+  * Stop a run: the engine stops the turn at its next `ctx` call (a parked turn at once), and
+  * cancels the sub-agent runs it is waiting on. What the engine knows nothing about is settled
+  * here, as on the `aviary` engine: the delegation a detached run answers, the thread's queue and
+  * live stream, the subscriber's stream (a `cancelled` frame and a normal end), the run's row.
+  */
+  async cancel(runId) {
+    this.logger.log(`cancelling agent run ${runId}`);
+    const details = await this.client.getStatus(runId).catch(() => null);
+    const input = details?.input;
+    const { threadId, sinkRunId, deliverTo } = recorded(input);
+    try {
+      await this.client.cancel(runId, "Stopped");
+    } catch (error) {
+      if (!(error instanceof WorkflowNotFoundError)) throw error;
+    }
+    const target = deliveryOf(input);
+    if (target !== void 0) {
+      await settleUnsettledDelegation2({
+        store: this.store,
+        delivery: target.delivery,
+        agent: target.agent,
+        runId,
+        status: "cancelled"
+      }).catch((error) => this.logger.error(`could not settle the delegation of cancelled run ${runId}: ${error instanceof Error ? error.message : String(error)}`));
+    }
+    const writer = await this.sink.open(runId);
+    if (typeof threadId === "string") {
+      const threadTurn = sinkRunId === void 0 && deliverTo === void 0;
+      if (this.queue?.supported === true && threadTurn) {
+        try {
+          const frame = await this.queue.handoff({
+            threadId,
+            runId,
+            outcome: "cancelled"
+          }, (next, nextRunId) => this.start(next, {
+            runId: nextRunId
+          }));
+          if (frame !== void 0) await writer.write(encodeStreamEvent3(frame));
+        } catch (error) {
+          this.logger.error(`could not advance the queue of thread ${threadId} after cancelling ${runId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      await releaseThreadRun2(this.store, threadId, runId);
+    }
+    await writer.write(encodeStreamEvent3({
+      kind: "cancelled"
+    }));
+    await writer.end();
+    const durationMs = details !== null && details !== void 0 ? Math.max(0, details.updatedAt - details.createdAt) : void 0;
+    const context = runContextOf(input);
+    publishAgentRunCancelled({
+      runId,
+      ...typeof threadId === "string" ? {
+        threadId
+      } : {},
+      ...durationMs !== void 0 ? {
+        durationMs
+      } : {},
+      ...context !== void 0 ? {
+        context
+      } : {}
+    });
+    await this.store.recordRunEnd?.({
+      runId,
+      status: "cancelled",
+      ...durationMs !== void 0 ? {
+        durationMs
+      } : {}
+    });
+  }
+};
+WorkflowsAgentRunner = _ts_decorate3([
+  Injectable2(),
+  _ts_param2(0, Inject2(AGENT_STORE2)),
+  _ts_param2(1, Inject2(AGENT_SINK)),
+  _ts_param2(2, Optional2()),
+  _ts_param2(3, Optional2()),
+  _ts_param2(3, Inject2(AGENT_CHAT_QUEUE)),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof AgentStore === "undefined" ? Object : AgentStore,
+    typeof TokenStreamSink === "undefined" ? Object : TokenStreamSink,
+    typeof WorkflowClient2 === "undefined" ? Object : WorkflowClient2,
+    typeof ChatQueueService === "undefined" ? Object : ChatQueueService
+  ])
+], WorkflowsAgentRunner);
+
+// src/workflows/agent-workflows.module.ts
+function _ts_decorate4(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") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate4, "_ts_decorate");
+var AgentWorkflowsModule = class {
+  static {
+    __name(this, "AgentWorkflowsModule");
+  }
+};
+AgentWorkflowsModule = _ts_decorate4([
+  Global(),
+  Module({
+    providers: [
+      AgentTurnExecutor,
+      AgentRunFlow,
+      AgentRunSegmentFlow,
+      WorkflowsAgentRunner,
+      {
+        provide: AGENT_WORKFLOWS_RUNNER,
+        useExisting: WorkflowsAgentRunner
+      }
+    ],
+    exports: [
+      AGENT_WORKFLOWS_RUNNER,
+      WorkflowsAgentRunner
+    ]
+  })
+], AgentWorkflowsModule);
+export {
+  AGENT_REPLY,
+  AGENT_RUN_SEGMENT_WORKFLOW,
+  AGENT_RUN_WORKFLOW,
+  AgentRunFlow,
+  AgentRunSegmentFlow,
+  AgentWorkflowsModule,
+  WorkflowsAgentRunner,
+  replyKey
+};
+//# sourceMappingURL=index.js.map