@cuylabs/agent-runtime-dapr 0.9.0 → 0.10.0

package/dist/chunk-YS2CWYBQ.js

@@ -0,0 +1,1358 @@
+import {
+  DaprSidecarClient
+} from "./chunk-MQJ4LZOX.js";
+
+// src/workflow/types.ts
+var TERMINAL_DAPR_WORKFLOW_STATUSES = /* @__PURE__ */ new Set([
+  "COMPLETED",
+  "FAILED",
+  "TERMINATED"
+]);
+function isTerminalDaprWorkflowStatus(status) {
+  return TERMINAL_DAPR_WORKFLOW_STATUSES.has(status);
+}
+function hasStartedDaprWorkflow(status) {
+  return status !== "PENDING";
+}
+
+// src/workflow/client.ts
+var DEFAULT_WORKFLOW_API_VERSION = "v1.0";
+var DEFAULT_WORKFLOW_POLL_INTERVAL_MS = 1e3;
+var MIN_WORKFLOW_POLL_INTERVAL_MS = 50;
+var DEFAULT_WORKFLOW_WAIT_TIMEOUT_MS = 6e4;
+function ensureNonEmpty(input, label) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    throw new Error(`${label} must not be empty`);
+  }
+  return trimmed;
+}
+function normalizePollInterval(input) {
+  if (input === void 0) {
+    return DEFAULT_WORKFLOW_POLL_INTERVAL_MS;
+  }
+  if (!Number.isFinite(input)) {
+    throw new Error("workflowPollIntervalMs must be a finite number");
+  }
+  return Math.max(MIN_WORKFLOW_POLL_INTERVAL_MS, Math.floor(input));
+}
+function normalizeTimeout(input) {
+  if (input === void 0) {
+    return DEFAULT_WORKFLOW_WAIT_TIMEOUT_MS;
+  }
+  if (!Number.isFinite(input)) {
+    throw new Error("timeoutMs must be a finite number");
+  }
+  return Math.max(0, Math.floor(input));
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function serializeWorkflowBody(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  return JSON.stringify(value);
+}
+function normalizeWorkflowState(payload) {
+  return {
+    instanceId: payload.instanceId ?? payload.instanceID ?? "",
+    workflowName: payload.workflowName ?? "",
+    createdAt: payload.createdAt,
+    lastUpdatedAt: payload.lastUpdatedAt,
+    runtimeStatus: payload.runtimeStatus ?? "PENDING",
+    properties: payload.properties ?? {}
+  };
+}
+var DaprWorkflowClient = class {
+  client;
+  workflowComponent;
+  workflowApiVersion;
+  workflowPollIntervalMs;
+  constructor(options) {
+    this.client = new DaprSidecarClient(options);
+    this.workflowComponent = ensureNonEmpty(
+      options.workflowComponent,
+      "workflowComponent"
+    );
+    this.workflowApiVersion = options.workflowApiVersion ?? DEFAULT_WORKFLOW_API_VERSION;
+    this.workflowPollIntervalMs = normalizePollInterval(
+      options.workflowPollIntervalMs
+    );
+  }
+  async verifySidecar() {
+    await this.client.verifySidecar();
+  }
+  async startWorkflow(workflowName, options = {}) {
+    const normalizedWorkflowName = ensureNonEmpty(workflowName, "workflowName");
+    const query = options.instanceId ? `?instanceID=${encodeURIComponent(options.instanceId)}` : "";
+    const payload = serializeWorkflowBody(options.input);
+    const response = await this.client.requestJson(
+      `/${this.workflowApiVersion}/workflows/${encodeURIComponent(this.workflowComponent)}/${encodeURIComponent(normalizedWorkflowName)}/start${query}`,
+      {
+        method: "POST",
+        ...payload !== void 0 ? { body: payload } : {}
+      },
+      [202]
+    );
+    const instanceId = response?.instanceId ?? response?.instanceID ?? options.instanceId;
+    if (!instanceId) {
+      throw new Error(
+        `Dapr workflow start did not return an instanceId for workflow '${normalizedWorkflowName}'`
+      );
+    }
+    return { instanceId };
+  }
+  async getWorkflow(instanceId) {
+    const normalizedInstanceId = ensureNonEmpty(instanceId, "instanceId");
+    const response = await this.client.requestJson(
+      `/${this.workflowApiVersion}/workflows/${encodeURIComponent(this.workflowComponent)}/${encodeURIComponent(normalizedInstanceId)}`,
+      { method: "GET" },
+      [200, 404]
+    );
+    if (!response) {
+      return void 0;
+    }
+    if (response.errorCode) {
+      return void 0;
+    }
+    if (!response.instanceId && !response.instanceID && !response.workflowName && !response.runtimeStatus) {
+      return void 0;
+    }
+    return normalizeWorkflowState(response);
+  }
+  async waitForWorkflowStart(instanceId, options = {}) {
+    return this.waitForWorkflowState(instanceId, {
+      ...options,
+      predicate: (state) => hasStartedDaprWorkflow(state.runtimeStatus)
+    });
+  }
+  async waitForWorkflowCompletion(instanceId, options = {}) {
+    return this.waitForWorkflowState(instanceId, {
+      ...options,
+      predicate: (state) => isTerminalDaprWorkflowStatus(state.runtimeStatus)
+    });
+  }
+  async pauseWorkflow(instanceId) {
+    await this.controlWorkflow(instanceId, "pause");
+  }
+  async resumeWorkflow(instanceId) {
+    await this.controlWorkflow(instanceId, "resume");
+  }
+  async terminateWorkflow(instanceId) {
+    await this.controlWorkflow(instanceId, "terminate");
+  }
+  async purgeWorkflow(instanceId) {
+    await this.controlWorkflow(instanceId, "purge");
+  }
+  async raiseWorkflowEvent(instanceId, eventName, options = {}) {
+    const normalizedInstanceId = ensureNonEmpty(instanceId, "instanceId");
+    const normalizedEventName = ensureNonEmpty(eventName, "eventName");
+    const payload = serializeWorkflowBody(options.eventData);
+    await this.client.request(
+      `/${this.workflowApiVersion}/workflows/${encodeURIComponent(this.workflowComponent)}/${encodeURIComponent(normalizedInstanceId)}/raiseEvent/${encodeURIComponent(normalizedEventName)}`,
+      {
+        method: "POST",
+        ...payload !== void 0 ? { body: payload } : {}
+      },
+      [202]
+    );
+  }
+  async controlWorkflow(instanceId, action) {
+    const normalizedInstanceId = ensureNonEmpty(instanceId, "instanceId");
+    await this.client.request(
+      `/${this.workflowApiVersion}/workflows/${encodeURIComponent(this.workflowComponent)}/${encodeURIComponent(normalizedInstanceId)}/${action}`,
+      { method: "POST" },
+      [202]
+    );
+  }
+  async waitForWorkflowState(instanceId, options) {
+    const timeoutMs = normalizeTimeout(options.timeoutMs);
+    const pollIntervalMs = normalizePollInterval(
+      options.pollIntervalMs ?? this.workflowPollIntervalMs
+    );
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() <= deadline) {
+      const state = await this.getWorkflow(instanceId);
+      if (state && options.predicate(state)) {
+        return state;
+      }
+      if (Date.now() >= deadline) {
+        break;
+      }
+      await sleep(pollIntervalMs);
+    }
+    return void 0;
+  }
+};
+
+// src/workflow/runtime-activities.ts
+import {
+  advanceAgentTurnState,
+  convertAgentMessagesToModelMessages,
+  createAgentTurnEngine,
+  createAgentTurnStepCommitBatch,
+  executeAgentToolCall,
+  normalizeToolReplayPolicy,
+  prepareModelStep,
+  restoreAgentWorkflowMessages,
+  runModelStep,
+  snapshotAgentWorkflowMessages
+} from "@cuylabs/agent-core";
+function normalizeError(error) {
+  if (error instanceof Error) return error;
+  if (typeof error === "string") return new Error(error);
+  if (error && typeof error === "object") {
+    if ("message" in error && typeof error.message === "string") {
+      return new Error(error.message);
+    }
+    try {
+      return new Error(JSON.stringify(error));
+    } catch {
+    }
+  }
+  return new Error(String(error));
+}
+function resolveOption(value) {
+  return typeof value === "function" ? value() : value;
+}
+async function* emptyCommitApplier() {
+  yield* [];
+}
+function createDaprAgentTurnSteerDrainActivity(options) {
+  return {
+    name: "steer-drain",
+    handler: async (_context, input) => options.drain(input)
+  };
+}
+async function withObserverContext(bridge, sessionId, fn) {
+  const parentCtx = bridge?.getOtelContext(sessionId);
+  if (!parentCtx) return fn();
+  try {
+    const otelApi = await import("@opentelemetry/api");
+    return await otelApi.context.with(
+      parentCtx,
+      fn
+    );
+  } catch {
+    return fn();
+  }
+}
+function createDaprAgentTurnModelStepActivity(options) {
+  const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  return {
+    name: "model-step",
+    handler: async (_context, plan) => {
+      const runActivity = async () => {
+        const runtime = resolveOption(options.runtime);
+        const tools = resolveOption(options.tools);
+        const host = options.host ? resolveOption(options.host) : void 0;
+        const middleware = options.middleware ? resolveOption(options.middleware) : void 0;
+        const reasoningLevel = options.reasoningLevel ? resolveOption(options.reasoningLevel) : void 0;
+        if (middleware?.hasMiddleware) {
+          await middleware.runChatStart(
+            plan.sessionId,
+            `[workflow model-step ${plan.step}]`
+          );
+        }
+        let stepResult;
+        let stepError;
+        try {
+          const systemPrompts = options.resolveSystemPrompts ? await options.resolveSystemPrompts(
+            plan.sessionId,
+            plan.systemPrompts
+          ) : plan.systemPrompts;
+          const restoredMessages = restoreAgentWorkflowMessages(plan.messages);
+          const turnEngine = createAgentTurnEngine({
+            sessionId: plan.sessionId,
+            startedAt: now(),
+            getToolReplayPolicy: (toolName) => tools[toolName]?.replayPolicy ? normalizeToolReplayPolicy(tools[toolName].replayPolicy) : void 0
+          });
+          const preparedStep = prepareModelStep({
+            sessionId: plan.sessionId,
+            step: plan.step,
+            systemPrompts,
+            messages: restoredMessages,
+            toModelMessages: options.toModelMessages ?? convertAgentMessagesToModelMessages,
+            abort: options.createAbortSignal?.() ?? new AbortController().signal,
+            tools,
+            mcpTools: typeof options.mcpTools === "function" ? await options.mcpTools() : options.mcpTools,
+            config: runtime,
+            ...host ? { host } : {},
+            ...options.turnTracker ? { turnTracker: options.turnTracker } : {},
+            ...middleware ? { middleware } : {},
+            ...reasoningLevel ? { reasoningLevel } : {},
+            toolExecutionMode: "plan"
+          });
+          const iterator = runModelStep({
+            preparedStep,
+            turnEngine,
+            applyCommitBatch: () => emptyCommitApplier()
+          });
+          while (true) {
+            const item = await iterator.next();
+            if (item.done) {
+              const stepCommit = turnEngine.createStepCommitSnapshot();
+              stepResult = {
+                text: item.value.text,
+                ...item.value.usage ? { usage: item.value.usage } : {},
+                ...item.value.finishReason ? { finishReason: item.value.finishReason } : {},
+                turnState: turnEngine.getState(),
+                ...stepCommit ? { stepCommit } : {}
+              };
+              break;
+            }
+            if (options.onEvent) {
+              await options.onEvent(plan.sessionId, item.value);
+            }
+          }
+        } catch (err) {
+          stepError = normalizeError(err);
+        }
+        if (middleware?.hasMiddleware) {
+          await middleware.runChatEnd(plan.sessionId, {
+            usage: stepResult?.usage,
+            error: stepError,
+            output: stepResult?.text
+          });
+        }
+        if (stepError) throw stepError;
+        return stepResult;
+      };
+      return withObserverContext(
+        options.observerBridge,
+        plan.sessionId,
+        runActivity
+      );
+    }
+  };
+}
+function createDaprAgentTurnToolCallActivity(options) {
+  const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  return {
+    name: "tool-call",
+    handler: async (_context, plan) => {
+      const runActivity = async () => {
+        const tools = resolveOption(options.tools);
+        const host = options.host ? resolveOption(options.host) : void 0;
+        const middleware = options.middleware ? resolveOption(options.middleware) : void 0;
+        if (plan.replayDecision?.action === "skip") {
+          throw new Error(
+            `Tool call '${plan.toolCall.toolCallId}' cannot be skipped without a persisted result`
+          );
+        }
+        const updatedAt = now();
+        const tool = tools[plan.toolCall.toolName];
+        if (!tool) {
+          const event = {
+            type: "tool-error",
+            toolName: plan.toolCall.toolName,
+            toolCallId: plan.toolCall.toolCallId,
+            error: `Tool '${plan.toolCall.toolName}' is not registered`
+          };
+          return {
+            toolResult: {
+              toolCallId: plan.toolCall.toolCallId,
+              toolName: plan.toolCall.toolName,
+              result: `Error: Tool '${plan.toolCall.toolName}' is not registered`,
+              ...plan.toolCall.replayPolicy ? { replayPolicy: plan.toolCall.replayPolicy } : {}
+            },
+            ...plan.turnState ? {
+              turnState: advanceAgentTurnState(
+                plan.turnState,
+                event,
+                updatedAt,
+                {
+                  ...plan.toolCall.replayPolicy ? { toolReplayPolicy: plan.toolCall.replayPolicy } : {}
+                }
+              )
+            } : {}
+          };
+        }
+        try {
+          const executed = await executeAgentToolCall({
+            toolName: plan.toolCall.toolName,
+            tool,
+            params: plan.toolCall.args,
+            cwd: options.cwd,
+            abort: options.createAbortSignal?.() ?? new AbortController().signal,
+            sessionID: plan.sessionId,
+            messageID: plan.toolCall.toolCallId,
+            ...host ? { host } : {},
+            ...options.turnTracker ? { turnTracker: options.turnTracker } : {},
+            ...middleware ? { middleware } : {}
+          });
+          const event = {
+            type: "tool-result",
+            toolName: plan.toolCall.toolName,
+            toolCallId: plan.toolCall.toolCallId,
+            result: executed.output
+          };
+          return {
+            toolResult: {
+              toolCallId: plan.toolCall.toolCallId,
+              toolName: plan.toolCall.toolName,
+              result: executed.output,
+              ...plan.toolCall.replayPolicy ? { replayPolicy: plan.toolCall.replayPolicy } : {}
+            },
+            ...plan.turnState ? {
+              turnState: advanceAgentTurnState(
+                plan.turnState,
+                event,
+                updatedAt,
+                {
+                  ...plan.toolCall.replayPolicy ? { toolReplayPolicy: plan.toolCall.replayPolicy } : {}
+                }
+              )
+            } : {}
+          };
+        } catch (error) {
+          const message = normalizeError(error).message;
+          const event = {
+            type: "tool-error",
+            toolName: plan.toolCall.toolName,
+            toolCallId: plan.toolCall.toolCallId,
+            error: message
+          };
+          return {
+            toolResult: {
+              toolCallId: plan.toolCall.toolCallId,
+              toolName: plan.toolCall.toolName,
+              result: `Error: ${message}`,
+              ...plan.toolCall.replayPolicy ? { replayPolicy: plan.toolCall.replayPolicy } : {}
+            },
+            ...plan.turnState ? {
+              turnState: advanceAgentTurnState(
+                plan.turnState,
+                event,
+                updatedAt,
+                {
+                  ...plan.toolCall.replayPolicy ? { toolReplayPolicy: plan.toolCall.replayPolicy } : {}
+                }
+              )
+            } : {}
+          };
+        }
+      };
+      return withObserverContext(
+        options.observerBridge,
+        plan.sessionId,
+        runActivity
+      );
+    }
+  };
+}
+function createDaprAgentTurnApprovalCheckActivity(options) {
+  return {
+    name: "approval-check",
+    handler: async (_context, input) => await options.check(input)
+  };
+}
+function createDaprAgentTurnHumanInputCheckActivity(options) {
+  return {
+    name: "human-input-check",
+    handler: async (_context, input) => await options.check(input)
+  };
+}
+function createDaprAgentTurnStepCommitActivity(options) {
+  return {
+    name: "step-commit",
+    handler: async (_context, plan) => {
+      if (plan.kind === "input-commit") {
+        const messages = restoreAgentWorkflowMessages(plan.messages);
+        await options.persistMessages(plan.sessionId, messages);
+        return {
+          messages: plan.messages.map((message) => structuredClone(message))
+        };
+      }
+      const batch = createAgentTurnStepCommitBatch(plan.step, plan.snapshot);
+      if (!batch) {
+        return { messages: [] };
+      }
+      await options.persistMessages(plan.sessionId, batch.messages);
+      return { messages: snapshotAgentWorkflowMessages(batch.messages) };
+    }
+  };
+}
+function createDaprAgentTurnOutputCommitActivity(options) {
+  const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  return {
+    name: "output-commit",
+    handler: async (_context, plan) => {
+      const turnEngine = createAgentTurnEngine({
+        sessionId: plan.sessionId,
+        startedAt: now()
+      });
+      const batch = turnEngine.createOutputCommit({
+        text: plan.text,
+        usage: plan.usage
+      });
+      if (!batch) {
+        return { messages: [] };
+      }
+      await options.persistMessages(plan.sessionId, batch.messages);
+      return { messages: snapshotAgentWorkflowMessages(batch.messages) };
+    }
+  };
+}
+
+// src/workflow/runtime.ts
+import {
+  advanceAgentTurnState as advanceAgentTurnState2,
+  applyWorkflowInterventions,
+  applyAgentWorkflowCommitResult,
+  applyAgentWorkflowModelStepResult,
+  applyAgentWorkflowToolCallResult,
+  createApprovalCorrection,
+  failAgentWorkflowTurnState,
+  formatApprovalDeniedReason,
+  planNextAgentWorkflowOperation,
+  recordAgentWorkflowReplayDecision
+} from "@cuylabs/agent-core";
+var MAX_CONTROL_EVENTS_PER_BOUNDARY = 32;
+var DEFAULT_WORKFLOW_NAME = "agent-turn";
+function defaultActivityNames(workflowName, overrides = {}, options = {}) {
+  return {
+    ...options.includeSteerDrain || overrides.steerDrain ? {
+      steerDrain: overrides.steerDrain ?? `${workflowName}:steer-drain`
+    } : {},
+    modelStep: overrides.modelStep ?? `${workflowName}:model-step`,
+    ...options.includeHumanInputCheck || overrides.humanInputCheck ? {
+      humanInputCheck: overrides.humanInputCheck ?? `${workflowName}:human-input-check`
+    } : {},
+    ...options.includeApprovalCheck || overrides.approvalCheck ? {
+      approvalCheck: overrides.approvalCheck ?? `${workflowName}:approval-check`
+    } : {},
+    toolCall: overrides.toolCall ?? `${workflowName}:tool-call`,
+    stepCommit: overrides.stepCommit ?? `${workflowName}:step-commit`,
+    outputCommit: overrides.outputCommit ?? `${workflowName}:output-commit`
+  };
+}
+function normalizeError2(error) {
+  if (error instanceof Error) return error;
+  if (typeof error === "string") return new Error(error);
+  if (error && typeof error === "object") {
+    if ("message" in error && typeof error.message === "string") {
+      return new Error(error.message);
+    }
+    try {
+      return new Error(JSON.stringify(error));
+    } catch {
+    }
+  }
+  return new Error(String(error));
+}
+function renameActivity(activity, name) {
+  return {
+    name,
+    handler: activity.handler
+  };
+}
+function summarizeWorkflowState(state) {
+  return JSON.stringify({
+    sessionId: state.sessionId,
+    phase: state.phase,
+    step: state.step,
+    finalResponse: state.finalResponse,
+    error: state.error
+  });
+}
+function ensureReplayDecision(state, plan, now) {
+  if (plan.replayDecision) {
+    return { state, decision: plan.replayDecision };
+  }
+  const mode = plan.toolCall.replayPolicy?.mode;
+  if (!mode) {
+    return { state };
+  }
+  if (mode === "manual") {
+    const decision2 = {
+      toolCallId: plan.toolCall.toolCallId,
+      toolName: plan.toolCall.toolName,
+      action: "replay",
+      source: "runtime",
+      decidedAt: now,
+      reason: "auto-decided by Dapr workflow runtime (activity-level checkpoint)"
+    };
+    return {
+      state: recordAgentWorkflowReplayDecision(state, decision2, now),
+      decision: decision2
+    };
+  }
+  const decision = {
+    toolCallId: plan.toolCall.toolCallId,
+    toolName: plan.toolCall.toolName,
+    action: mode === "skip" ? "skip" : "replay",
+    source: "policy",
+    decidedAt: now,
+    ...plan.toolCall.replayPolicy?.reason ? { reason: plan.toolCall.replayPolicy.reason } : {}
+  };
+  return {
+    state: recordAgentWorkflowReplayDecision(state, decision, now),
+    decision
+  };
+}
+function extractApprovalDecision(value) {
+  if (value === "allow" || value === "deny" || value === "remember") {
+    return { action: value };
+  }
+  if (value && typeof value === "object" && "action" in value && (value.action === "allow" || value.action === "deny" || value.action === "remember")) {
+    const decision = value;
+    return {
+      action: decision.action,
+      ...typeof decision.feedback === "string" ? { feedback: decision.feedback } : {},
+      ...decision.rememberScope === "session" || decision.rememberScope === "project" || decision.rememberScope === "user" ? { rememberScope: decision.rememberScope } : {}
+    };
+  }
+  throw new Error("Approval decision event is missing a valid action");
+}
+function extractHumanInputResponse(value) {
+  if (value && typeof value === "object" && "kind" in value && typeof value.kind === "string" && "text" in value && typeof value.text === "string") {
+    const response = value;
+    if (response.kind === "text") {
+      return response;
+    }
+    if (response.kind === "confirm" && "confirmed" in response) {
+      return response;
+    }
+    if (response.kind === "choice" && "selected" in response && Array.isArray(response.selected)) {
+      return response;
+    }
+  }
+  throw new Error("Human input response event is missing a valid response");
+}
+function createDeniedToolCallResult(plan, reason, updatedAt, feedback) {
+  const resultText = reason || formatApprovalDeniedReason(plan.toolCall.toolName);
+  const correction = createApprovalCorrection(
+    plan.toolCall.toolName,
+    feedback
+  );
+  const toolResult = {
+    toolCallId: plan.toolCall.toolCallId,
+    toolName: plan.toolCall.toolName,
+    result: resultText,
+    metadata: {
+      approvalCorrection: correction
+    },
+    ...plan.toolCall.replayPolicy ? { replayPolicy: plan.toolCall.replayPolicy } : {}
+  };
+  if (!plan.turnState) {
+    return { toolResult };
+  }
+  return {
+    toolResult,
+    turnState: advanceAgentTurnState2(
+      plan.turnState,
+      {
+        type: "tool-result",
+        toolName: plan.toolCall.toolName,
+        toolCallId: plan.toolCall.toolCallId,
+        result: resultText,
+        metadata: {
+          approvalCorrection: correction
+        }
+      },
+      updatedAt,
+      {
+        ...plan.toolCall.replayPolicy ? { toolReplayPolicy: plan.toolCall.replayPolicy } : {}
+      }
+    )
+  };
+}
+function createHumanInputToolCallResult(plan, response, updatedAt) {
+  const resultText = response.text;
+  const toolResult = {
+    toolCallId: plan.toolCall.toolCallId,
+    toolName: plan.toolCall.toolName,
+    result: resultText,
+    ...plan.toolCall.replayPolicy ? { replayPolicy: plan.toolCall.replayPolicy } : {}
+  };
+  if (!plan.turnState) {
+    return { toolResult };
+  }
+  return {
+    toolResult,
+    turnState: advanceAgentTurnState2(
+      plan.turnState,
+      {
+        type: "tool-result",
+        toolName: plan.toolCall.toolName,
+        toolCallId: plan.toolCall.toolCallId,
+        result: resultText
+      },
+      updatedAt,
+      {
+        ...plan.toolCall.replayPolicy ? { toolReplayPolicy: plan.toolCall.replayPolicy } : {}
+      }
+    )
+  };
+}
+function normalizeSteerSnapshots(payload) {
+  if (!Array.isArray(payload)) {
+    return [];
+  }
+  return payload.flatMap((candidate) => {
+    if (!candidate || typeof candidate !== "object") {
+      return [];
+    }
+    const steer = candidate;
+    if (typeof steer.id !== "string" || !steer.id.trim() || typeof steer.message !== "string" || !steer.message.trim() || typeof steer.createdAt !== "string" || !steer.createdAt.trim()) {
+      return [];
+    }
+    return [{
+      id: steer.id.trim(),
+      message: steer.message.trim(),
+      createdAt: steer.createdAt.trim()
+    }];
+  });
+}
+var EXTERNAL_EVENT_TIMEOUT = /* @__PURE__ */ Symbol("EXTERNAL_EVENT_TIMEOUT");
+function* waitForExternalEventWithTimeout(context, eventName, timeoutMs) {
+  if (!context.waitForExternalEvent) {
+    throw new Error(
+      "Workflow context does not support waitForExternalEvent"
+    );
+  }
+  const eventTask = context.waitForExternalEvent(eventName);
+  if (timeoutMs && timeoutMs > 0 && context.createTimer && context.whenAny) {
+    const timerTask = context.createTimer(timeoutMs);
+    const winner = yield context.whenAny([eventTask, timerTask]);
+    if (winner === timerTask) {
+      return EXTERNAL_EVENT_TIMEOUT;
+    }
+    const eventHandle = eventTask;
+    if (typeof eventHandle.getResult === "function") {
+      return eventHandle.getResult();
+    }
+    return winner;
+  }
+  return yield eventTask;
+}
+function createDaprAgentTurnWorkflowDefinition(options) {
+  const workflowName = options.workflowName ?? DEFAULT_WORKFLOW_NAME;
+  const activityNames = defaultActivityNames(
+    workflowName,
+    options.activityNames,
+    {
+      includeSteerDrain: Boolean(options.steerDrain),
+      includeHumanInputCheck: Boolean(options.humanInputCheck),
+      includeApprovalCheck: Boolean(options.approvalCheck)
+    }
+  );
+  const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const steeringEnabled = options.steeringEnabled ?? false;
+  const continueAsNewThreshold = options.continueAsNewThreshold;
+  const workflow = async function* (context, input) {
+    const bridge = options.observerBridge;
+    let state = structuredClone(input);
+    if (!context.isReplaying?.()) {
+      await bridge?.notifyTaskStart(state);
+    }
+    try {
+      while (true) {
+        context.setCustomStatus?.(summarizeWorkflowState(state));
+        if (state.phase === "model-step" && steeringEnabled && activityNames.steerDrain && options.steerDrain) {
+          const controlEvents = normalizeSteerSnapshots(
+            yield context.callActivity(
+              activityNames.steerDrain,
+              {
+                workflowInstanceId: context.getWorkflowInstanceId?.() ?? "",
+                sessionId: state.sessionId,
+                step: state.step,
+                maxItems: MAX_CONTROL_EVENTS_PER_BOUNDARY
+              }
+            )
+          );
+          if (controlEvents.length > 0) {
+            state = applyWorkflowInterventions(state, controlEvents, now());
+            if (!context.isReplaying?.()) {
+              for (const steerEvent of controlEvents) {
+                await options.onEvent?.(state.sessionId, {
+                  type: "intervention-applied",
+                  id: steerEvent.id,
+                  message: steerEvent.message
+                });
+              }
+              await bridge?.notifyCheckpoint("intervention-commit-finish", state);
+            }
+          }
+        }
+        const plan = planNextAgentWorkflowOperation(state);
+        if (!plan) {
+          if (!context.isReplaying?.()) {
+            await bridge?.notifyTaskComplete(state);
+          }
+          return state;
+        }
+        switch (plan.kind) {
+          case "input-commit": {
+            const result = yield context.callActivity(
+              activityNames.stepCommit,
+              plan
+            );
+            state = applyAgentWorkflowCommitResult(state, result, now());
+            if (!context.isReplaying?.()) {
+              await bridge?.notifyCheckpoint("input-commit-finish", state);
+            }
+            break;
+          }
+          case "model-step": {
+            const result = yield context.callActivity(
+              activityNames.modelStep,
+              plan
+            );
+            state = applyAgentWorkflowModelStepResult(state, result, now());
+            if (!context.isReplaying?.()) {
+              await bridge?.notifyCheckpoint("step-finish", state);
+            }
+            break;
+          }
+          case "tool-call": {
+            const decisionState = ensureReplayDecision(state, plan, now());
+            state = decisionState.state;
+            if (decisionState.decision?.action === "skip") {
+              throw new Error(
+                `Cannot skip unresolved tool call '${plan.toolCall.toolCallId}' without a previously persisted tool result`
+              );
+            }
+            if (activityNames.humanInputCheck && options.humanInputCheck) {
+              const humanInput = yield context.callActivity(
+                activityNames.humanInputCheck,
+                {
+                  workflowInstanceId: context.getWorkflowInstanceId?.() ?? "",
+                  sessionId: plan.sessionId,
+                  step: plan.step,
+                  toolCall: structuredClone(plan.toolCall)
+                }
+              );
+              if (humanInput.action === "deny") {
+                state = applyAgentWorkflowToolCallResult(
+                  state,
+                  createDeniedToolCallResult(plan, humanInput.reason, now()),
+                  now()
+                );
+                if (!context.isReplaying?.()) {
+                  await bridge?.notifyCheckpoint("tool-result", state);
+                }
+                break;
+              }
+              if (humanInput.action === "request") {
+                if (!context.waitForExternalEvent) {
+                  throw new Error(
+                    "Workflow context does not support waitForExternalEvent for human input requests"
+                  );
+                }
+                context.setCustomStatus?.(
+                  JSON.stringify({
+                    sessionId: state.sessionId,
+                    phase: "waiting-input",
+                    step: state.step,
+                    toolCallId: plan.toolCall.toolCallId,
+                    request: humanInput.request
+                  })
+                );
+                const eventPayload = yield* waitForExternalEventWithTimeout(
+                  context,
+                  humanInput.eventName,
+                  options.humanInputTimeoutMs
+                );
+                if (eventPayload === EXTERNAL_EVENT_TIMEOUT) {
+                  state = applyAgentWorkflowToolCallResult(
+                    state,
+                    createDeniedToolCallResult(
+                      plan,
+                      `Human input request timed out after ${options.humanInputTimeoutMs}ms`,
+                      now()
+                    ),
+                    now()
+                  );
+                  if (!context.isReplaying?.()) {
+                    await bridge?.notifyCheckpoint("tool-result", state);
+                  }
+                  break;
+                }
+                const response = extractHumanInputResponse(eventPayload);
+                state = applyAgentWorkflowToolCallResult(
+                  state,
+                  createHumanInputToolCallResult(plan, response, now()),
+                  now()
+                );
+                if (!context.isReplaying?.()) {
+                  await bridge?.notifyCheckpoint("tool-result", state);
+                }
+                break;
+              }
+            }
+            if (activityNames.approvalCheck && options.approvalCheck) {
+              const approval = yield context.callActivity(
+                activityNames.approvalCheck,
+                {
+                  workflowInstanceId: context.getWorkflowInstanceId?.() ?? "",
+                  sessionId: plan.sessionId,
+                  step: plan.step,
+                  toolCall: structuredClone(plan.toolCall)
+                }
+              );
+              if (approval.action === "deny") {
+                state = applyAgentWorkflowToolCallResult(
+                  state,
+                  createDeniedToolCallResult(plan, approval.reason, now()),
+                  now()
+                );
+                if (!context.isReplaying?.()) {
+                  await bridge?.notifyCheckpoint("tool-result", state);
+                }
+                break;
+              }
+              if (approval.action === "request") {
+                if (!context.waitForExternalEvent) {
+                  throw new Error(
+                    "Workflow context does not support waitForExternalEvent for approval requests"
+                  );
+                }
+                context.setCustomStatus?.(
+                  JSON.stringify({
+                    sessionId: state.sessionId,
+                    phase: "waiting-approval",
+                    step: state.step,
+                    toolCallId: plan.toolCall.toolCallId,
+                    request: approval.request
+                  })
+                );
+                const eventPayload = yield* waitForExternalEventWithTimeout(
+                  context,
+                  approval.eventName,
+                  options.approvalTimeoutMs
+                );
+                if (eventPayload === EXTERNAL_EVENT_TIMEOUT) {
+                  state = applyAgentWorkflowToolCallResult(
+                    state,
+                    createDeniedToolCallResult(
+                      plan,
+                      `Approval request timed out after ${options.approvalTimeoutMs}ms`,
+                      now()
+                    ),
+                    now()
+                  );
+                  if (!context.isReplaying?.()) {
+                    await bridge?.notifyCheckpoint("tool-result", state);
+                  }
+                  break;
+                }
+                const decision = extractApprovalDecision(eventPayload);
+                if (decision.action === "deny") {
+                  state = applyAgentWorkflowToolCallResult(
+                    state,
+                    createDeniedToolCallResult(
+                      plan,
+                      formatApprovalDeniedReason(
+                        plan.toolCall.toolName,
+                        decision.feedback
+                      ),
+                      now(),
+                      decision.feedback
+                    ),
+                    now()
+                  );
+                  if (!context.isReplaying?.()) {
+                    await bridge?.notifyCheckpoint("tool-result", state);
+                  }
+                  break;
+                }
+              }
+            }
+            let handledToolCall = false;
+            for (const handler of options.workflowToolHandlers ?? []) {
+              const handled = yield* handler({
+                context,
+                plan,
+                now: now(),
+                isReplaying: context.isReplaying?.() ?? false
+              });
+              if (!handled) {
+                continue;
+              }
+              state = applyAgentWorkflowToolCallResult(state, handled, now());
+              if (!context.isReplaying?.()) {
+                await bridge?.notifyCheckpoint("tool-result", state);
+              }
+              handledToolCall = true;
+              break;
+            }
+            if (handledToolCall) {
+              break;
+            }
+            const result = yield context.callActivity(activityNames.toolCall, {
+              ...plan,
+              ...decisionState.decision ? { replayDecision: decisionState.decision } : {}
+            });
+            state = applyAgentWorkflowToolCallResult(state, result, now());
+            if (!context.isReplaying?.()) {
+              await bridge?.notifyCheckpoint("tool-result", state);
+            }
+            break;
+          }
+          case "tool-batch": {
+            const clearedToolCalls = [];
+            for (const toolCall of plan.toolCalls) {
+              const singlePlan = {
+                kind: "tool-call",
+                step: plan.step,
+                sessionId: plan.sessionId,
+                toolCall,
+                turnState: plan.turnState,
+                replayDecision: plan.replayDecisions[toolCall.toolCallId]
+              };
+              let gateHandled = false;
+              if (activityNames.humanInputCheck && options.humanInputCheck) {
+                const humanInput = yield context.callActivity(
+                  activityNames.humanInputCheck,
+                  {
+                    workflowInstanceId: context.getWorkflowInstanceId?.() ?? "",
+                    sessionId: singlePlan.sessionId,
+                    step: singlePlan.step,
+                    toolCall: structuredClone(singlePlan.toolCall)
+                  }
+                );
+                if (humanInput.action === "deny") {
+                  state = applyAgentWorkflowToolCallResult(
+                    state,
+                    createDeniedToolCallResult(
+                      singlePlan,
+                      humanInput.reason,
+                      now()
+                    ),
+                    now()
+                  );
+                  gateHandled = true;
+                }
+                if (!gateHandled && humanInput.action === "request") {
+                  if (!context.waitForExternalEvent) {
+                    throw new Error(
+                      "Workflow context does not support waitForExternalEvent for human input requests"
+                    );
+                  }
+                  context.setCustomStatus?.(
+                    JSON.stringify({
+                      sessionId: state.sessionId,
+                      phase: "waiting-input",
+                      step: state.step,
+                      toolCallId: singlePlan.toolCall.toolCallId,
+                      request: humanInput.request
+                    })
+                  );
+                  const eventPayload = yield* waitForExternalEventWithTimeout(
+                    context,
+                    humanInput.eventName,
+                    options.humanInputTimeoutMs
+                  );
+                  if (eventPayload === EXTERNAL_EVENT_TIMEOUT) {
+                    state = applyAgentWorkflowToolCallResult(
+                      state,
+                      createDeniedToolCallResult(
+                        singlePlan,
+                        `Human input request timed out after ${options.humanInputTimeoutMs}ms`,
+                        now()
+                      ),
+                      now()
+                    );
+                  } else {
+                    const response = extractHumanInputResponse(eventPayload);
+                    state = applyAgentWorkflowToolCallResult(
+                      state,
+                      createHumanInputToolCallResult(
+                        singlePlan,
+                        response,
+                        now()
+                      ),
+                      now()
+                    );
+                  }
+                  gateHandled = true;
+                }
+              }
+              if (!gateHandled && activityNames.approvalCheck && options.approvalCheck) {
+                const approval = yield context.callActivity(
+                  activityNames.approvalCheck,
+                  {
+                    workflowInstanceId: context.getWorkflowInstanceId?.() ?? "",
+                    sessionId: singlePlan.sessionId,
+                    step: singlePlan.step,
+                    toolCall: structuredClone(singlePlan.toolCall)
+                  }
+                );
+                if (approval.action === "deny") {
+                  state = applyAgentWorkflowToolCallResult(
+                    state,
+                    createDeniedToolCallResult(
+                      singlePlan,
+                      approval.reason,
+                      now()
+                    ),
+                    now()
+                  );
+                  gateHandled = true;
+                }
+                if (!gateHandled && approval.action === "request") {
+                  if (!context.waitForExternalEvent) {
+                    throw new Error(
+                      "Workflow context does not support waitForExternalEvent for approval requests"
+                    );
+                  }
+                  context.setCustomStatus?.(
+                    JSON.stringify({
+                      sessionId: state.sessionId,
+                      phase: "waiting-approval",
+                      step: state.step,
+                      toolCallId: singlePlan.toolCall.toolCallId,
+                      request: approval.request
+                    })
+                  );
+                  const eventPayload = yield* waitForExternalEventWithTimeout(
+                    context,
+                    approval.eventName,
+                    options.approvalTimeoutMs
+                  );
+                  if (eventPayload === EXTERNAL_EVENT_TIMEOUT) {
+                    state = applyAgentWorkflowToolCallResult(
+                      state,
+                      createDeniedToolCallResult(
+                        singlePlan,
+                        `Approval request timed out after ${options.approvalTimeoutMs}ms`,
+                        now()
+                      ),
+                      now()
+                    );
+                    gateHandled = true;
+                  } else {
+                    const decision = extractApprovalDecision(eventPayload);
+                    if (decision.action === "deny") {
+                      state = applyAgentWorkflowToolCallResult(
+                        state,
+                        createDeniedToolCallResult(
+                          singlePlan,
+                          formatApprovalDeniedReason(
+                            singlePlan.toolCall.toolName,
+                            decision.feedback
+                          ),
+                          now(),
+                          decision.feedback
+                        ),
+                        now()
+                      );
+                      gateHandled = true;
+                    }
+                  }
+                }
+              }
+              if (!gateHandled) {
+                clearedToolCalls.push({
+                  toolCall,
+                  replayDecision: plan.replayDecisions[toolCall.toolCallId]
+                });
+              }
+            }
+            if (clearedToolCalls.length > 0) {
+              if (context.whenAll && clearedToolCalls.length > 1) {
+                const tasks = clearedToolCalls.map(
+                  ({ toolCall, replayDecision }) => context.callActivity(activityNames.toolCall, {
+                    kind: "tool-call",
+                    step: plan.step,
+                    sessionId: plan.sessionId,
+                    toolCall,
+                    turnState: plan.turnState,
+                    ...replayDecision ? { replayDecision } : {}
+                  })
+                );
+                const results = yield context.whenAll(
+                  tasks
+                );
+                for (const result of results) {
+                  state = applyAgentWorkflowToolCallResult(
+                    state,
+                    result,
+                    now()
+                  );
+                }
+              } else {
+                for (const { toolCall, replayDecision } of clearedToolCalls) {
+                  const result = yield context.callActivity(
+                    activityNames.toolCall,
+                    {
+                      kind: "tool-call",
+                      step: plan.step,
+                      sessionId: plan.sessionId,
+                      toolCall,
+                      turnState: plan.turnState,
+                      ...replayDecision ? { replayDecision } : {}
+                    }
+                  );
+                  state = applyAgentWorkflowToolCallResult(
+                    state,
+                    result,
+                    now()
+                  );
+                }
+              }
+            }
+            if (!context.isReplaying?.()) {
+              await bridge?.notifyCheckpoint("tool-result", state);
+            }
+            break;
+          }
+          case "step-commit": {
+            const result = yield context.callActivity(
+              activityNames.stepCommit,
+              plan
+            );
+            state = applyAgentWorkflowCommitResult(state, result, now());
+            if (!context.isReplaying?.()) {
+              await bridge?.notifyCheckpoint("step-commit-finish", state);
+            }
+            if (continueAsNewThreshold && state.step > 0 && state.step % continueAsNewThreshold === 0 && context.continueAsNew) {
+              context.continueAsNew(
+                state,
+                /* preserveUnprocessedEvents */
+                true
+              );
+            }
+            break;
+          }
+          case "output-commit": {
+            const result = yield context.callActivity(
+              activityNames.outputCommit,
+              plan
+            );
+            state = applyAgentWorkflowCommitResult(state, result, now());
+            if (!context.isReplaying?.()) {
+              await bridge?.notifyCheckpoint("output-commit-finish", state);
+            }
+            break;
+          }
+        }
+      }
+    } catch (error) {
+      const normalized = normalizeError2(error);
+      state = failAgentWorkflowTurnState(state, normalized, now());
+      context.setCustomStatus?.(summarizeWorkflowState(state));
+      if (!context.isReplaying?.()) {
+        await bridge?.notifyTaskError(state, normalized);
+      }
+      throw normalized;
+    }
+  };
+  return {
+    workflowName,
+    activityNames,
+    workflow
+  };
+}
+function createDaprAgentTurnWorkflowKit(options) {
+  const getBridge = () => options.observerBridge;
+  const steerDrainActivity = options.steerDrainActivity ? createDaprAgentTurnSteerDrainActivity(options.steerDrainActivity) : void 0;
+  const humanInputCheckActivity = options.humanInputCheckActivity ? createDaprAgentTurnHumanInputCheckActivity(
+    options.humanInputCheckActivity
+  ) : void 0;
+  const approvalCheckActivity = options.approvalCheckActivity ? createDaprAgentTurnApprovalCheckActivity(options.approvalCheckActivity) : void 0;
+  const modelStepActivity = createDaprAgentTurnModelStepActivity({
+    ...options.modelStepActivity,
+    get observerBridge() {
+      return getBridge();
+    }
+  });
+  const toolCallActivity = createDaprAgentTurnToolCallActivity({
+    ...options.toolCallActivity,
+    get observerBridge() {
+      return getBridge();
+    }
+  });
+  const stepCommitActivity = createDaprAgentTurnStepCommitActivity(
+    options.commitActivity
+  );
+  const outputCommitActivity = createDaprAgentTurnOutputCommitActivity(
+    options.commitActivity
+  );
+  const registration = createDaprAgentTurnWorkflowDefinition({
+    workflowName: options.workflowName,
+    activityNames: options.activityNames,
+    steeringEnabled: options.steeringEnabled,
+    now: options.now,
+    get observerBridge() {
+      return getBridge();
+    },
+    onEvent: options.onEvent,
+    ...steerDrainActivity ? {
+      steerDrain: (input) => steerDrainActivity.handler(void 0, input)
+    } : {},
+    modelStep: (input) => modelStepActivity.handler(void 0, input),
+    ...humanInputCheckActivity ? {
+      humanInputCheck: (input) => humanInputCheckActivity.handler(void 0, input)
+    } : {},
+    ...approvalCheckActivity ? {
+      approvalCheck: (input) => approvalCheckActivity.handler(void 0, input)
+    } : {},
+    toolCall: (input) => toolCallActivity.handler(void 0, input),
+    stepCommit: (input) => stepCommitActivity.handler(void 0, input),
+    outputCommit: (input) => outputCommitActivity.handler(void 0, input),
+    workflowToolHandlers: options.workflowToolHandlers
+  });
+  return {
+    ...registration,
+    activities: {
+      ...steerDrainActivity && registration.activityNames.steerDrain ? {
+        steerDrain: renameActivity(
+          steerDrainActivity,
+          registration.activityNames.steerDrain
+        )
+      } : {},
+      modelStep: renameActivity(
+        modelStepActivity,
+        registration.activityNames.modelStep
+      ),
+      ...humanInputCheckActivity && registration.activityNames.humanInputCheck ? {
+        humanInputCheck: renameActivity(
+          humanInputCheckActivity,
+          registration.activityNames.humanInputCheck
+        )
+      } : {},
+      ...approvalCheckActivity && registration.activityNames.approvalCheck ? {
+        approvalCheck: renameActivity(
+          approvalCheckActivity,
+          registration.activityNames.approvalCheck
+        )
+      } : {},
+      toolCall: renameActivity(
+        toolCallActivity,
+        registration.activityNames.toolCall
+      ),
+      stepCommit: renameActivity(
+        stepCommitActivity,
+        registration.activityNames.stepCommit
+      ),
+      outputCommit: renameActivity(
+        outputCommitActivity,
+        registration.activityNames.outputCommit
+      )
+    }
+  };
+}
+
+export {
+  isTerminalDaprWorkflowStatus,
+  hasStartedDaprWorkflow,
+  DaprWorkflowClient,
+  createDaprAgentTurnSteerDrainActivity,
+  createDaprAgentTurnModelStepActivity,
+  createDaprAgentTurnToolCallActivity,
+  createDaprAgentTurnApprovalCheckActivity,
+  createDaprAgentTurnHumanInputCheckActivity,
+  createDaprAgentTurnStepCommitActivity,
+  createDaprAgentTurnOutputCommitActivity,
+  createDaprAgentTurnWorkflowDefinition,
+  createDaprAgentTurnWorkflowKit
+};