@cuylabs/agent-runtime-dapr 0.5.0

package/dist/chunk-2FMHOZLU.js

@@ -0,0 +1,1997 @@
+import {
+  DaprExecutionStore,
+  createDaprExecutionObserver,
+  createDaprLoggingObserver,
+  createWorkflowObserverBridge
+} from "./chunk-2CEICSJH.js";
+import {
+  DaprWorkflowClient,
+  createDaprAgentTurnWorkflowKit
+} from "./chunk-DILON56B.js";
+import {
+  DaprSidecarClient,
+  isDaprConflictError
+} from "./chunk-A34CHK2E.js";
+
+// 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(text2) {
+  if (!text2.trim()) {
+    return void 0;
+  }
+  return JSON.parse(text2);
+}
+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 text2 = await response.text();
+      if (response.status < 200 || response.status >= 300) {
+        throw new Error(
+          `Dapr service invocation failed (${response.status}) ${method} ${methodPath}${text2 ? `: ${text2}` : ""}`
+        );
+      }
+      let parsed;
+      if (text2.trim()) {
+        try {
+          parsed = parseJson(text2);
+        } catch {
+          parsed = text2;
+        }
+      }
+      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/host/workflow-host.ts
+import { randomUUID } from "crypto";
+import {
+  SessionManager,
+  createAgentWorkflowTurnState,
+  snapshotAgentWorkflowMessages
+} from "@cuylabs/agent-core";
+
+// src/http.ts
+var DEFAULT_HANDLED_STATUS = 200;
+var DEFAULT_UNHANDLED_STATUS = 404;
+var DEFAULT_ERROR_STATUS = 500;
+function normalizeStatus(value, fallback) {
+  if (value === void 0) {
+    return fallback;
+  }
+  const normalized = Math.floor(value);
+  if (normalized < 100 || normalized > 599) {
+    throw new Error(`Invalid HTTP status code: ${value}`);
+  }
+  return normalized;
+}
+function createDaprHttpJobHandler(options) {
+  const handledStatus = normalizeStatus(options.handledStatus, DEFAULT_HANDLED_STATUS);
+  const unhandledStatus = normalizeStatus(options.unhandledStatus, DEFAULT_UNHANDLED_STATUS);
+  const errorStatus = normalizeStatus(options.errorStatus, DEFAULT_ERROR_STATUS);
+  return async (jobName) => {
+    const normalizedJobName = String(jobName).trim();
+    if (!normalizedJobName) {
+      return {
+        status: unhandledStatus,
+        handled: false
+      };
+    }
+    try {
+      const handled = await options.driver.handleJobTriggerByName(normalizedJobName);
+      return {
+        status: handled ? handledStatus : unhandledStatus,
+        handled
+      };
+    } catch (error) {
+      if (options.onError) {
+        await options.onError(error, normalizedJobName);
+      }
+      return {
+        status: errorStatus,
+        handled: false,
+        error
+      };
+    }
+  };
+}
+
+// src/jobs/api.ts
+import {
+  computeNextRunAtMs
+} from "@cuylabs/agent-runtime";
+function toGoDurationMs(everyMs) {
+  const normalized = Math.max(1, Math.floor(everyMs));
+  return `${normalized}ms`;
+}
+function normalizeDaprCronExpression(expr) {
+  const parts = expr.trim().split(/\s+/).filter(Boolean);
+  if (parts.length === 5) {
+    return `0 ${parts.join(" ")}`;
+  }
+  if (parts.length === 6) {
+    return parts.join(" ");
+  }
+  throw new Error(`Dapr cron schedules must have 5 or 6 fields. Received: ${expr}`);
+}
+var DaprJobsApi = class {
+  client;
+  jobNamePrefix;
+  now;
+  constructor(options) {
+    this.client = options.client;
+    this.jobNamePrefix = options.jobNamePrefix;
+    this.now = options.now ?? (() => Date.now());
+  }
+  toDaprJobName(jobId) {
+    const encoded = Buffer.from(jobId, "utf8").toString("base64url");
+    return `${this.jobNamePrefix}${encoded}`;
+  }
+  fromDaprJobName(jobName) {
+    if (!jobName.startsWith(this.jobNamePrefix)) {
+      return void 0;
+    }
+    const encoded = jobName.slice(this.jobNamePrefix.length);
+    try {
+      return Buffer.from(encoded, "base64url").toString("utf8");
+    } catch {
+      return void 0;
+    }
+  }
+  async syncJob(job) {
+    if (!job.enabled) {
+      await this.deleteJob(job.id);
+      return;
+    }
+    const payload = this.toSchedulePayload(job);
+    const name = this.toDaprJobName(job.id);
+    await this.client.requestJson(`/v1.0-alpha1/jobs/${encodeURIComponent(name)}`, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }, [200, 201, 204]);
+  }
+  async deleteJob(jobId) {
+    const name = this.toDaprJobName(jobId);
+    await this.client.requestJson(`/v1.0-alpha1/jobs/${encodeURIComponent(name)}`, {
+      method: "DELETE"
+    }, [200, 204, 404]);
+  }
+  toSchedulePayload(job) {
+    const payload = {
+      overwrite: true,
+      data: {
+        source: "@cuylabs/agent-runtime-dapr",
+        jobId: job.id
+      }
+    };
+    if (job.schedule.kind === "at") {
+      payload.dueTime = new Date(job.schedule.at).toISOString();
+      return payload;
+    }
+    if (job.schedule.kind === "every") {
+      payload.schedule = `@every ${toGoDurationMs(job.schedule.everyMs)}`;
+      if (job.schedule.anchorMs !== void 0) {
+        const nextAnchor = computeNextRunAtMs(job.schedule, this.now());
+        if (nextAnchor !== void 0) {
+          payload.dueTime = new Date(nextAnchor).toISOString();
+        }
+      }
+      return payload;
+    }
+    if (job.schedule.timezone && !["UTC", "ETC/UTC", "Z"].includes(job.schedule.timezone.trim().toUpperCase())) {
+      throw new Error(
+        `Dapr jobs API does not expose timezone selection for cron schedules (received: ${job.schedule.timezone})`
+      );
+    }
+    payload.schedule = normalizeDaprCronExpression(job.schedule.expr);
+    return payload;
+  }
+};
+
+// src/driver.ts
+var DEFAULT_KEY_PREFIX = "agent-runtime:";
+var DEFAULT_JOB_NAME_PREFIX = "agent-runtime-job-";
+var DEFAULT_INDEX_UPDATE_RETRIES = 4;
+var STORED_JOB_KIND = "@cuylabs/agent-runtime-dapr/job";
+var STORED_JOB_VERSION = 1;
+function cloneJob(job) {
+  return structuredClone(job);
+}
+function ensureNonEmpty2(input, label) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    throw new Error(`${label} must not be empty`);
+  }
+  return trimmed;
+}
+var DaprRuntimeDriver = class {
+  name = "dapr";
+  client;
+  jobsApi;
+  keyPrefix;
+  context;
+  started = false;
+  constructor(options) {
+    this.client = new DaprSidecarClient(options);
+    this.keyPrefix = ensureNonEmpty2(options.keyPrefix ?? DEFAULT_KEY_PREFIX, "keyPrefix");
+    this.jobsApi = new DaprJobsApi({
+      client: this.client,
+      jobNamePrefix: ensureNonEmpty2(
+        options.jobNamePrefix ?? DEFAULT_JOB_NAME_PREFIX,
+        "jobNamePrefix"
+      )
+    });
+  }
+  async start(context) {
+    this.context = context;
+    this.started = true;
+    try {
+      await this.client.verifySidecar();
+    } catch (error) {
+      this.started = false;
+      this.context = void 0;
+      throw error;
+    }
+  }
+  async stop() {
+    this.started = false;
+    this.context = void 0;
+  }
+  async listJobs() {
+    const listed = /* @__PURE__ */ new Map();
+    try {
+      const queryJobs = await this.listJobsViaStateQuery();
+      for (const job of queryJobs) {
+        listed.set(job.id, job);
+      }
+    } catch (error) {
+      this.context?.logger.warn("Failed to list Dapr runtime jobs via state query", {
+        error: String(error)
+      });
+    }
+    try {
+      const indexedJobs = await this.listJobsFromIndex();
+      for (const job of indexedJobs) {
+        if (!listed.has(job.id)) {
+          listed.set(job.id, job);
+        }
+      }
+    } catch (error) {
+      this.context?.logger.warn("Failed to list Dapr runtime jobs via legacy index", {
+        error: String(error)
+      });
+    }
+    return [...listed.values()].map((job) => cloneJob(job)).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  }
+  async getJob(jobId) {
+    const current = await this.readJob(jobId);
+    return current ? cloneJob(current) : void 0;
+  }
+  async upsertJob(job) {
+    const copy = cloneJob(job);
+    await this.writeJob(copy);
+    await this.addToIndex(copy.id).catch((error) => {
+      this.context?.logger.warn("Failed to update legacy Dapr job index after upsert", {
+        jobId: copy.id,
+        error: String(error)
+      });
+    });
+    try {
+      await this.syncScheduledJob(copy);
+    } catch (error) {
+      this.context?.logger.warn("Failed to synchronize Dapr job schedule", {
+        jobId: copy.id,
+        error: String(error)
+      });
+      throw error;
+    }
+    return cloneJob(copy);
+  }
+  async removeJob(jobId) {
+    const existed = await this.readJob(jobId) !== void 0;
+    await this.client.deleteState(this.stateKeyForJob(jobId));
+    await this.removeFromIndex(jobId).catch((error) => {
+      this.context?.logger.warn("Failed to update legacy Dapr job index after removal", {
+        jobId,
+        error: String(error)
+      });
+    });
+    try {
+      await this.deleteScheduledJob(jobId);
+    } catch (error) {
+      this.context?.logger.warn("Failed to delete Dapr scheduled job", {
+        jobId,
+        error: String(error)
+      });
+    }
+    return existed;
+  }
+  /**
+   * Handle a Dapr scheduler callback routed to `/job/:name`.
+   * Returns false when the job name is not managed by this driver.
+   */
+  async handleJobTriggerByName(jobName) {
+    if (!this.started || !this.context) {
+      return false;
+    }
+    const jobId = this.fromDaprJobName(jobName);
+    if (!jobId) {
+      return false;
+    }
+    await this.context.onDue(jobId);
+    return true;
+  }
+  async syncScheduledJob(job) {
+    await this.jobsApi.syncJob(job);
+  }
+  fromDaprJobName(jobName) {
+    return this.jobsApi.fromDaprJobName(jobName);
+  }
+  stateKeyForJob(jobId) {
+    return `${this.keyPrefix}jobs/${jobId}`;
+  }
+  stateKeyForIndex() {
+    return `${this.keyPrefix}index`;
+  }
+  async readJob(jobId) {
+    const value = await this.client.getState(this.stateKeyForJob(jobId));
+    if (!value || typeof value !== "object") {
+      return void 0;
+    }
+    return this.decodeStoredJob(value);
+  }
+  async writeJob(job) {
+    const envelope = {
+      kind: STORED_JOB_KIND,
+      version: STORED_JOB_VERSION,
+      job
+    };
+    await this.client.saveState(this.stateKeyForJob(job.id), envelope);
+  }
+  async readIndex() {
+    const value = (await this.client.getStateEntry(this.stateKeyForIndex())).value;
+    if (!Array.isArray(value)) {
+      return [];
+    }
+    return [...new Set(value.filter((entry) => typeof entry === "string"))];
+  }
+  async writeIndex(ids, etag) {
+    await this.client.saveState(this.stateKeyForIndex(), [...new Set(ids)], {
+      etag,
+      concurrency: etag ? "first-write" : void 0
+    });
+  }
+  async addToIndex(jobId) {
+    await this.updateIndex((ids) => {
+      if (ids.includes(jobId)) {
+        return void 0;
+      }
+      return [...ids, jobId];
+    });
+  }
+  async removeFromIndex(jobId) {
+    await this.updateIndex((ids) => {
+      const next = ids.filter((id) => id !== jobId);
+      return next.length === ids.length ? void 0 : next;
+    });
+  }
+  async listJobsViaStateQuery() {
+    const jobs = [];
+    let token;
+    do {
+      const response = await this.client.queryState({
+        filter: {
+          EQ: {
+            kind: STORED_JOB_KIND
+          }
+        },
+        page: {
+          limit: 100,
+          ...token ? { token } : {}
+        }
+      });
+      if (!response?.results?.length) {
+        token = response?.token?.trim() || void 0;
+        continue;
+      }
+      for (const result of response.results) {
+        if (result.error || result.data === void 0) {
+          continue;
+        }
+        const job = this.decodeStoredJob(result.data);
+        if (job) {
+          jobs.push(job);
+        }
+      }
+      token = response.token?.trim() || void 0;
+    } while (token);
+    return jobs;
+  }
+  async listJobsFromIndex() {
+    const ids = await this.readIndex();
+    const jobs = await Promise.all(ids.map((id) => this.readJob(id)));
+    const present = jobs.filter((entry) => Boolean(entry));
+    if (present.length !== ids.length) {
+      await this.writeIndex(present.map((entry) => entry.id)).catch((error) => {
+        this.context?.logger.warn("Failed to compact legacy Dapr job index", {
+          error: String(error)
+        });
+      });
+    }
+    return present;
+  }
+  decodeStoredJob(value) {
+    if (!value || typeof value !== "object") {
+      return void 0;
+    }
+    const envelope = value;
+    if (envelope.kind === STORED_JOB_KIND) {
+      if (envelope.version !== STORED_JOB_VERSION) {
+        throw new Error(
+          `Unsupported Dapr runtime job record version: ${String(envelope.version)}`
+        );
+      }
+      if (envelope.job && typeof envelope.job === "object") {
+        return envelope.job;
+      }
+      return void 0;
+    }
+    return value;
+  }
+  async updateIndex(updater) {
+    for (let attempt = 0; attempt < DEFAULT_INDEX_UPDATE_RETRIES; attempt += 1) {
+      const current = await this.client.getStateEntry(this.stateKeyForIndex());
+      const ids = Array.isArray(current.value) ? [...new Set(current.value.filter((entry) => typeof entry === "string"))] : [];
+      const next = updater(ids);
+      if (!next) {
+        return;
+      }
+      try {
+        await this.writeIndex(next, current.etag);
+        return;
+      } catch (error) {
+        if (isDaprConflictError(error) && attempt + 1 < DEFAULT_INDEX_UPDATE_RETRIES) {
+          continue;
+        }
+        throw error;
+      }
+    }
+  }
+  async deleteScheduledJob(jobId) {
+    await this.jobsApi.deleteJob(jobId);
+  }
+};
+
+// src/store.ts
+import { isTerminalRunStatus } from "@cuylabs/agent-runtime";
+var DEFAULT_KEY_PREFIX2 = "agent-runtime:orchestrator:";
+var DEFAULT_INDEX_UPDATE_RETRIES2 = 4;
+var STORED_RUN_KIND = "@cuylabs/agent-runtime-dapr/orchestrator-run";
+var STORED_RUN_VERSION = 1;
+function cloneRun(run) {
+  return structuredClone(run);
+}
+function ensureNonEmpty3(input, label) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    throw new Error(`${label} must not be empty`);
+  }
+  return trimmed;
+}
+var DaprOrchestratorRunStore = class {
+  client;
+  keyPrefix;
+  constructor(options) {
+    this.client = new DaprSidecarClient(options);
+    this.keyPrefix = ensureNonEmpty3(options.keyPrefix ?? DEFAULT_KEY_PREFIX2, "keyPrefix");
+  }
+  async start() {
+    await this.client.verifySidecar();
+  }
+  async stop() {
+  }
+  async get(runId) {
+    const current = await this.readRun(runId);
+    return current ? cloneRun(current) : void 0;
+  }
+  async list() {
+    const listed = /* @__PURE__ */ new Map();
+    try {
+      const queryRuns = await this.listRunsViaStateQuery();
+      for (const run of queryRuns) {
+        listed.set(run.id, run);
+      }
+    } catch {
+    }
+    const indexedRuns = await this.listRunsFromIndex().catch(() => []);
+    for (const run of indexedRuns) {
+      if (!listed.has(run.id)) {
+        listed.set(run.id, run);
+      }
+    }
+    return [...listed.values()].map((run) => cloneRun(run)).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  }
+  async upsert(run) {
+    const copy = cloneRun(run);
+    await this.writeRun(copy);
+    await this.addToIndex(copy.id).catch(() => {
+    });
+    return cloneRun(copy);
+  }
+  async remove(runId) {
+    const existed = await this.readRun(runId) !== void 0;
+    await this.client.deleteState(this.stateKeyForRun(runId));
+    await this.removeFromIndex(runId).catch(() => {
+    });
+    return existed;
+  }
+  async cleanup(options = {}) {
+    const now = options.now ?? (() => Date.now());
+    const includeActive = options.includeActive ?? false;
+    const cutoff = options.maxAgeMs !== void 0 ? now() - options.maxAgeMs : void 0;
+    const statuses = options.statuses ? new Set(options.statuses) : void 0;
+    const runs = await this.list();
+    const eligible = runs.filter((run) => {
+      if (!includeActive && !isTerminalRunStatus(run.state.status)) {
+        return false;
+      }
+      if (statuses && !statuses.has(run.state.status)) {
+        return false;
+      }
+      return true;
+    });
+    const toDelete = /* @__PURE__ */ new Set();
+    if (cutoff !== void 0) {
+      for (const run of eligible) {
+        const updatedAtMs = Date.parse(run.updatedAt);
+        if (Number.isFinite(updatedAtMs) && updatedAtMs < cutoff) {
+          toDelete.add(run.id);
+        }
+      }
+    }
+    if (options.maxRuns !== void 0 && Number.isFinite(options.maxRuns) && options.maxRuns >= 0) {
+      const normalizedMaxRuns = Math.floor(options.maxRuns);
+      const overflow = [...eligible].sort((left, right) => {
+        const leftMs = Date.parse(left.updatedAt);
+        const rightMs = Date.parse(right.updatedAt);
+        return rightMs - leftMs;
+      }).slice(normalizedMaxRuns);
+      for (const run of overflow) {
+        toDelete.add(run.id);
+      }
+    }
+    const deletedRunIds = [];
+    for (const runId of toDelete) {
+      if (await this.remove(runId)) {
+        deletedRunIds.push(runId);
+      }
+    }
+    return {
+      deletedRuns: deletedRunIds.length,
+      deletedRunIds
+    };
+  }
+  stateKeyForRun(runId) {
+    return `${this.keyPrefix}runs/${runId}`;
+  }
+  stateKeyForIndex() {
+    return `${this.keyPrefix}index`;
+  }
+  async readRun(runId) {
+    const value = await this.client.getState(this.stateKeyForRun(runId));
+    if (!value || typeof value !== "object") {
+      return void 0;
+    }
+    return this.decodeStoredRun(value);
+  }
+  async writeRun(run) {
+    const envelope = {
+      kind: STORED_RUN_KIND,
+      version: STORED_RUN_VERSION,
+      run
+    };
+    await this.client.saveState(this.stateKeyForRun(run.id), envelope);
+  }
+  async readIndex() {
+    const value = (await this.client.getStateEntry(this.stateKeyForIndex())).value;
+    if (!Array.isArray(value)) {
+      return [];
+    }
+    return [...new Set(value.filter((entry) => typeof entry === "string"))];
+  }
+  async writeIndex(ids, etag) {
+    await this.client.saveState(this.stateKeyForIndex(), [...new Set(ids)], {
+      etag,
+      concurrency: etag ? "first-write" : void 0
+    });
+  }
+  async addToIndex(runId) {
+    await this.updateIndex((ids) => {
+      if (ids.includes(runId)) {
+        return void 0;
+      }
+      return [...ids, runId];
+    });
+  }
+  async removeFromIndex(runId) {
+    await this.updateIndex((ids) => {
+      const next = ids.filter((id) => id !== runId);
+      return next.length === ids.length ? void 0 : next;
+    });
+  }
+  async listRunsViaStateQuery() {
+    const runs = [];
+    let token;
+    do {
+      const response = await this.client.queryState({
+        filter: {
+          EQ: {
+            kind: STORED_RUN_KIND
+          }
+        },
+        page: {
+          limit: 100,
+          ...token ? { token } : {}
+        }
+      });
+      if (!response?.results?.length) {
+        token = response?.token?.trim() || void 0;
+        continue;
+      }
+      for (const result of response.results) {
+        if (result.error || result.data === void 0) {
+          continue;
+        }
+        const run = this.decodeStoredRun(result.data);
+        if (run) {
+          runs.push(run);
+        }
+      }
+      token = response.token?.trim() || void 0;
+    } while (token);
+    return runs;
+  }
+  async listRunsFromIndex() {
+    const ids = await this.readIndex();
+    const runs = await Promise.all(ids.map((id) => this.readRun(id)));
+    const present = runs.filter((entry) => Boolean(entry));
+    if (present.length !== ids.length) {
+      await this.writeIndex(present.map((entry) => entry.id)).catch(() => {
+      });
+    }
+    return present;
+  }
+  decodeStoredRun(value) {
+    if (!value || typeof value !== "object") {
+      return void 0;
+    }
+    const envelope = value;
+    if (envelope.kind === STORED_RUN_KIND) {
+      if (envelope.version !== STORED_RUN_VERSION) {
+        throw new Error(
+          `Unsupported Dapr orchestrator run record version: ${String(envelope.version)}`
+        );
+      }
+      if (envelope.run && typeof envelope.run === "object") {
+        return envelope.run;
+      }
+      return void 0;
+    }
+    return value;
+  }
+  async updateIndex(updater) {
+    for (let attempt = 0; attempt < DEFAULT_INDEX_UPDATE_RETRIES2; attempt += 1) {
+      const current = await this.client.getStateEntry(this.stateKeyForIndex());
+      const ids = Array.isArray(current.value) ? [...new Set(current.value.filter((entry) => typeof entry === "string"))] : [];
+      const next = updater(ids);
+      if (!next) {
+        return;
+      }
+      try {
+        await this.writeIndex(next, current.etag);
+        return;
+      } catch (error) {
+        if (isDaprConflictError(error) && attempt + 1 < DEFAULT_INDEX_UPDATE_RETRIES2) {
+          continue;
+        }
+        throw error;
+      }
+    }
+  }
+};
+
+// src/host/workflow-host.ts
+function buildToolRecord(agent) {
+  return Object.fromEntries(
+    agent.getTools().map((tool) => [tool.id, tool])
+  );
+}
+function createScopedSessionManager(agent) {
+  return new SessionManager(agent.getSessionManager().getStorage());
+}
+async function ensureSessionLoaded(agent, sessionId) {
+  const sessions = createScopedSessionManager(agent);
+  const storage = sessions.getStorage();
+  let existingEntries;
+  try {
+    existingEntries = await storage.read(sessionId);
+  } catch (error) {
+    if (!(error instanceof Error) || !error.message.startsWith("Session not found:")) {
+      throw error;
+    }
+    existingEntries = [];
+  }
+  if (existingEntries.length === 0) {
+    await sessions.create({
+      id: sessionId,
+      cwd: agent.cwd,
+      title: `Workflow ${sessionId}`
+    });
+    return sessions;
+  }
+  await sessions.load(sessionId);
+  return sessions;
+}
+function createUserMessage(message, createdAt) {
+  return {
+    id: randomUUID(),
+    role: "user",
+    content: message,
+    createdAt: new Date(createdAt)
+  };
+}
+function normalizeWorkflowInstanceId(explicitInstanceId, sessionId) {
+  const normalized = explicitInstanceId?.trim();
+  return normalized && normalized.length > 0 ? normalized : `turn_${sessionId}_${randomUUID().slice(0, 8)}`;
+}
+function createDaprAgentWorkflowHost(options) {
+  const now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+  const tools = buildToolRecord(options.agent);
+  const runtimeConfig = options.agent.getTurnRuntimeConfig();
+  const host = options.agent.getHost();
+  const middleware = options.agent.getMiddlewareRunner();
+  const observerBridge = options.observers && options.observers.length > 0 ? createWorkflowObserverBridge({
+    observers: options.observers,
+    payload: { message: "" },
+    trigger: "workflow"
+  }) : void 0;
+  const workflowKit = createDaprAgentTurnWorkflowKit({
+    workflowName: options.workflowName,
+    activityNames: options.activityNames,
+    observerBridge,
+    modelStepActivity: {
+      runtime: runtimeConfig,
+      tools,
+      ...options.mcpTools ? { mcpTools: options.mcpTools } : {},
+      host,
+      middleware,
+      reasoningLevel: options.agent.reasoningLevel,
+      ...options.createAbortSignal ? { createAbortSignal: options.createAbortSignal } : {},
+      now
+    },
+    toolCallActivity: {
+      tools,
+      cwd: options.agent.cwd,
+      host,
+      middleware,
+      ...options.createAbortSignal ? { createAbortSignal: options.createAbortSignal } : {},
+      now
+    },
+    commitActivity: {
+      persistMessages: async (sessionId, messages) => {
+        const sessions = await ensureSessionLoaded(options.agent, sessionId);
+        await sessions.addMessages(messages);
+      },
+      now
+    }
+  });
+  return {
+    workflowName: workflowKit.workflowName,
+    activityNames: workflowKit.activityNames,
+    register(runtime) {
+      return runtime.registerWorkflowWithName(
+        workflowKit.workflowName,
+        workflowKit.workflow
+      ).registerActivityWithName(
+        workflowKit.activities.modelStep.name,
+        workflowKit.activities.modelStep.handler
+      ).registerActivityWithName(
+        workflowKit.activities.toolCall.name,
+        workflowKit.activities.toolCall.handler
+      ).registerActivityWithName(
+        workflowKit.activities.stepCommit.name,
+        workflowKit.activities.stepCommit.handler
+      ).registerActivityWithName(
+        workflowKit.activities.outputCommit.name,
+        workflowKit.activities.outputCommit.handler
+      );
+    },
+    async createInitialState(request) {
+      const sessionId = request.sessionId?.trim() || `workflow_${randomUUID().slice(0, 8)}`;
+      const startedAt = now();
+      const sessions = await ensureSessionLoaded(options.agent, sessionId);
+      await sessions.addMessage(createUserMessage(request.message, startedAt));
+      const initialState = createAgentWorkflowTurnState({
+        sessionId,
+        startedAt,
+        maxSteps: request.maxSteps ?? runtimeConfig.maxSteps,
+        systemPrompts: await options.agent.buildSystemPrompts(
+          sessionId,
+          request.system
+        ),
+        initialMessages: snapshotAgentWorkflowMessages(sessions.getMessages())
+      });
+      return {
+        sessionId,
+        workflowInstanceId: normalizeWorkflowInstanceId(
+          request.workflowInstanceId,
+          sessionId
+        ),
+        initialState
+      };
+    },
+    async startTurn(client, request) {
+      const prepared = await this.createInitialState(request);
+      observerBridge?.updatePayload({ message: request.message });
+      await observerBridge?.notifyTaskStart(prepared.initialState);
+      const scheduleWorkflow = () => client.startWorkflow(this.workflowName, {
+        instanceId: prepared.workflowInstanceId,
+        input: prepared.initialState
+      });
+      try {
+        const ctx = observerBridge?.getOtelContext(prepared.sessionId);
+        if (ctx) {
+          const otelApi = await import("@opentelemetry/api").catch(
+            () => null
+          );
+          if (otelApi) {
+            await otelApi.context.with(
+              ctx,
+              scheduleWorkflow
+            );
+            return prepared;
+          }
+        }
+        await scheduleWorkflow();
+      } catch (error) {
+        await observerBridge?.notifyTaskError(
+          prepared.initialState,
+          error instanceof Error ? error : new Error(String(error))
+        );
+        throw error;
+      }
+      return prepared;
+    }
+  };
+}
+async function startDaprAgentWorkflowTurn(client, host, request) {
+  return host.startTurn(client, request);
+}
+
+// src/host/worker.ts
+function normalizeKey(input, label) {
+  const normalized = input.trim();
+  if (!normalized) {
+    throw new Error(`${label} must not be empty`);
+  }
+  return normalized;
+}
+function registerHosts(runtime, agents) {
+  for (const agent of agents) {
+    agent.host.register(runtime);
+  }
+}
+function validateAgents(agents) {
+  if (agents.length === 0) {
+    throw new Error("Dapr workflow worker requires at least one agent host.");
+  }
+  const lookup = /* @__PURE__ */ new Map();
+  const workflowNames = /* @__PURE__ */ new Set();
+  for (const agent of agents) {
+    const id = normalizeKey(agent.id, "agent id");
+    if (lookup.has(id)) {
+      throw new Error(`Duplicate Dapr workflow worker agent id: ${id}`);
+    }
+    const workflowName = normalizeKey(
+      agent.host.workflowName,
+      `workflow name for agent '${id}'`
+    );
+    if (workflowNames.has(workflowName)) {
+      throw new Error(
+        `Duplicate Dapr workflow name '${workflowName}' across worker agents.`
+      );
+    }
+    workflowNames.add(workflowName);
+    lookup.set(id, agent);
+    for (const alias of agent.aliases ?? []) {
+      const normalizedAlias = normalizeKey(alias, `alias for agent '${id}'`);
+      if (lookup.has(normalizedAlias)) {
+        throw new Error(
+          `Duplicate Dapr workflow worker agent alias: ${normalizedAlias}`
+        );
+      }
+      lookup.set(normalizedAlias, agent);
+    }
+  }
+  return lookup;
+}
+function createDaprWorkflowWorker(options) {
+  const agents = [...options.agents];
+  const lookup = validateAgents(agents);
+  const logger = options.logger;
+  let running = false;
+  let registered = false;
+  return {
+    runtime: options.runtime,
+    agents,
+    async start() {
+      if (running) {
+        return;
+      }
+      if (!registered) {
+        registerHosts(options.runtime, agents);
+        registered = true;
+      }
+      await options.runtime.start();
+      running = true;
+      logger?.info?.(
+        `Dapr workflow worker started with ${agents.length} agent host(s).`
+      );
+    },
+    async stop() {
+      if (!running) {
+        return;
+      }
+      logger?.info?.("Stopping workflow worker (gRPC stream cancel is expected)...");
+      await options.runtime.stop();
+      running = false;
+      logger?.info?.("Dapr workflow worker stopped.");
+    },
+    isRunning() {
+      return running;
+    },
+    listAgents() {
+      return agents;
+    },
+    getAgent(idOrAlias) {
+      const normalized = normalizeKey(idOrAlias, "agent id or alias");
+      return lookup.get(normalized);
+    }
+  };
+}
+
+// src/host/runtime-bundle.ts
+import {
+  createAgentTaskRunner
+} from "@cuylabs/agent-core";
+import {
+  createAgentRuntime
+} from "@cuylabs/agent-runtime";
+function toErrorMessage(error) {
+  if (error instanceof Error && error.message) {
+    return error.message;
+  }
+  return String(error);
+}
+function createExecutionContext(jobId, runtimeContext) {
+  return {
+    signal: runtimeContext.signal,
+    trigger: runtimeContext.trigger,
+    fallbackSessionKey: jobId
+  };
+}
+function buildTaskRunnerOptions(options, executionObserver) {
+  if (!options.taskRunnerOptions && !executionObserver) {
+    return void 0;
+  }
+  const observers = [...options.taskRunnerOptions?.observers ?? []];
+  if (executionObserver) {
+    observers.push(executionObserver);
+  }
+  return {
+    ...options.taskRunnerOptions,
+    ...observers.length > 0 ? { observers } : {}
+  };
+}
+function resolveExecutionStore(options) {
+  if (options.executionStore && options.executionStoreOptions) {
+    throw new Error(
+      "Provide either executionStore or executionStoreOptions, not both."
+    );
+  }
+  if (options.persistExecutionState === false) {
+    if (options.executionStore || options.executionStoreOptions) {
+      throw new Error(
+        "Do not provide executionStore or executionStoreOptions when persistExecutionState is false."
+      );
+    }
+    return void 0;
+  }
+  return options.executionStore ?? new DaprExecutionStore({
+    ...options.driver,
+    ...options.executionStoreOptions
+  });
+}
+function createExecutor(runTask, options) {
+  return async (job, runtimeContext) => {
+    try {
+      const result = await runTask(
+        job.payload,
+        createExecutionContext(job.id, runtimeContext)
+      );
+      if (options.onTaskResult) {
+        await options.onTaskResult({
+          jobId: job.id,
+          payload: job.payload,
+          runtimeContext,
+          result
+        });
+      }
+      return { status: "ok" };
+    } catch (error) {
+      const message = toErrorMessage(error);
+      if (options.onTaskError) {
+        try {
+          await options.onTaskError({
+            jobId: job.id,
+            payload: job.payload,
+            runtimeContext,
+            error,
+            message
+          });
+        } catch {
+        }
+      }
+      return {
+        status: "error",
+        error: message
+      };
+    }
+  };
+}
+function createDaprAgentRuntime(options) {
+  const driver = new DaprRuntimeDriver(options.driver);
+  const executionStore = resolveExecutionStore(options);
+  if (options.taskRunner && executionStore) {
+    throw new Error(
+      "Automatic Dapr execution persistence requires createDaprAgentRuntime(...) to create the task runner. Remove taskRunner or set persistExecutionState to false."
+    );
+  }
+  const executionObserver = executionStore ? createDaprExecutionObserver({ store: executionStore }) : void 0;
+  const runTask = options.taskRunner ?? createAgentTaskRunner(
+    options.agent,
+    buildTaskRunnerOptions(options, executionObserver)
+  );
+  const runtime = createAgentRuntime({
+    ...options.runtime,
+    driver,
+    execute: createExecutor(runTask, options)
+  });
+  const handleDaprJob = createDaprHttpJobHandler({ driver });
+  return {
+    runtime,
+    driver,
+    runTask,
+    executionStore,
+    handleDaprJob
+  };
+}
+
+// src/host/http.ts
+import {
+  createServer
+} from "http";
+function json(value, status = 200) {
+  if (status === 204 || status === 304) {
+    return new Response(null, { status });
+  }
+  return new Response(JSON.stringify(value), {
+    status,
+    headers: {
+      "content-type": "application/json; charset=utf-8"
+    }
+  });
+}
+function text(message, status = 200) {
+  return new Response(message, { status });
+}
+function toErrorMessage2(error) {
+  if (error instanceof Error && error.message) {
+    return error.message;
+  }
+  return String(error);
+}
+function splitPath(pathname) {
+  return pathname.split("/").map((part) => part.trim()).filter(Boolean);
+}
+async function parseJsonBody(request) {
+  const raw = await request.text();
+  if (!raw.trim()) {
+    return {};
+  }
+  return JSON.parse(raw);
+}
+function resolveSingleAgent(app) {
+  const agents = app.listAgents();
+  return agents.length === 1 ? agents[0] : void 0;
+}
+async function resolveReadiness(app) {
+  if (app.checkReadiness) {
+    return await app.checkReadiness();
+  }
+  const running = app.isRunning();
+  return {
+    ok: running,
+    checks: [
+      {
+        name: "app",
+        ok: running,
+        ...running ? {} : { detail: "Host app is not running." }
+      }
+    ]
+  };
+}
+async function writeResponse(response, nodeResponse) {
+  nodeResponse.statusCode = response.status;
+  response.headers.forEach((value, key) => {
+    nodeResponse.setHeader(key, value);
+  });
+  if (!response.body) {
+    nodeResponse.end();
+    return;
+  }
+  const arrayBuffer = await response.arrayBuffer();
+  nodeResponse.end(Buffer.from(arrayBuffer));
+}
+async function toRequest(nodeRequest) {
+  const origin = `http://${nodeRequest.headers.host ?? "127.0.0.1"}`;
+  const url = new URL(nodeRequest.url ?? "/", origin);
+  const method = nodeRequest.method ?? "GET";
+  if (method === "GET" || method === "HEAD") {
+    return new Request(url, { method });
+  }
+  const body = await new Promise((resolve, reject) => {
+    const chunks = [];
+    nodeRequest.on("data", (chunk) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    });
+    nodeRequest.once("end", () => resolve(Buffer.concat(chunks)));
+    nodeRequest.once("error", reject);
+  });
+  return new Request(url, {
+    method,
+    headers: nodeRequest.headers,
+    body,
+    duplex: "half"
+  });
+}
+async function handleExecutionLookup(agent, sessionId) {
+  if (!agent.runtimeBundle.executionStore) {
+    return json(
+      { error: "Execution persistence is disabled for this agent." },
+      501
+    );
+  }
+  const record = await agent.runtimeBundle.executionStore.getExecution(sessionId);
+  if (!record) {
+    return json({ error: `Execution not found: ${sessionId}` }, 404);
+  }
+  return json(record);
+}
+async function handleCheckpointLookup(agent, sessionId) {
+  if (!agent.runtimeBundle.executionStore) {
+    return json(
+      { error: "Execution persistence is disabled for this agent." },
+      501
+    );
+  }
+  const checkpoints = await agent.runtimeBundle.executionStore.listCheckpoints(sessionId);
+  return json(checkpoints);
+}
+async function handleWorkflowLookup(workflowClient, instanceId) {
+  if (!workflowClient) {
+    return json({ error: "Workflow client is not configured." }, 501);
+  }
+  const workflow = await workflowClient.getWorkflow(instanceId);
+  if (!workflow) {
+    return json({ error: `Workflow not found: ${instanceId}` }, 404);
+  }
+  return json(workflow);
+}
+function createDaprHostHttpHandler(options) {
+  return async function handle(request) {
+    const url = new URL(request.url);
+    const segments = splitPath(url.pathname);
+    if (request.method === "GET" && segments.length === 1 && (segments[0] === "health" || segments[0] === "healthz")) {
+      return json({
+        status: "ok",
+        mode: "liveness",
+        running: options.app.isRunning(),
+        agents: options.app.listAgents().map((agent) => ({
+          id: agent.id,
+          aliases: agent.aliases,
+          workflowName: agent.workflowHost.workflowName
+        }))
+      });
+    }
+    if (request.method === "GET" && segments.length === 1 && (segments[0] === "ready" || segments[0] === "readyz")) {
+      const readiness = await resolveReadiness(options.app);
+      return json(
+        {
+          status: readiness.ok ? "ready" : "not-ready",
+          mode: "readiness",
+          ready: readiness.ok,
+          checks: readiness.checks,
+          agents: options.app.listAgents().map((agent) => ({
+            id: agent.id,
+            aliases: agent.aliases,
+            workflowName: agent.workflowHost.workflowName
+          }))
+        },
+        readiness.ok ? 200 : 503
+      );
+    }
+    if (request.method === "GET" && segments.length === 1 && segments[0] === "agents") {
+      return json(
+        options.app.listAgents().map((agent) => ({
+          id: agent.id,
+          aliases: agent.aliases,
+          description: agent.description,
+          workflowName: agent.workflowHost.workflowName
+        }))
+      );
+    }
+    if (request.method === "POST" && segments.length === 2 && segments[0] === "job") {
+      const result = await options.app.handleScheduledJob(segments[1]);
+      return json(result, result.status);
+    }
+    if (request.method === "POST" && segments.length === 2 && segments[0] === "agents" && segments[1] === "run") {
+      const body = await parseJsonBody(request);
+      const selectedId = body.agentId?.trim() || resolveSingleAgent(options.app)?.id;
+      if (!selectedId) {
+        return json(
+          {
+            error: "agentId is required when the host app manages multiple agents."
+          },
+          400
+        );
+      }
+      try {
+        const result = await options.app.runAgent(
+          selectedId,
+          body
+        );
+        return json(result);
+      } catch (error) {
+        return json({ error: toErrorMessage2(error) }, 404);
+      }
+    }
+    if (request.method === "POST" && segments.length === 2 && segments[0] === "agents" && segments[1] === "workflow") {
+      if (!options.workflowClient) {
+        return json({ error: "Workflow client is not configured." }, 501);
+      }
+      const body = await parseJsonBody(request);
+      const selectedId = body.agentId?.trim() || resolveSingleAgent(options.app)?.id;
+      if (!selectedId) {
+        return json(
+          {
+            error: "agentId is required when the host app manages multiple agents."
+          },
+          400
+        );
+      }
+      const agent = options.app.getAgent(selectedId);
+      if (!agent) {
+        return json({ error: `Unknown agent: ${selectedId}` }, 404);
+      }
+      try {
+        const result = await agent.workflowHost.startTurn(
+          options.workflowClient,
+          body
+        );
+        return json({
+          instanceId: result.workflowInstanceId,
+          agentId: agent.id,
+          workflowName: agent.workflowHost.workflowName,
+          sessionId: result.sessionId
+        }, 202);
+      } catch (error) {
+        return json({ error: toErrorMessage2(error) }, 500);
+      }
+    }
+    if (segments[0] === "agents" && segments.length >= 2) {
+      const agent = options.app.getAgent(segments[1]);
+      if (!agent) {
+        return json({ error: `Unknown agent: ${segments[1]}` }, 404);
+      }
+      if (request.method === "POST" && segments.length === 3 && segments[2] === "run") {
+        const body = await parseJsonBody(request);
+        const result = await options.app.runAgent(agent.id, body);
+        return json(result);
+      }
+      if (request.method === "POST" && segments.length === 3 && segments[2] === "workflow") {
+        if (!options.workflowClient) {
+          return json({ error: "Workflow client is not configured." }, 501);
+        }
+        const body = await parseJsonBody(request);
+        try {
+          const result = await agent.workflowHost.startTurn(
+            options.workflowClient,
+            body
+          );
+          return json({
+            instanceId: result.workflowInstanceId,
+            agentId: agent.id,
+            workflowName: agent.workflowHost.workflowName,
+            sessionId: result.sessionId
+          }, 202);
+        } catch (error) {
+          return json({ error: toErrorMessage2(error) }, 500);
+        }
+      }
+      if (request.method === "GET" && segments.length === 4 && segments[2] === "executions") {
+        return await handleExecutionLookup(agent, segments[3]);
+      }
+      if (request.method === "GET" && segments.length === 5 && segments[2] === "executions" && segments[4] === "checkpoints") {
+        return await handleCheckpointLookup(agent, segments[3]);
+      }
+      if (request.method === "GET" && segments.length === 4 && segments[2] === "workflows") {
+        return await handleWorkflowLookup(options.workflowClient, segments[3]);
+      }
+    }
+    return text("Not found", 404);
+  };
+}
+async function startDaprHostHttpServer(options) {
+  const handler = createDaprHostHttpHandler(options);
+  const server = createServer(async (req, res) => {
+    try {
+      const request = await toRequest(req);
+      const response = await handler(request);
+      await writeResponse(response, res);
+    } catch (error) {
+      await writeResponse(json({ error: toErrorMessage2(error) }, 500), res);
+    }
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(options.port, options.host, () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    throw new Error("Unable to resolve Dapr host HTTP server address.");
+  }
+  return {
+    server,
+    origin: `http://${address.address}:${address.port}`,
+    close() {
+      return new Promise((resolve, reject) => {
+        server.close((error) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve();
+        });
+      });
+    }
+  };
+}
+
+// src/host/runner.ts
+import process from "process";
+function resolveDaprConfig(options) {
+  const daprHost = process.env.DAPR_HOST ?? "127.0.0.1";
+  const daprHttpPort = process.env.DAPR_HTTP_PORT ?? "3500";
+  return {
+    daprHttpEndpoint: options.daprHttpEndpoint ?? `http://${daprHost}:${daprHttpPort}`,
+    stateStoreName: options.stateStoreName ?? "statestore",
+    workflowComponent: options.workflowComponent ?? "dapr"
+  };
+}
+function buildObservers(options) {
+  const observers = [];
+  if (options.logging !== false) {
+    observers.push(
+      createDaprLoggingObserver({
+        prefix: options.logPrefix ?? `[${options.name}]`
+      })
+    );
+  }
+  if (options.observers) {
+    observers.push(...options.observers);
+  }
+  return observers;
+}
+function toErrorMessage3(error) {
+  if (error instanceof Error && error.message) {
+    return error.message;
+  }
+  return String(error);
+}
+function createAggregateLifecycleError(message, errors) {
+  if (errors.length === 1 && errors[0] instanceof Error) {
+    return errors[0];
+  }
+  return new AggregateError(errors, message);
+}
+async function stopRuntimeSafely(runtime, errors) {
+  try {
+    await runtime.stop();
+  } catch (error) {
+    errors.push(error);
+  }
+}
+async function collectSingleRunnerReadiness(params) {
+  const checks = [];
+  const runtimeStarted = params.runtimeBundle.runtime.status().started;
+  const workerRunning = params.worker.isRunning();
+  checks.push({
+    name: "runtime",
+    ok: runtimeStarted,
+    ...runtimeStarted ? {} : { detail: "Agent runtime is not started." }
+  });
+  checks.push({
+    name: "workflow-worker",
+    ok: workerRunning,
+    ...workerRunning ? {} : { detail: "Workflow worker is not running." }
+  });
+  const sidecarClient = new DaprSidecarClient({
+    stateStoreName: params.config.stateStoreName,
+    daprHttpEndpoint: params.config.daprHttpEndpoint,
+    ...params.driverOptions,
+    verifySidecarOnStart: true
+  });
+  try {
+    await sidecarClient.verifySidecar();
+    checks.push({ name: "dapr-sidecar", ok: true });
+  } catch (error) {
+    checks.push({
+      name: "dapr-sidecar",
+      ok: false,
+      detail: toErrorMessage3(error)
+    });
+  }
+  try {
+    await sidecarClient.getStateEntry("__agent-runtime-ready__");
+    checks.push({ name: "state-store", ok: true });
+  } catch (error) {
+    checks.push({
+      name: "state-store",
+      ok: false,
+      detail: toErrorMessage3(error)
+    });
+  }
+  return {
+    ok: checks.every((check) => check.ok),
+    checks
+  };
+}
+function createDaprAgentRunner(options) {
+  const { agent } = options;
+  const name = options.name ?? agent.name;
+  const config = resolveDaprConfig({ ...options, name });
+  const observers = buildObservers({ ...options, name });
+  const workflowHost = createDaprAgentWorkflowHost({
+    agent,
+    observers,
+    ...options.workflowHost
+  });
+  const runtimeBundle = createDaprAgentRuntime({
+    agent,
+    driver: {
+      stateStoreName: config.stateStoreName,
+      daprHttpEndpoint: config.daprHttpEndpoint,
+      ...options.driverOptions
+    },
+    taskRunnerOptions: {
+      ...options.runtimeOptions?.taskRunnerOptions,
+      observers
+    },
+    ...options.runtimeOptions
+  });
+  const worker = createDaprWorkflowWorker({
+    runtime: options.workflowRuntime,
+    agents: [
+      {
+        id: name,
+        host: workflowHost,
+        aliases: options.aliases,
+        description: options.description
+      }
+    ]
+  });
+  const workflowClient = new DaprWorkflowClient({
+    daprHttpEndpoint: config.daprHttpEndpoint,
+    workflowComponent: config.workflowComponent
+  });
+  const agentInfo = {
+    id: name,
+    aliases: options.aliases ?? [],
+    description: options.description,
+    workflowHost,
+    runtimeBundle: { executionStore: runtimeBundle.executionStore }
+  };
+  const app = {
+    isRunning: () => worker.isRunning(),
+    listAgents: () => [agentInfo],
+    getAgent: (id) => id === name || (options.aliases ?? []).includes(id) ? agentInfo : void 0,
+    runAgent: async (_id, payload) => runtimeBundle.runTask(payload, {
+      trigger: "http",
+      fallbackSessionKey: `${name}-http`
+    }),
+    handleScheduledJob: async (jobName) => runtimeBundle.handleDaprJob(jobName),
+    checkReadiness: async () => await collectSingleRunnerReadiness({
+      config,
+      driverOptions: options.driverOptions,
+      runtimeBundle,
+      worker
+    })
+  };
+  let started = false;
+  let httpServer;
+  function log(message) {
+    if (options.logging !== false) {
+      console.log(`[${name}] ${message}`);
+    }
+  }
+  return {
+    name,
+    workflowHost,
+    runtimeBundle,
+    worker,
+    workflowClient,
+    async start() {
+      if (started) return;
+      const startupErrors = [];
+      try {
+        await runtimeBundle.runtime.start();
+        try {
+          await worker.start();
+        } catch (error) {
+          startupErrors.push(error);
+          await stopRuntimeSafely(runtimeBundle.runtime, startupErrors);
+          throw createAggregateLifecycleError(
+            "Failed to start Dapr agent runner cleanly.",
+            startupErrors
+          );
+        }
+        started = true;
+        log("Worker started");
+      } catch (error) {
+        if (error instanceof Error) {
+          throw error;
+        }
+        throw new Error(String(error));
+      }
+    },
+    async serve(serveOptions) {
+      if (!started) {
+        await this.start();
+      }
+      const port = serveOptions?.port ?? 3e3;
+      httpServer = await startDaprHostHttpServer({
+        app,
+        workflowClient,
+        port,
+        host: serveOptions?.host
+      });
+      log(`HTTP listening on ${httpServer.origin}`);
+      await new Promise((resolve) => {
+        let shuttingDown = false;
+        const shutdown = async (signal) => {
+          if (shuttingDown) return;
+          shuttingDown = true;
+          log(`${signal} \u2014 shutting down`);
+          await this.stop();
+          resolve();
+        };
+        process.once("SIGINT", () => void shutdown("SIGINT"));
+        process.once("SIGTERM", () => void shutdown("SIGTERM"));
+      });
+    },
+    async run(message, runOptions) {
+      if (!started) {
+        throw new Error(
+          "Runner is not started. Call start() or serve() first."
+        );
+      }
+      return runtimeBundle.runTask(
+        { message, sessionId: runOptions?.sessionId },
+        { trigger: "programmatic", fallbackSessionKey: `${name}-run` }
+      );
+    },
+    async stop() {
+      const stopErrors = [];
+      if (httpServer) {
+        try {
+          await httpServer.close();
+        } catch (error) {
+          stopErrors.push(error);
+        } finally {
+          httpServer = void 0;
+        }
+      }
+      try {
+        await worker.stop();
+      } catch (error) {
+        stopErrors.push(error);
+      }
+      await stopRuntimeSafely(runtimeBundle.runtime, stopErrors);
+      started = false;
+      log("Stopped");
+      if (stopErrors.length > 0) {
+        throw createAggregateLifecycleError(
+          "Failed to stop Dapr agent runner cleanly.",
+          stopErrors
+        );
+      }
+    }
+  };
+}
+function createDaprMultiAgentRunner(options) {
+  const config = resolveDaprConfig({
+    ...options,
+    // Satisfy resolveDaprConfig's DaprAgentRunnerOptions shape
+    agent: options.agents[0].agent,
+    name: "multi-agent"
+  });
+  const loggingEnabled = options.logging !== false;
+  const entries = options.agents.map((ac) => {
+    const observers = [];
+    if (loggingEnabled) {
+      observers.push(createDaprLoggingObserver({ prefix: `[${ac.name}]` }));
+    }
+    if (options.observers) {
+      observers.push(...options.observers);
+    }
+    const workflowHost = createDaprAgentWorkflowHost({
+      agent: ac.agent,
+      workflowName: `${ac.name}:turn`,
+      observers
+    });
+    const runtimeBundle = createDaprAgentRuntime({
+      agent: ac.agent,
+      driver: {
+        stateStoreName: config.stateStoreName,
+        daprHttpEndpoint: config.daprHttpEndpoint,
+        ...options.driverOptions
+      },
+      taskRunnerOptions: { observers }
+    });
+    const info = {
+      id: ac.name,
+      aliases: ac.aliases ?? [],
+      description: ac.description,
+      workflowHost,
+      runtimeBundle: { executionStore: runtimeBundle.executionStore }
+    };
+    return { ...ac, workflowHost, runtimeBundle, info };
+  });
+  const worker = createDaprWorkflowWorker({
+    runtime: options.workflowRuntime,
+    agents: entries.map((e) => ({
+      id: e.name,
+      host: e.workflowHost,
+      aliases: e.aliases,
+      description: e.description
+    }))
+  });
+  const workflowClient = new DaprWorkflowClient({
+    daprHttpEndpoint: config.daprHttpEndpoint,
+    workflowComponent: config.workflowComponent
+  });
+  const agentMap = new Map(entries.map((e) => [e.name, e]));
+  for (const e of entries) {
+    for (const alias of e.aliases ?? []) {
+      agentMap.set(alias, e);
+    }
+  }
+  const app = {
+    isRunning: () => worker.isRunning(),
+    listAgents: () => entries.map((e) => e.info),
+    getAgent: (id) => agentMap.get(id)?.info,
+    runAgent: async (id, payload) => {
+      const entry = agentMap.get(id);
+      if (!entry) throw new Error(`Unknown agent: ${id}`);
+      return entry.runtimeBundle.runTask(payload, {
+        trigger: "http",
+        fallbackSessionKey: `${entry.name}-http`
+      });
+    },
+    handleScheduledJob: async (jobName) => {
+      for (const e of entries) {
+        const result = await e.runtimeBundle.handleDaprJob(jobName);
+        if (result.handled) return result;
+      }
+      return { handled: false, status: 404 };
+    },
+    checkReadiness: async () => {
+      const checks = [];
+      const workerRunning = worker.isRunning();
+      const runtimesRunning = entries.every(
+        (entry) => entry.runtimeBundle.runtime.status().started
+      );
+      checks.push({
+        name: "workflow-worker",
+        ok: workerRunning,
+        ...workerRunning ? {} : { detail: "Workflow worker is not running." }
+      });
+      checks.push({
+        name: "runtimes",
+        ok: runtimesRunning,
+        ...runtimesRunning ? {} : { detail: "One or more agent runtimes are not started." }
+      });
+      const sidecarClient = new DaprSidecarClient({
+        stateStoreName: config.stateStoreName,
+        daprHttpEndpoint: config.daprHttpEndpoint,
+        ...options.driverOptions,
+        verifySidecarOnStart: true
+      });
+      try {
+        await sidecarClient.verifySidecar();
+        checks.push({ name: "dapr-sidecar", ok: true });
+      } catch (error) {
+        checks.push({
+          name: "dapr-sidecar",
+          ok: false,
+          detail: toErrorMessage3(error)
+        });
+      }
+      try {
+        await sidecarClient.getStateEntry("__agent-runtime-ready__");
+        checks.push({ name: "state-store", ok: true });
+      } catch (error) {
+        checks.push({
+          name: "state-store",
+          ok: false,
+          detail: toErrorMessage3(error)
+        });
+      }
+      return {
+        ok: checks.every((check) => check.ok),
+        checks
+      };
+    }
+  };
+  let started = false;
+  let httpServer;
+  function log(message) {
+    if (loggingEnabled) {
+      console.log(`[multi-agent] ${message}`);
+    }
+  }
+  return {
+    async start() {
+      if (started) return;
+      const startedRuntimes = [];
+      const startupErrors = [];
+      try {
+        for (const entry of entries) {
+          await entry.runtimeBundle.runtime.start();
+          startedRuntimes.push(entry.runtimeBundle.runtime);
+        }
+        try {
+          await worker.start();
+        } catch (error) {
+          startupErrors.push(error);
+          for (const runtime of startedRuntimes.reverse()) {
+            await stopRuntimeSafely(runtime, startupErrors);
+          }
+          throw createAggregateLifecycleError(
+            "Failed to start Dapr multi-agent runner cleanly.",
+            startupErrors
+          );
+        }
+        started = true;
+        log(
+          `Worker started \u2014 agents: ${entries.map((e) => e.name).join(", ")}`
+        );
+      } catch (error) {
+        if (error instanceof Error) {
+          throw error;
+        }
+        throw new Error(String(error));
+      }
+    },
+    async serve(serveOptions) {
+      if (!started) {
+        await this.start();
+      }
+      const port = serveOptions?.port ?? 3e3;
+      httpServer = await startDaprHostHttpServer({
+        app,
+        workflowClient,
+        port,
+        host: serveOptions?.host
+      });
+      log(`HTTP listening on ${httpServer.origin}`);
+      await new Promise((resolve) => {
+        let shuttingDown = false;
+        const shutdown = async (signal) => {
+          if (shuttingDown) return;
+          shuttingDown = true;
+          log(`${signal} \u2014 shutting down`);
+          await this.stop();
+          resolve();
+        };
+        process.once("SIGINT", () => void shutdown("SIGINT"));
+        process.once("SIGTERM", () => void shutdown("SIGTERM"));
+      });
+    },
+    async stop() {
+      const stopErrors = [];
+      if (httpServer) {
+        try {
+          await httpServer.close();
+        } catch (error) {
+          stopErrors.push(error);
+        } finally {
+          httpServer = void 0;
+        }
+      }
+      try {
+        await worker.stop();
+      } catch (error) {
+        stopErrors.push(error);
+      }
+      for (const entry of entries) {
+        await stopRuntimeSafely(entry.runtimeBundle.runtime, stopErrors);
+      }
+      started = false;
+      log("Stopped");
+      if (stopErrors.length > 0) {
+        throw createAggregateLifecycleError(
+          "Failed to stop Dapr multi-agent runner cleanly.",
+          stopErrors
+        );
+      }
+    }
+  };
+}
+
+export {
+  createDaprHttpJobHandler,
+  DaprRuntimeDriver,
+  DaprOrchestratorRunStore,
+  DaprServiceInvoker,
+  invokeRemoteAgentRun,
+  createDaprAgentWorkflowHost,
+  startDaprAgentWorkflowTurn,
+  createDaprWorkflowWorker,
+  createDaprAgentRuntime,
+  createDaprHostHttpHandler,
+  startDaprHostHttpServer,
+  createDaprAgentRunner,
+  createDaprMultiAgentRunner
+};