@cuylabs/agent-runtime-dapr 0.5.0

package/dist/chunk-DILON56B.js

@@ -0,0 +1,668 @@
+import {
+  DaprSidecarClient
+} from "./chunk-A34CHK2E.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.ts
+import {
+  applyAgentWorkflowCommitResult,
+  applyAgentWorkflowModelStepResult,
+  applyAgentWorkflowToolCallResult,
+  advanceAgentTurnState,
+  convertAgentMessagesToModelMessages,
+  createAgentTurnEngine,
+  createAgentTurnStepCommitBatch,
+  executeAgentToolCall,
+  failAgentWorkflowTurnState,
+  normalizeToolReplayPolicy,
+  planNextAgentWorkflowOperation,
+  prepareModelStep,
+  recordAgentWorkflowReplayDecision,
+  restoreAgentWorkflowMessages,
+  runModelStep,
+  snapshotAgentWorkflowMessages
+} from "@cuylabs/agent-core";
+var DEFAULT_WORKFLOW_NAME = "agent-turn";
+function defaultActivityNames(workflowName, overrides = {}) {
+  return {
+    modelStep: overrides.modelStep ?? `${workflowName}:model-step`,
+    toolCall: overrides.toolCall ?? `${workflowName}:tool-call`,
+    stepCommit: overrides.stepCommit ?? `${workflowName}:step-commit`,
+    outputCommit: overrides.outputCommit ?? `${workflowName}:output-commit`
+  };
+}
+function normalizeError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+function renameActivity(activity, name) {
+  return {
+    name,
+    handler: activity.handler
+  };
+}
+async function* emptyCommitApplier() {
+  yield* [];
+}
+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 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 createDaprAgentTurnWorkflowDefinition(options) {
+  const workflowName = options.workflowName ?? DEFAULT_WORKFLOW_NAME;
+  const activityNames = defaultActivityNames(
+    workflowName,
+    options.activityNames
+  );
+  const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const bridge = options.observerBridge;
+  const workflow = async function* (context, input) {
+    let state = structuredClone(input);
+    if (!context.isReplaying?.()) {
+      await bridge?.notifyTaskStart(state);
+    }
+    try {
+      while (true) {
+        context.setCustomStatus?.(summarizeWorkflowState(state));
+        const plan = planNextAgentWorkflowOperation(state);
+        if (!plan) {
+          if (!context.isReplaying?.()) {
+            await bridge?.notifyTaskComplete(state);
+          }
+          return state;
+        }
+        switch (plan.kind) {
+          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`
+              );
+            }
+            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 "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);
+            }
+            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 = normalizeError(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 createDaprAgentTurnModelStepActivity(options) {
+  const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  return {
+    name: "model-step",
+    handler: async (_context, plan) => {
+      const runActivity = async () => {
+        if (options.middleware?.hasMiddleware) {
+          await options.middleware.runChatStart(
+            plan.sessionId,
+            `[workflow model-step ${plan.step}]`
+          );
+        }
+        let stepResult;
+        let stepError;
+        try {
+          const restoredMessages = restoreAgentWorkflowMessages(plan.messages);
+          const turnEngine = createAgentTurnEngine({
+            sessionId: plan.sessionId,
+            startedAt: now(),
+            getToolReplayPolicy: (toolName) => options.tools[toolName]?.replayPolicy ? normalizeToolReplayPolicy(options.tools[toolName].replayPolicy) : void 0
+          });
+          const preparedStep = prepareModelStep({
+            sessionId: plan.sessionId,
+            step: plan.step,
+            systemPrompts: plan.systemPrompts,
+            messages: restoredMessages,
+            toModelMessages: options.toModelMessages ?? convertAgentMessagesToModelMessages,
+            abort: options.createAbortSignal?.() ?? new AbortController().signal,
+            tools: options.tools,
+            mcpTools: typeof options.mcpTools === "function" ? await options.mcpTools() : options.mcpTools,
+            config: options.runtime,
+            ...options.host ? { host: options.host } : {},
+            ...options.turnTracker ? { turnTracker: options.turnTracker } : {},
+            ...options.middleware ? { middleware: options.middleware } : {},
+            ...options.reasoningLevel ? { reasoningLevel: options.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(item.value);
+            }
+          }
+        } catch (err) {
+          stepError = err instanceof Error ? err : new Error(String(err));
+        }
+        if (options.middleware?.hasMiddleware) {
+          await options.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 () => {
+        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 = options.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,
+            ...options.host ? { host: options.host } : {},
+            ...options.turnTracker ? { turnTracker: options.turnTracker } : {},
+            ...options.middleware ? { middleware: options.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 createDaprAgentTurnStepCommitActivity(options) {
+  return {
+    name: "step-commit",
+    handler: async (_context, plan) => {
+      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) };
+    }
+  };
+}
+function createDaprAgentTurnWorkflowKit(options) {
+  const modelStepActivity = createDaprAgentTurnModelStepActivity({
+    ...options.modelStepActivity,
+    observerBridge: options.observerBridge
+  });
+  const toolCallActivity = createDaprAgentTurnToolCallActivity({
+    ...options.toolCallActivity,
+    observerBridge: options.observerBridge
+  });
+  const stepCommitActivity = createDaprAgentTurnStepCommitActivity(
+    options.commitActivity
+  );
+  const outputCommitActivity = createDaprAgentTurnOutputCommitActivity(
+    options.commitActivity
+  );
+  const registration = createDaprAgentTurnWorkflowDefinition({
+    workflowName: options.workflowName,
+    activityNames: options.activityNames,
+    now: options.now,
+    observerBridge: options.observerBridge,
+    modelStep: (input) => modelStepActivity.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)
+  });
+  return {
+    ...registration,
+    activities: {
+      modelStep: renameActivity(
+        modelStepActivity,
+        registration.activityNames.modelStep
+      ),
+      toolCall: renameActivity(
+        toolCallActivity,
+        registration.activityNames.toolCall
+      ),
+      stepCommit: renameActivity(
+        stepCommitActivity,
+        registration.activityNames.stepCommit
+      ),
+      outputCommit: renameActivity(
+        outputCommitActivity,
+        registration.activityNames.outputCommit
+      )
+    }
+  };
+}
+
+export {
+  isTerminalDaprWorkflowStatus,
+  hasStartedDaprWorkflow,
+  DaprWorkflowClient,
+  createDaprAgentTurnWorkflowDefinition,
+  createDaprAgentTurnModelStepActivity,
+  createDaprAgentTurnToolCallActivity,
+  createDaprAgentTurnStepCommitActivity,
+  createDaprAgentTurnOutputCommitActivity,
+  createDaprAgentTurnWorkflowKit
+};