@cuylabs/agent-runtime-dapr 0.9.0 → 0.11.0

package/dist/chunk-YQQTUE6B.js

@@ -0,0 +1,993 @@
+import {
+  DaprSidecarClient,
+  isDaprConflictError
+} from "./chunk-MQJ4LZOX.js";
+
+// src/dispatch/runtime.ts
+import {
+  ensureNonEmpty as ensureNonEmpty2,
+  mergeInspection,
+  sleep
+} from "@cuylabs/agent-core";
+
+// src/host/invoker.ts
+var DEFAULT_DAPR_HTTP_ENDPOINT = "http://127.0.0.1:3500";
+var DEFAULT_REQUEST_TIMEOUT_MS = 15e3;
+function trimTrailingSlash(input) {
+  return input.replace(/\/+$/, "");
+}
+function ensureNonEmpty(input, label) {
+  const normalized = input.trim();
+  if (!normalized) {
+    throw new Error(`${label} must not be empty`);
+  }
+  return normalized;
+}
+function ensurePositiveInt(input, label) {
+  if (!Number.isFinite(input)) {
+    throw new Error(`${label} must be a finite number`);
+  }
+  const normalized = Math.floor(input);
+  if (normalized <= 0) {
+    throw new Error(`${label} must be greater than zero`);
+  }
+  return normalized;
+}
+function toQueryString(query) {
+  if (!query) {
+    return "";
+  }
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0) {
+      continue;
+    }
+    params.set(key, String(value));
+  }
+  const encoded = params.toString();
+  return encoded ? `?${encoded}` : "";
+}
+function parseJson(text) {
+  if (!text.trim()) {
+    return void 0;
+  }
+  return JSON.parse(text);
+}
+function normalizeMethodPath(methodPath) {
+  return methodPath.split("/").map((part) => part.trim()).filter(Boolean).map((part) => encodeURIComponent(part)).join("/");
+}
+function isAbortError(error) {
+  return error instanceof Error && error.name === "AbortError";
+}
+var DaprServiceInvoker = class {
+  daprHttpEndpoint;
+  apiToken;
+  requestTimeoutMs;
+  fetchImpl;
+  constructor(options = {}) {
+    this.daprHttpEndpoint = trimTrailingSlash(
+      options.daprHttpEndpoint ?? DEFAULT_DAPR_HTTP_ENDPOINT
+    );
+    this.apiToken = options.apiToken?.trim() || void 0;
+    this.requestTimeoutMs = ensurePositiveInt(
+      options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS,
+      "requestTimeoutMs"
+    );
+    if (options.fetch) {
+      this.fetchImpl = options.fetch;
+    } else if (typeof globalThis.fetch === "function") {
+      this.fetchImpl = globalThis.fetch.bind(globalThis);
+    } else {
+      throw new Error(
+        "No fetch implementation available. Provide options.fetch."
+      );
+    }
+  }
+  async invokeMethod(appId, methodPath, options = {}) {
+    const normalizedAppId = ensureNonEmpty(appId, "appId");
+    const normalizedMethod = normalizeMethodPath(
+      ensureNonEmpty(methodPath, "methodPath")
+    );
+    const timeoutMs = ensurePositiveInt(
+      options.timeoutMs ?? this.requestTimeoutMs,
+      "timeoutMs"
+    );
+    const query = toQueryString(options.query);
+    const method = options.method ?? (options.body === void 0 ? "GET" : "POST");
+    const headers = new Headers(options.headers);
+    let body;
+    if (options.body !== void 0) {
+      if (typeof options.body === "string" || options.body instanceof Blob || options.body instanceof ArrayBuffer || ArrayBuffer.isView(options.body) || options.body instanceof URLSearchParams || options.body instanceof FormData) {
+        body = options.body;
+      } else {
+        if (!headers.has("content-type")) {
+          headers.set("content-type", "application/json");
+        }
+        body = JSON.stringify(options.body);
+      }
+    }
+    if (this.apiToken && !headers.has("dapr-api-token")) {
+      headers.set("dapr-api-token", this.apiToken);
+    }
+    const timeoutController = new AbortController();
+    const timeout = setTimeout(() => {
+      timeoutController.abort();
+    }, timeoutMs);
+    timeout.unref?.();
+    const url = `${this.daprHttpEndpoint}/v1.0/invoke/${encodeURIComponent(normalizedAppId)}/method/${normalizedMethod}${query}`;
+    try {
+      const response = await this.fetchImpl(url, {
+        method,
+        headers,
+        body,
+        signal: timeoutController.signal
+      });
+      const text = await response.text();
+      if (response.status < 200 || response.status >= 300) {
+        throw new Error(
+          `Dapr service invocation failed (${response.status}) ${method} ${methodPath}${text ? `: ${text}` : ""}`
+        );
+      }
+      let parsed;
+      if (text.trim()) {
+        try {
+          parsed = parseJson(text);
+        } catch {
+          parsed = text;
+        }
+      }
+      return {
+        status: response.status,
+        data: parsed,
+        headers: response.headers
+      };
+    } catch (error) {
+      if (isAbortError(error)) {
+        throw new Error(
+          `Dapr service invocation timed out after ${timeoutMs}ms: ${method} ${methodPath}`
+        );
+      }
+      if (error instanceof Error) {
+        throw error;
+      }
+      throw new Error(String(error));
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+};
+async function invokeRemoteAgentRun(invoker, appId, request, methodPath = "agents/run") {
+  const response = await invoker.invokeMethod(appId, methodPath, {
+    method: "POST",
+    body: request
+  });
+  if (!response.data) {
+    throw new Error("Remote agent invocation returned no response body");
+  }
+  return response.data;
+}
+
+// src/dispatch/runtime.ts
+var DEFAULT_KEY_PREFIX = "agent-runtime:dispatch:";
+var STORED_KIND = "@cuylabs/agent-runtime-dapr/dispatch-record";
+var STORED_VERSION = 1;
+var DEFAULT_INDEX_UPDATE_RETRIES = 4;
+var DEFAULT_POLL_INTERVAL_MS = 500;
+function cloneRecord(record) {
+  return structuredClone(record);
+}
+function toStoredRecord(record) {
+  return {
+    kind: STORED_KIND,
+    version: STORED_VERSION,
+    record
+  };
+}
+function fromStoredRecord(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const envelope = value;
+  if (envelope.kind !== STORED_KIND || envelope.version !== STORED_VERSION || !envelope.record) {
+    return void 0;
+  }
+  return cloneRecord(envelope.record);
+}
+function normalizeStatuses(status) {
+  if (!status) {
+    return void 0;
+  }
+  return new Set(Array.isArray(status) ? status : [status]);
+}
+function createDaprDispatchRecordWriter(options) {
+  const client = new DaprSidecarClient(options);
+  const agentId = ensureNonEmpty2(options.agentId, "agentId");
+  const keyPrefix = ensureNonEmpty2(
+    options.keyPrefix ?? DEFAULT_KEY_PREFIX,
+    "keyPrefix"
+  );
+  function recordKey(id) {
+    return `${keyPrefix}records/${agentId}/${id}`;
+  }
+  function globalIndexKey() {
+    return `${keyPrefix}record-index/${agentId}`;
+  }
+  function sessionIndexKey(sessionId) {
+    return `${keyPrefix}session-index/${agentId}/${sessionId}`;
+  }
+  async function readIndex(key) {
+    const entry = await client.getStateEntry(key);
+    if (entry.value === void 0) {
+      return { exists: false };
+    }
+    if (!Array.isArray(entry.value)) {
+      return { ids: [], etag: entry.etag, exists: true };
+    }
+    return {
+      ids: [...new Set(entry.value.filter((item) => typeof item === "string"))],
+      etag: entry.etag,
+      exists: true
+    };
+  }
+  async function writeIndex(key, ids, etag) {
+    await client.saveState(key, [...new Set(ids)], {
+      ...etag ? { etag } : {},
+      concurrency: etag ? "first-write" : void 0
+    });
+  }
+  async function updateIndex(key, updater) {
+    for (let attempt = 0; attempt < DEFAULT_INDEX_UPDATE_RETRIES; attempt += 1) {
+      const current = await readIndex(key);
+      const next = updater(current.ids ?? []);
+      if (!next) {
+        return;
+      }
+      try {
+        await writeIndex(key, next, current.etag);
+        return;
+      } catch (error) {
+        if (isDaprConflictError(error) && attempt + 1 < DEFAULT_INDEX_UPDATE_RETRIES) {
+          continue;
+        }
+        throw error;
+      }
+    }
+  }
+  async function addRecordToIndex(key, id) {
+    await updateIndex(key, (ids) => {
+      if (ids.includes(id)) {
+        return void 0;
+      }
+      return [...ids, id];
+    });
+  }
+  return {
+    async saveStartedRecord(record) {
+      await client.saveState(recordKey(record.id), toStoredRecord(record), {
+        concurrency: "first-write"
+      });
+      await addRecordToIndex(globalIndexKey(), record.id);
+      if (record.parentSessionId) {
+        await addRecordToIndex(sessionIndexKey(record.parentSessionId), record.id);
+      }
+    }
+  };
+}
+function mapWorkflowStatus(status) {
+  switch (status) {
+    case "COMPLETED":
+      return "completed";
+    case "FAILED":
+      return "failed";
+    case "TERMINATED":
+      return "cancelled";
+    default:
+      return "running";
+  }
+}
+function createWorkflowDispatchTarget(options) {
+  return {
+    name: options.name,
+    description: options.description,
+    async start(input) {
+      const prepared = await options.host.startTurn(
+        options.client,
+        options.buildRequest?.(input) ?? {
+          message: input.brief,
+          sessionId: input.sessionId
+        }
+      );
+      if (options.waitForStart) {
+        await options.client.waitForWorkflowStart(
+          prepared.workflowInstanceId
+        );
+      }
+      return {
+        sessionId: prepared.sessionId,
+        executionId: prepared.workflowInstanceId
+      };
+    },
+    async redirect(input) {
+      if (!options.host.steerTurn) {
+        throw new Error(
+          `Workflow dispatch target "${options.name}" does not expose durable steering.`
+        );
+      }
+      const executionId = input.record.executionId ?? ensureNonEmpty2(input.record.id, "record.id");
+      await options.host.steerTurn(options.client, {
+        workflowInstanceId: executionId,
+        sessionId: input.record.sessionId ?? ensureNonEmpty2(input.record.parentSessionId ?? "", "record.sessionId"),
+        message: input.message
+      });
+    },
+    async cancel(input) {
+      const executionId = ensureNonEmpty2(
+        input.record.executionId ?? "",
+        "record.executionId"
+      );
+      await options.client.terminateWorkflow(executionId);
+    },
+    async check(input) {
+      const executionId = input.record.executionId;
+      if (!executionId) {
+        return void 0;
+      }
+      const workflow = await options.client.getWorkflow(executionId);
+      if (!workflow) {
+        return {
+          status: "failed",
+          error: `Workflow "${executionId}" was not found.`
+        };
+      }
+      const snapshot = {
+        status: mapWorkflowStatus(workflow.runtimeStatus),
+        updatedAt: workflow.lastUpdatedAt ?? workflow.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (options.readCompletion && snapshot.status !== "running") {
+        const completion = await options.readCompletion({
+          record: input.record,
+          workflow
+        });
+        if (completion?.result) {
+          snapshot.result = completion.result;
+        }
+        if (completion?.error) {
+          snapshot.error = completion.error;
+        }
+      }
+      return snapshot;
+    }
+  };
+}
+function createRemoteAgentDispatchTarget(options) {
+  const invoker = options.invoker ?? new DaprServiceInvoker(options.invokerOptions);
+  function resolveAgentId(record) {
+    return options.agentId ?? record.agentId ?? record.targetType;
+  }
+  return {
+    name: options.name,
+    description: options.description,
+    async start(input) {
+      const methodPath = options.agentId ? `agents/${encodeURIComponent(options.agentId)}/run-durable` : "agents/run-durable";
+      const response = await invoker.invokeMethod(options.appId, methodPath, {
+        method: "POST",
+        body: options.buildRunRequest?.(input) ?? {
+          message: input.brief,
+          sessionId: input.sessionId ?? input.parentSessionId,
+          ...options.agentId ? {} : { agentId: options.name }
+        }
+      });
+      if (!response.data?.instanceId) {
+        throw new Error(
+          `Remote agent "${options.appId}" did not return a workflow instanceId.`
+        );
+      }
+      return {
+        sessionId: response.data.sessionId,
+        executionId: response.data.instanceId,
+        ...response.data.agentId ? { agentId: response.data.agentId } : {}
+      };
+    },
+    async redirect(input) {
+      const executionId = ensureNonEmpty2(
+        input.record.executionId ?? input.record.id,
+        "record.executionId"
+      );
+      await invoker.invokeMethod(
+        options.appId,
+        `agents/${encodeURIComponent(resolveAgentId(input.record))}/steer`,
+        {
+          method: "POST",
+          body: {
+            workflowInstanceId: executionId,
+            sessionId: input.record.sessionId ?? input.record.parentSessionId,
+            message: input.message
+          }
+        }
+      );
+    },
+    async cancel(input) {
+      const executionId = ensureNonEmpty2(
+        input.record.executionId ?? input.record.id,
+        "record.executionId"
+      );
+      await invoker.invokeMethod(
+        options.appId,
+        `agents/${encodeURIComponent(resolveAgentId(input.record))}/workflows/${encodeURIComponent(executionId)}/terminate`,
+        {
+          method: "POST",
+          body: { reason: input.reason }
+        }
+      );
+    },
+    async check(input) {
+      const executionId = ensureNonEmpty2(
+        input.record.executionId ?? input.record.id,
+        "record.executionId"
+      );
+      const agentId = resolveAgentId(input.record);
+      const workflow = await invoker.invokeMethod(
+        options.appId,
+        `agents/${encodeURIComponent(agentId)}/workflows/${encodeURIComponent(executionId)}`,
+        { method: "GET" }
+      );
+      const runtimeStatus = workflow.data?.runtimeStatus;
+      if (!runtimeStatus) {
+        return void 0;
+      }
+      const inspection = {
+        status: mapWorkflowStatus(runtimeStatus),
+        updatedAt: workflow.data?.lastUpdatedAt ?? workflow.data?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (inspection.status === "completed") {
+        const execution = await invoker.invokeMethod(
+          options.appId,
+          `agents/${encodeURIComponent(agentId)}/executions/${encodeURIComponent(
+            input.record.sessionId ?? ""
+          )}`,
+          { method: "GET" }
+        ).catch(() => ({ data: void 0 }));
+        if (execution.data?.result) {
+          inspection.result = {
+            response: execution.data.result.response ?? "",
+            usage: execution.data.result.usage ?? {
+              inputTokens: 0,
+              outputTokens: 0,
+              totalTokens: 0
+            },
+            toolCalls: execution.data.result.toolCalls ?? []
+          };
+        } else if (execution.data?.error?.message) {
+          inspection.error = execution.data.error.message;
+        } else {
+          inspection.result = {
+            response: `[Remote workflow ${executionId} completed]`,
+            usage: {
+              inputTokens: 0,
+              outputTokens: 0,
+              totalTokens: 0
+            },
+            toolCalls: []
+          };
+        }
+      } else if (inspection.status === "failed" || inspection.status === "cancelled") {
+        const execution = await invoker.invokeMethod(
+          options.appId,
+          `agents/${encodeURIComponent(agentId)}/executions/${encodeURIComponent(
+            input.record.sessionId ?? ""
+          )}`,
+          { method: "GET" }
+        ).catch(() => ({ data: void 0 }));
+        if (execution.data?.error?.message) {
+          inspection.error = execution.data.error.message;
+        } else {
+          inspection.error = inspection.status === "cancelled" ? `Remote workflow "${executionId}" was cancelled.` : `Remote workflow "${executionId}" failed.`;
+        }
+      }
+      return inspection;
+    }
+  };
+}
+function createDaprDispatchRuntime(options) {
+  const client = new DaprSidecarClient(options);
+  const agentId = ensureNonEmpty2(options.agentId, "agentId");
+  const keyPrefix = ensureNonEmpty2(
+    options.keyPrefix ?? DEFAULT_KEY_PREFIX,
+    "keyPrefix"
+  );
+  const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const createId = options.createId ?? (() => crypto.randomUUID());
+  const pollIntervalMs = Math.max(25, Math.floor(options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS));
+  const targets = new Map(
+    options.targets.map((target) => [target.name, target])
+  );
+  function recordKey(id) {
+    return `${keyPrefix}records/${agentId}/${id}`;
+  }
+  function globalIndexKey() {
+    return `${keyPrefix}record-index/${agentId}`;
+  }
+  function sessionIndexKey(sessionId) {
+    return `${keyPrefix}session-index/${agentId}/${sessionId}`;
+  }
+  async function getStoredRecord(id) {
+    const entry = await client.getStateEntry(recordKey(id));
+    return {
+      record: fromStoredRecord(entry.value),
+      etag: entry.etag
+    };
+  }
+  async function saveRecord(record, etag) {
+    await client.saveState(recordKey(record.id), toStoredRecord(record), {
+      ...etag ? { etag } : {},
+      concurrency: "first-write"
+    });
+  }
+  async function readIndex(key) {
+    const entry = await client.getStateEntry(key);
+    if (entry.value === void 0) {
+      return { exists: false };
+    }
+    if (!Array.isArray(entry.value)) {
+      return { ids: [], etag: entry.etag, exists: true };
+    }
+    return {
+      ids: [...new Set(entry.value.filter((item) => typeof item === "string"))],
+      etag: entry.etag,
+      exists: true
+    };
+  }
+  async function writeIndex(key, ids, etag) {
+    await client.saveState(key, [...new Set(ids)], {
+      ...etag ? { etag } : {},
+      concurrency: etag ? "first-write" : void 0
+    });
+  }
+  async function updateIndex(key, updater) {
+    for (let attempt = 0; attempt < DEFAULT_INDEX_UPDATE_RETRIES; attempt += 1) {
+      const current = await readIndex(key);
+      const next = updater(current.ids ?? []);
+      if (!next) {
+        return;
+      }
+      try {
+        await writeIndex(key, next, current.etag);
+        return;
+      } catch (error) {
+        if (isDaprConflictError(error) && attempt + 1 < DEFAULT_INDEX_UPDATE_RETRIES) {
+          continue;
+        }
+        throw error;
+      }
+    }
+  }
+  async function addRecordToIndex(key, id) {
+    await updateIndex(key, (ids) => {
+      if (ids.includes(id)) {
+        return void 0;
+      }
+      return [...ids, id];
+    });
+  }
+  async function updateStoredRecord(id, updater) {
+    for (let attempt = 0; attempt < DEFAULT_INDEX_UPDATE_RETRIES; attempt += 1) {
+      const current = await getStoredRecord(id);
+      if (!current.record) {
+        throw new Error(`Unknown dispatch "${id}".`);
+      }
+      const next = updater(current.record);
+      try {
+        await saveRecord(next, current.etag);
+        return cloneRecord(next);
+      } catch (error) {
+        if (isDaprConflictError(error) && attempt + 1 < DEFAULT_INDEX_UPDATE_RETRIES) {
+          continue;
+        }
+        throw error;
+      }
+    }
+    throw new Error(`Failed to update dispatch "${id}".`);
+  }
+  async function refreshRecord(id) {
+    const current = await getStoredRecord(id);
+    if (!current.record) {
+      return void 0;
+    }
+    const target = targets.get(current.record.targetType);
+    if (!target?.check || current.record.status !== "running") {
+      return current.record;
+    }
+    const inspection = await target.check({
+      record: cloneRecord(current.record)
+    });
+    if (!inspection) {
+      return current.record;
+    }
+    const next = mergeInspection(current.record, inspection, now());
+    if (JSON.stringify(next) === JSON.stringify(current.record)) {
+      return next;
+    }
+    try {
+      await saveRecord(next, current.etag);
+      return cloneRecord(next);
+    } catch (error) {
+      if (isDaprConflictError(error)) {
+        return (await getStoredRecord(id)).record;
+      }
+      throw error;
+    }
+  }
+  async function waitForCheck(id, checkOptions) {
+    const waitMs = checkOptions?.waitMs;
+    if (!waitMs || waitMs <= 0) {
+      return refreshRecord(id);
+    }
+    const deadline = Date.now() + waitMs;
+    let current = await refreshRecord(id);
+    while (current && current.status === "running" && Date.now() < deadline) {
+      await sleep(pollIntervalMs);
+      current = await refreshRecord(id);
+    }
+    return current;
+  }
+  async function listIndexedRecords(key) {
+    const current = await readIndex(key);
+    if (!current.exists) {
+      return [];
+    }
+    const entries = await Promise.all(
+      (current.ids ?? []).map((id) => getStoredRecord(id))
+    );
+    const records = [];
+    const presentIds = [];
+    for (const entry of entries) {
+      if (!entry.record || entry.record.agentId !== agentId) {
+        continue;
+      }
+      presentIds.push(entry.record.id);
+      records.push(entry.record);
+    }
+    if (presentIds.length !== (current.ids ?? []).length) {
+      await writeIndex(key, presentIds, current.etag).catch(() => {
+      });
+    }
+    return records;
+  }
+  return {
+    describeTargets() {
+      return options.targets.map((target) => ({
+        name: target.name,
+        description: target.description
+      }));
+    },
+    async start(input) {
+      const target = targets.get(
+        ensureNonEmpty2(input.targetType, "targetType")
+      );
+      if (!target) {
+        throw new Error(`Unknown dispatch target "${input.targetType}".`);
+      }
+      const id = createId();
+      const startedAt = now();
+      const title = input.title?.trim() || `Dispatch: ${target.name}`;
+      const brief = ensureNonEmpty2(input.brief, "brief");
+      const launched = await target.start({
+        id,
+        brief,
+        title,
+        parentSessionId: input.parentSessionId
+      });
+      const record = {
+        id,
+        agentId,
+        targetType: target.name,
+        title,
+        brief,
+        status: "running",
+        createdAt: startedAt,
+        updatedAt: startedAt,
+        parentSessionId: input.parentSessionId,
+        sessionId: launched.sessionId,
+        executionId: launched.executionId,
+        redirectCount: 0
+      };
+      await saveRecord(record);
+      await addRecordToIndex(globalIndexKey(), record.id);
+      if (record.parentSessionId) {
+        await addRecordToIndex(sessionIndexKey(record.parentSessionId), record.id);
+      }
+      return cloneRecord(record);
+    },
+    async check(id, checkOptions) {
+      const record = await waitForCheck(id, checkOptions);
+      return record ? cloneRecord(record) : void 0;
+    },
+    async redirect(id, message) {
+      const current = await refreshRecord(id);
+      if (!current) {
+        throw new Error(`Unknown dispatch "${id}".`);
+      }
+      if (current.status !== "running") {
+        throw new Error(
+          `Dispatch "${id}" is ${current.status} and cannot be redirected.`
+        );
+      }
+      const target = targets.get(current.targetType);
+      if (!target) {
+        throw new Error(`No target registered for dispatch target "${current.targetType}".`);
+      }
+      const nextMessage = ensureNonEmpty2(message, "message");
+      await target.redirect({
+        record: cloneRecord(current),
+        message: nextMessage
+      });
+      return updateStoredRecord(id, (record) => ({
+        ...record,
+        updatedAt: now(),
+        redirectCount: record.redirectCount + 1,
+        lastRedirect: nextMessage
+      }));
+    },
+    async cancel(id, reason) {
+      const current = await refreshRecord(id);
+      if (!current) {
+        throw new Error(`Unknown dispatch "${id}".`);
+      }
+      if (current.status !== "running") {
+        return cloneRecord(current);
+      }
+      const target = targets.get(current.targetType);
+      if (!target) {
+        throw new Error(`No target registered for dispatch target "${current.targetType}".`);
+      }
+      await target.cancel({
+        record: cloneRecord(current),
+        reason
+      });
+      return updateStoredRecord(id, (record) => ({
+        ...record,
+        status: "cancelled",
+        updatedAt: now(),
+        ...reason ? { error: reason } : {}
+      }));
+    },
+    async list(listOptions = {}) {
+      const indexKey = listOptions.parentSessionId ? sessionIndexKey(listOptions.parentSessionId) : globalIndexKey();
+      const statuses = normalizeStatuses(listOptions.status);
+      const records = await listIndexedRecords(indexKey);
+      const refreshed = await Promise.all(
+        records.map(
+          (record) => record.status === "running" ? refreshRecord(record.id) : Promise.resolve(record)
+        )
+      );
+      return refreshed.filter((record) => record !== void 0).filter(
+        (record) => (!statuses || statuses.has(record.status)) && (!listOptions.targetType || record.targetType === listOptions.targetType)
+      ).map((record) => cloneRecord(record)).sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+    }
+  };
+}
+
+// src/dispatch/executor.ts
+import {
+  createCompositeDispatchTaskExecutor,
+  createDispatchTaskExecutor
+} from "@cuylabs/agent-core";
+
+// src/dispatch/completion.ts
+function zeroUsage() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0
+  };
+}
+function toDispatchResult(value) {
+  if (!value) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    const response = value.trim();
+    return response ? { response, usage: zeroUsage(), toolCalls: [] } : void 0;
+  }
+  if (typeof value !== "object") {
+    return void 0;
+  }
+  const candidate = value;
+  if (typeof candidate.response !== "string" || !candidate.response.trim()) {
+    return void 0;
+  }
+  const toolCalls = Array.isArray(candidate.toolCalls) ? candidate.toolCalls : [];
+  return {
+    response: candidate.response,
+    usage: {
+      inputTokens: candidate.usage?.inputTokens ?? 0,
+      outputTokens: candidate.usage?.outputTokens ?? 0,
+      totalTokens: candidate.usage?.totalTokens ?? 0
+    },
+    toolCalls
+  };
+}
+function parseJsonProperty(value) {
+  if (!value) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+async function readWorkflowCompletion(input) {
+  const { record, workflow, executionStore } = input;
+  if (executionStore && record.sessionId) {
+    const execution = await executionStore.getExecution(record.sessionId);
+    if (execution?.result) {
+      return {
+        result: {
+          response: execution.result.response,
+          usage: {
+            inputTokens: execution.result.usage?.inputTokens ?? 0,
+            outputTokens: execution.result.usage?.outputTokens ?? 0,
+            totalTokens: execution.result.usage?.totalTokens ?? 0
+          },
+          toolCalls: execution.result.toolCalls
+        }
+      };
+    }
+    if (execution?.error?.message) {
+      return { error: execution.error.message };
+    }
+  }
+  const outputResult = toDispatchResult(
+    parseJsonProperty(workflow.properties["dapr.workflow.output"])
+  );
+  if (outputResult) {
+    return { result: outputResult };
+  }
+  const statusResult = toDispatchResult(
+    parseJsonProperty(workflow.properties["dapr.workflow.custom_status"])
+  );
+  if (statusResult) {
+    return { result: statusResult };
+  }
+  if (workflow.runtimeStatus === "FAILED") {
+    return { error: `Workflow "${workflow.instanceId}" failed.` };
+  }
+  if (workflow.runtimeStatus === "TERMINATED") {
+    return { error: `Workflow "${workflow.instanceId}" was terminated.` };
+  }
+  return {
+    result: {
+      response: `[Workflow ${workflow.instanceId} completed]`,
+      usage: zeroUsage(),
+      toolCalls: []
+    }
+  };
+}
+
+// src/dispatch/executor.ts
+function createDispatchRecord(input) {
+  return {
+    id: input.dispatchId,
+    agentId: input.startResult.agentId ?? input.memberId,
+    targetType: input.targetName,
+    title: input.taskTitle,
+    brief: input.prompt,
+    status: "running",
+    createdAt: input.startedAt,
+    updatedAt: input.startedAt,
+    parentSessionId: input.parentSessionId,
+    sessionId: input.startResult.sessionId ?? input.memberSessionId,
+    executionId: input.startResult.executionId ?? input.dispatchId,
+    redirectCount: 0
+  };
+}
+function createDaprWorkflowDispatchExecutor(options) {
+  const targets = [...options.workflowHosts.entries()].map(
+    ([name, host]) => createWorkflowDispatchTarget({
+      name,
+      description: `Durable workflow-backed member "${name}".`,
+      host,
+      client: options.workflowClient,
+      buildRequest: (input) => ({
+        message: input.brief,
+        sessionId: input.sessionId,
+        workflowInstanceId: input.id
+      }),
+      readCompletion: async ({ record, workflow }) => await readWorkflowCompletion({
+        record,
+        workflow,
+        executionStore: options.executionStore
+      })
+    })
+  );
+  return createDispatchTaskExecutor({
+    targets,
+    timeoutMs: options.timeoutMs,
+    pollIntervalMs: options.pollIntervalMs,
+    createRecord: ({
+      taskInput,
+      target,
+      dispatchId,
+      startedAt,
+      startResult
+    }) => createDispatchRecord({
+      taskTitle: taskInput.task.title,
+      prompt: taskInput.prompt,
+      parentSessionId: taskInput.parentSessionId,
+      memberSessionId: taskInput.runtime.member.sessionId,
+      memberId: taskInput.runtime.member.id,
+      targetName: target.name,
+      dispatchId,
+      startedAt,
+      startResult
+    })
+  });
+}
+function createDaprAppDispatchExecutor(options) {
+  const targets = [...options.appsByRole.entries()].map(
+    ([name, appId]) => createRemoteAgentDispatchTarget({
+      name,
+      description: `App-backed member "${name}" on app "${appId}".`,
+      appId,
+      invoker: options.invoker,
+      invokerOptions: options.invoker ? void 0 : options.invokerOptions
+    })
+  );
+  return createDispatchTaskExecutor({
+    targets,
+    timeoutMs: options.timeoutMs,
+    pollIntervalMs: options.pollIntervalMs,
+    createRecord: ({
+      taskInput,
+      target,
+      dispatchId,
+      startedAt,
+      startResult
+    }) => createDispatchRecord({
+      taskTitle: taskInput.task.title,
+      prompt: taskInput.prompt,
+      parentSessionId: taskInput.parentSessionId,
+      memberSessionId: taskInput.runtime.member.sessionId,
+      memberId: taskInput.runtime.member.id,
+      targetName: target.name,
+      dispatchId,
+      startedAt,
+      startResult
+    })
+  });
+}
+function createDaprCompositeDispatchExecutor(options) {
+  const workflowExecutor = options.workflow ? createDaprWorkflowDispatchExecutor(options.workflow) : void 0;
+  const appExecutor = options.app ? createDaprAppDispatchExecutor(options.app) : void 0;
+  const routes = [];
+  if (workflowExecutor && options.workflow) {
+    routes.push({
+      matches: (input) => options.workflow.workflowHosts.has(input.runtime.member.role),
+      executor: workflowExecutor
+    });
+  }
+  if (appExecutor && options.app) {
+    routes.push({
+      matches: (input) => options.app.appsByRole.has(input.runtime.member.role),
+      executor: appExecutor
+    });
+  }
+  return createCompositeDispatchTaskExecutor({
+    routes,
+    fallback: options.fallback
+  });
+}
+
+export {
+  DaprServiceInvoker,
+  invokeRemoteAgentRun,
+  createDaprDispatchRecordWriter,
+  createWorkflowDispatchTarget,
+  createRemoteAgentDispatchTarget,
+  createDaprDispatchRuntime,
+  readWorkflowCompletion,
+  createDaprWorkflowDispatchExecutor,
+  createDaprAppDispatchExecutor,
+  createDaprCompositeDispatchExecutor
+};