@cuylabs/agent-runtime-dapr 0.5.0

package/dist/chunk-2CEICSJH.js

@@ -0,0 +1,809 @@
+import {
+  DaprSidecarClient,
+  isDaprConflictError
+} from "./chunk-A34CHK2E.js";
+
+// src/execution/store.ts
+var DEFAULT_KEY_PREFIX = "agent-runtime:execution:";
+var STORED_EXECUTION_KIND = "@cuylabs/agent-runtime-dapr/execution";
+var STORED_EXECUTION_CHECKPOINT_KIND = "@cuylabs/agent-runtime-dapr/execution-checkpoint";
+var STORED_EXECUTION_VERSION = 1;
+var DEFAULT_INDEX_UPDATE_RETRIES = 4;
+function ensureNonEmpty(input, label) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    throw new Error(`${label} must not be empty`);
+  }
+  return trimmed;
+}
+function cloneRecord(value) {
+  return structuredClone(value);
+}
+function serializeError(error) {
+  return {
+    name: error.name,
+    message: error.message,
+    ...error.stack ? { stack: error.stack } : {}
+  };
+}
+function toJsonSafe(value) {
+  if (value === void 0) {
+    return value;
+  }
+  const serialized = JSON.stringify(value, (_key, currentValue) => {
+    if (currentValue instanceof Error) {
+      return serializeError(currentValue);
+    }
+    return currentValue;
+  });
+  if (serialized === void 0) {
+    return value;
+  }
+  return JSON.parse(serialized);
+}
+function toSerializableContext(context) {
+  return {
+    ...context.trigger ? { trigger: context.trigger } : {},
+    ...context.fallbackSessionKey ? { fallbackSessionKey: context.fallbackSessionKey } : {}
+  };
+}
+function toSerializableSnapshot(snapshot) {
+  return {
+    sessionId: snapshot.sessionId,
+    response: snapshot.response,
+    usage: cloneRecord(snapshot.usage),
+    toolCalls: snapshot.toolCalls.map((toolCall) => ({
+      name: toolCall.name,
+      result: toJsonSafe(toolCall.result)
+    })),
+    eventCount: snapshot.eventCount,
+    ...snapshot.activeStep !== void 0 ? { activeStep: snapshot.activeStep } : {},
+    ...snapshot.lastEvent !== void 0 ? { lastEvent: toJsonSafe(snapshot.lastEvent) } : {},
+    ...snapshot.error ? { error: snapshot.error } : {},
+    startedAt: snapshot.startedAt,
+    updatedAt: snapshot.updatedAt,
+    turnState: toJsonSafe(cloneRecord(snapshot.turnState))
+  };
+}
+function toExecutionRecord(run, snapshot) {
+  return {
+    sessionId: run.sessionId,
+    payload: toJsonSafe(run.payload),
+    context: toSerializableContext(run.context),
+    status: "running",
+    startedAt: run.startedAt,
+    updatedAt: snapshot.updatedAt,
+    checkpointCount: 0,
+    snapshot: toSerializableSnapshot(snapshot)
+  };
+}
+function buildCheckpointId(checkpoint) {
+  const createdAtMs = Date.parse(checkpoint.createdAt);
+  const safeTimestamp = Number.isFinite(createdAtMs) ? createdAtMs.toString() : checkpoint.createdAt.replace(/[^0-9]/g, "");
+  const paddedEventCount = String(checkpoint.snapshot.eventCount).padStart(
+    6,
+    "0"
+  );
+  return `${safeTimestamp}-${paddedEventCount}-${checkpoint.reason}`;
+}
+var DaprExecutionStore = class {
+  client;
+  keyPrefix;
+  constructor(options) {
+    this.client = new DaprSidecarClient(options);
+    this.keyPrefix = ensureNonEmpty(
+      options.keyPrefix ?? DEFAULT_KEY_PREFIX,
+      "keyPrefix"
+    );
+  }
+  async getExecution(sessionId) {
+    const value = await this.client.getState(
+      this.stateKeyForExecution(sessionId)
+    );
+    const decoded = this.decodeExecution(value);
+    return decoded ? cloneRecord(decoded) : void 0;
+  }
+  async listExecutions() {
+    const records = [];
+    let token;
+    do {
+      const response = await this.client.queryState({
+        filter: {
+          EQ: {
+            kind: STORED_EXECUTION_KIND
+          }
+        },
+        page: {
+          limit: 100,
+          ...token ? { token } : {}
+        }
+      });
+      for (const result of response?.results ?? []) {
+        if (result.error || result.data === void 0) {
+          continue;
+        }
+        const execution = this.decodeExecution(result.data);
+        if (execution) {
+          records.push(execution);
+        }
+      }
+      token = response?.token?.trim() || void 0;
+    } while (token);
+    return records.map((record) => cloneRecord(record)).sort((left, right) => left.startedAt.localeCompare(right.startedAt));
+  }
+  async listCheckpoints(sessionId) {
+    const indexed = await this.listCheckpointsFromIndex(sessionId);
+    if (indexed) {
+      return indexed.map((record) => cloneRecord(record)).sort((left, right) => {
+        const createdAtSort = left.createdAt.localeCompare(right.createdAt);
+        if (createdAtSort !== 0) {
+          return createdAtSort;
+        }
+        return left.id.localeCompare(right.id);
+      });
+    }
+    const records = [];
+    let token;
+    do {
+      const response = await this.client.queryState({
+        filter: {
+          EQ: {
+            kind: STORED_EXECUTION_CHECKPOINT_KIND
+          }
+        },
+        page: {
+          limit: 200,
+          ...token ? { token } : {}
+        }
+      });
+      for (const result of response?.results ?? []) {
+        if (result.error || result.data === void 0) {
+          continue;
+        }
+        const checkpoint = this.decodeCheckpoint(result.data);
+        if (checkpoint && checkpoint.sessionId === sessionId) {
+          records.push(checkpoint);
+        }
+      }
+      token = response?.token?.trim() || void 0;
+    } while (token);
+    return records.map((record) => cloneRecord(record)).sort((left, right) => {
+      const createdAtSort = left.createdAt.localeCompare(right.createdAt);
+      if (createdAtSort !== 0) {
+        return createdAtSort;
+      }
+      return left.id.localeCompare(right.id);
+    });
+  }
+  async recordStart(run, snapshot) {
+    await this.writeExecution(toExecutionRecord(run, snapshot));
+  }
+  async recordCheckpoint(checkpoint) {
+    const record = {
+      id: buildCheckpointId(checkpoint),
+      sessionId: checkpoint.run.sessionId,
+      payload: toJsonSafe(checkpoint.run.payload),
+      context: toSerializableContext(checkpoint.run.context),
+      startedAt: checkpoint.run.startedAt,
+      reason: checkpoint.reason,
+      snapshot: toSerializableSnapshot(checkpoint.snapshot),
+      ...checkpoint.event !== void 0 ? { event: toJsonSafe(checkpoint.event) } : {},
+      createdAt: checkpoint.createdAt
+    };
+    await this.writeCheckpoint(record);
+    await this.addCheckpointToIndex(record.sessionId, record.id).catch(() => {
+    });
+    const current = await this.getExecution(checkpoint.run.sessionId);
+    const next = current ?? toExecutionRecord(checkpoint.run, checkpoint.snapshot);
+    next.updatedAt = checkpoint.snapshot.updatedAt;
+    next.lastCheckpointReason = checkpoint.reason;
+    next.checkpointCount = (current?.checkpointCount ?? 0) + 1;
+    next.snapshot = toSerializableSnapshot(checkpoint.snapshot);
+    await this.writeExecution(next);
+  }
+  async recordCompletion(run, result, snapshot) {
+    const current = await this.getExecution(run.sessionId);
+    const next = current ?? toExecutionRecord(run, snapshot);
+    next.status = "completed";
+    next.updatedAt = snapshot.updatedAt;
+    next.completedAt = snapshot.updatedAt;
+    next.snapshot = toSerializableSnapshot(snapshot);
+    next.result = toJsonSafe(result);
+    delete next.error;
+    await this.writeExecution(next);
+  }
+  async recordError(run, error, snapshot) {
+    const current = await this.getExecution(run.sessionId);
+    const next = current ?? toExecutionRecord(run, snapshot);
+    next.status = "failed";
+    next.updatedAt = snapshot.updatedAt;
+    next.completedAt = snapshot.updatedAt;
+    next.snapshot = toSerializableSnapshot(snapshot);
+    next.error = serializeError(error);
+    delete next.result;
+    await this.writeExecution(next);
+  }
+  async cleanup(options = {}) {
+    const now = options.now ?? (() => Date.now());
+    const includeRunning = options.includeRunning ?? false;
+    const cutoff = options.maxAgeMs !== void 0 ? now() - options.maxAgeMs : void 0;
+    const executions = await this.listExecutions();
+    const eligible = executions.filter(
+      (execution) => includeRunning ? true : execution.status !== "running"
+    );
+    const toDelete = /* @__PURE__ */ new Set();
+    let deletedCheckpoints = 0;
+    let trimmedSessions = 0;
+    if (cutoff !== void 0) {
+      for (const execution of eligible) {
+        const referenceMs = Date.parse(execution.completedAt ?? execution.updatedAt);
+        if (Number.isFinite(referenceMs) && referenceMs < cutoff) {
+          toDelete.add(execution.sessionId);
+        }
+      }
+    }
+    if (options.maxExecutions !== void 0 && Number.isFinite(options.maxExecutions) && options.maxExecutions >= 0) {
+      const normalizedMaxExecutions = Math.floor(options.maxExecutions);
+      const overflow = [...eligible].sort((left, right) => {
+        const leftMs = Date.parse(left.completedAt ?? left.updatedAt);
+        const rightMs = Date.parse(right.completedAt ?? right.updatedAt);
+        return rightMs - leftMs;
+      }).slice(normalizedMaxExecutions);
+      for (const execution of overflow) {
+        toDelete.add(execution.sessionId);
+      }
+    }
+    const deletedExecutionIds = [];
+    for (const sessionId of toDelete) {
+      deletedCheckpoints += await this.deleteExecutionRecord(sessionId);
+      deletedExecutionIds.push(sessionId);
+    }
+    if (options.maxCheckpointsPerExecution !== void 0 && Number.isFinite(options.maxCheckpointsPerExecution) && options.maxCheckpointsPerExecution >= 0) {
+      const normalizedCheckpointLimit = Math.floor(options.maxCheckpointsPerExecution);
+      for (const execution of executions) {
+        if (toDelete.has(execution.sessionId)) {
+          continue;
+        }
+        if (!includeRunning && execution.status === "running") {
+          continue;
+        }
+        const checkpoints = await this.listCheckpoints(execution.sessionId);
+        if (checkpoints.length <= normalizedCheckpointLimit) {
+          continue;
+        }
+        const checkpointOverflow = checkpoints.slice(
+          0,
+          checkpoints.length - normalizedCheckpointLimit
+        );
+        const retained = checkpoints.slice(checkpoints.length - normalizedCheckpointLimit);
+        for (const checkpoint of checkpointOverflow) {
+          await this.deleteCheckpoint(checkpoint.sessionId, checkpoint.id);
+        }
+        deletedCheckpoints += checkpointOverflow.length;
+        trimmedSessions += 1;
+        await this.writeCheckpointIndex(
+          execution.sessionId,
+          retained.map((checkpoint) => checkpoint.id)
+        );
+        const updatedExecution = await this.getExecution(execution.sessionId);
+        if (updatedExecution) {
+          updatedExecution.checkpointCount = retained.length;
+          updatedExecution.lastCheckpointReason = retained.at(-1)?.reason;
+          await this.writeExecution(updatedExecution);
+        }
+      }
+    }
+    return {
+      deletedExecutions: deletedExecutionIds.length,
+      deletedExecutionIds,
+      deletedCheckpoints,
+      trimmedSessions
+    };
+  }
+  stateKeyForExecution(sessionId) {
+    return `${this.keyPrefix}runs/${sessionId}`;
+  }
+  stateKeyForCheckpoint(sessionId, checkpointId) {
+    return `${this.keyPrefix}checkpoints/${sessionId}/${checkpointId}`;
+  }
+  stateKeyForCheckpointIndex(sessionId) {
+    return `${this.keyPrefix}checkpoint-index/${sessionId}`;
+  }
+  async deleteExecutionRecord(sessionId) {
+    const checkpoints = await this.listCheckpoints(sessionId);
+    for (const checkpoint of checkpoints) {
+      await this.deleteCheckpoint(sessionId, checkpoint.id);
+    }
+    await this.client.deleteState(this.stateKeyForCheckpointIndex(sessionId));
+    await this.client.deleteState(this.stateKeyForExecution(sessionId));
+    return checkpoints.length;
+  }
+  async deleteCheckpoint(sessionId, checkpointId) {
+    await this.client.deleteState(this.stateKeyForCheckpoint(sessionId, checkpointId));
+  }
+  async readCheckpoint(sessionId, checkpointId) {
+    const value = await this.client.getState(
+      this.stateKeyForCheckpoint(sessionId, checkpointId)
+    );
+    const decoded = this.decodeCheckpoint(value);
+    return decoded ? cloneRecord(decoded) : void 0;
+  }
+  async readCheckpointIndex(sessionId) {
+    const entry = await this.client.getStateEntry(
+      this.stateKeyForCheckpointIndex(sessionId)
+    );
+    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 writeCheckpointIndex(sessionId, ids, etag) {
+    await this.client.saveState(this.stateKeyForCheckpointIndex(sessionId), [...new Set(ids)], {
+      etag,
+      concurrency: etag ? "first-write" : void 0
+    });
+  }
+  async updateCheckpointIndex(sessionId, updater) {
+    for (let attempt = 0; attempt < DEFAULT_INDEX_UPDATE_RETRIES; attempt += 1) {
+      const current = await this.readCheckpointIndex(sessionId);
+      const next = updater(current.ids ?? []);
+      if (!next) {
+        return;
+      }
+      try {
+        await this.writeCheckpointIndex(sessionId, next, current.etag);
+        return;
+      } catch (error) {
+        if (isDaprConflictError(error) && attempt + 1 < DEFAULT_INDEX_UPDATE_RETRIES) {
+          continue;
+        }
+        throw error;
+      }
+    }
+  }
+  async addCheckpointToIndex(sessionId, checkpointId) {
+    await this.updateCheckpointIndex(sessionId, (ids) => {
+      if (ids.includes(checkpointId)) {
+        return void 0;
+      }
+      return [...ids, checkpointId];
+    });
+  }
+  async listCheckpointsFromIndex(sessionId) {
+    const current = await this.readCheckpointIndex(sessionId);
+    if (!current.exists) {
+      return void 0;
+    }
+    const records = await Promise.all(
+      (current.ids ?? []).map(
+        (checkpointId) => this.readCheckpoint(sessionId, checkpointId)
+      )
+    );
+    const present = records.filter(
+      (record) => Boolean(record)
+    );
+    if (present.length !== (current.ids ?? []).length) {
+      await this.writeCheckpointIndex(
+        sessionId,
+        present.map((record) => record.id),
+        current.etag
+      ).catch(() => {
+      });
+    }
+    return present;
+  }
+  async writeExecution(record) {
+    const envelope = {
+      kind: STORED_EXECUTION_KIND,
+      version: STORED_EXECUTION_VERSION,
+      execution: record
+    };
+    await this.client.saveState(
+      this.stateKeyForExecution(record.sessionId),
+      envelope
+    );
+  }
+  async writeCheckpoint(record) {
+    const envelope = {
+      kind: STORED_EXECUTION_CHECKPOINT_KIND,
+      version: STORED_EXECUTION_VERSION,
+      checkpoint: record
+    };
+    await this.client.saveState(
+      this.stateKeyForCheckpoint(record.sessionId, record.id),
+      envelope
+    );
+  }
+  decodeExecution(value) {
+    if (!value || typeof value !== "object") {
+      return void 0;
+    }
+    const envelope = value;
+    if (envelope.kind === STORED_EXECUTION_KIND) {
+      if (envelope.version !== STORED_EXECUTION_VERSION) {
+        throw new Error(
+          `Unsupported Dapr execution record version: ${String(envelope.version)}`
+        );
+      }
+      if (envelope.execution && typeof envelope.execution === "object") {
+        return envelope.execution;
+      }
+      return void 0;
+    }
+    return void 0;
+  }
+  decodeCheckpoint(value) {
+    if (!value || typeof value !== "object") {
+      return void 0;
+    }
+    const envelope = value;
+    if (envelope.kind === STORED_EXECUTION_CHECKPOINT_KIND) {
+      if (envelope.version !== STORED_EXECUTION_VERSION) {
+        throw new Error(
+          `Unsupported Dapr execution checkpoint version: ${String(envelope.version)}`
+        );
+      }
+      if (envelope.checkpoint && typeof envelope.checkpoint === "object") {
+        return envelope.checkpoint;
+      }
+      return void 0;
+    }
+    return void 0;
+  }
+};
+
+// src/execution/observer.ts
+var DaprExecutionObserver = class {
+  store;
+  constructor(options) {
+    this.store = options.store;
+  }
+  async onTaskStart(run, snapshot) {
+    await this.store.recordStart(run, snapshot);
+  }
+  async onCheckpoint(checkpoint) {
+    await this.store.recordCheckpoint(checkpoint);
+  }
+  async onTaskComplete(run, result, snapshot) {
+    await this.store.recordCompletion(run, result, snapshot);
+  }
+  async onTaskError(run, error, snapshot) {
+    await this.store.recordError(run, error, snapshot);
+  }
+};
+function createDaprExecutionObserver(options) {
+  return new DaprExecutionObserver(options);
+}
+
+// src/execution/logging.ts
+function createDaprLoggingObserver(options = {}) {
+  const prefix = options.prefix ?? "[agent]";
+  const logger = options.logger ?? {
+    info: (msg) => console.log(msg),
+    warn: (msg) => console.warn(msg),
+    error: (msg) => console.error(msg)
+  };
+  const verbose = options.verbose ?? false;
+  function log(message) {
+    logger.info(`${prefix} ${message}`);
+  }
+  function formatUsage(snapshot) {
+    const { usage } = snapshot;
+    return `tokens=${usage.totalTokens} (in=${usage.inputTokens} out=${usage.outputTokens})`;
+  }
+  function formatToolCalls(snapshot) {
+    if (snapshot.toolCalls.length === 0) return "";
+    const names = snapshot.toolCalls.map((tc) => tc.name).join(", ");
+    return ` tools=[${names}]`;
+  }
+  return {
+    onTaskStart(run, _snapshot) {
+      log(
+        `task-start session=${run.sessionId} trigger=${run.context.trigger ?? "unknown"}`
+      );
+    },
+    ...verbose ? {
+      onTaskEvent(run, event, snapshot) {
+        log(
+          `event type=${event.type} session=${run.sessionId} step=${snapshot.activeStep ?? 0}`
+        );
+      }
+    } : {},
+    onCheckpoint(checkpoint) {
+      log(
+        `checkpoint reason=${checkpoint.reason} session=${checkpoint.run.sessionId} ${formatUsage(checkpoint.snapshot)}${formatToolCalls(checkpoint.snapshot)}`
+      );
+    },
+    onTaskComplete(run, result, snapshot) {
+      const toolCount = snapshot.toolCalls.length;
+      const responsePreview = result.response.length > 80 ? result.response.slice(0, 80) + "\u2026" : result.response;
+      log(
+        `task-complete session=${run.sessionId} ${formatUsage(snapshot)} tool-calls=${toolCount} response="${responsePreview}"`
+      );
+    },
+    onTaskError(run, error, snapshot) {
+      (logger.error ?? logger.info)(
+        `${prefix} task-error session=${run.sessionId} ${formatUsage(snapshot)} error="${error.message}"`
+      );
+    }
+  };
+}
+
+// src/execution/workflow-bridge.ts
+var EMPTY_USAGE = {
+  inputTokens: 0,
+  outputTokens: 0,
+  totalTokens: 0
+};
+function buildRun(state, payload, trigger) {
+  return {
+    payload,
+    context: { trigger },
+    sessionId: state.sessionId,
+    startedAt: state.startedAt
+  };
+}
+function collectToolCalls(state) {
+  const toolCalls = [];
+  for (const msg of state.messages) {
+    if (msg.role === "tool") {
+      toolCalls.push({ name: msg.toolName, result: msg.content });
+    }
+  }
+  return toolCalls;
+}
+function buildSnapshot(state) {
+  return {
+    sessionId: state.sessionId,
+    response: state.finalResponse ?? state.lastModelStep?.text ?? "",
+    usage: state.usage ?? EMPTY_USAGE,
+    toolCalls: collectToolCalls(state),
+    eventCount: 0,
+    activeStep: state.step,
+    startedAt: state.startedAt,
+    updatedAt: state.updatedAt,
+    turnState: state.turnState ?? {}
+  };
+}
+function buildCheckpoint(reason, state, payload, trigger) {
+  return {
+    run: buildRun(state, payload, trigger),
+    reason,
+    snapshot: buildSnapshot(state),
+    createdAt: state.updatedAt
+  };
+}
+async function notifyAll(observers, fn) {
+  for (const observer of observers) {
+    try {
+      await fn(observer);
+    } catch {
+    }
+  }
+}
+function createWorkflowObserverBridge(options) {
+  const { observers } = options;
+  let payload = options.payload;
+  const trigger = options.trigger ?? "workflow";
+  if (observers.length === 0) {
+    return {
+      async notifyTaskStart() {
+      },
+      async notifyCheckpoint() {
+      },
+      async notifyTaskComplete() {
+      },
+      async notifyTaskError() {
+      },
+      updatePayload() {
+      },
+      getOtelContext() {
+        return void 0;
+      }
+    };
+  }
+  let taskStarted = false;
+  return {
+    async notifyTaskStart(state) {
+      if (taskStarted) return;
+      taskStarted = true;
+      const run = buildRun(state, payload, trigger);
+      const snapshot = buildSnapshot(state);
+      await notifyAll(observers, (o) => o.onTaskStart?.(run, snapshot));
+    },
+    async notifyCheckpoint(reason, state) {
+      const checkpoint = buildCheckpoint(reason, state, payload, trigger);
+      await notifyAll(observers, (o) => o.onCheckpoint?.(checkpoint));
+    },
+    async notifyTaskComplete(state) {
+      const run = buildRun(state, payload, trigger);
+      const snapshot = buildSnapshot(state);
+      const result = {
+        response: state.finalResponse ?? "",
+        sessionId: state.sessionId,
+        usage: state.usage ?? EMPTY_USAGE,
+        toolCalls: collectToolCalls(state)
+      };
+      await notifyAll(
+        observers,
+        (o) => o.onTaskComplete?.(run, result, snapshot)
+      );
+    },
+    async notifyTaskError(state, error) {
+      const run = buildRun(state, payload, trigger);
+      const snapshot = buildSnapshot(state);
+      await notifyAll(observers, (o) => o.onTaskError?.(run, error, snapshot));
+    },
+    updatePayload(newPayload) {
+      payload = newPayload;
+    },
+    getOtelContext(sessionId) {
+      for (const observer of observers) {
+        const ctx = observer.getOtelContext?.(sessionId);
+        if (ctx !== void 0) return ctx;
+      }
+      return void 0;
+    }
+  };
+}
+
+// src/execution/telemetry.ts
+var _otel = null;
+function oiMime(v) {
+  const t = v.trimStart();
+  return t.startsWith("{") || t.startsWith("[") ? "application/json" : "text/plain";
+}
+async function getOtel() {
+  if (_otel) return _otel;
+  try {
+    _otel = await import("@opentelemetry/api");
+    return _otel;
+  } catch {
+    return null;
+  }
+}
+function createOtelObserver(config = {}) {
+  const agentName = config.agentName ?? "agent";
+  const spanTimeoutMs = config.spanTimeoutMs ?? 5 * 60 * 1e3;
+  const turnSpans = /* @__PURE__ */ new Map();
+  let otel = null;
+  let tracer = null;
+  async function ensureTracer() {
+    if (tracer) return tracer;
+    otel = await getOtel();
+    if (!otel) return null;
+    tracer = otel.trace.getTracer("@cuylabs/agent-runtime-dapr");
+    return tracer;
+  }
+  function getUsageAttrs(usage) {
+    if (!usage) return {};
+    return {
+      "gen_ai.usage.input_tokens": usage.inputTokens ?? 0,
+      "gen_ai.usage.output_tokens": usage.outputTokens ?? 0
+    };
+  }
+  return {
+    async onTaskStart(run, _snapshot) {
+      const existing = turnSpans.get(run.sessionId);
+      if (existing) {
+        const inputVal2 = run.payload.message.slice(0, 4096);
+        existing.span.setAttributes({
+          "openinference.span.kind": "AGENT",
+          "gen_ai.agent.name": agentName,
+          "gen_ai.agent.session_id": run.sessionId,
+          "agent.trigger": run.context.trigger ?? "unknown",
+          "input.value": inputVal2,
+          "input.mime_type": oiMime(inputVal2)
+        });
+        return;
+      }
+      const t = await ensureTracer();
+      if (!t) return;
+      const inputVal = run.payload.message.slice(0, 4096);
+      const span = t.startSpan("agent.turn", {
+        attributes: {
+          "openinference.span.kind": "AGENT",
+          "gen_ai.operation.name": "invoke_agent",
+          "gen_ai.agent.name": agentName,
+          "gen_ai.agent.session_id": run.sessionId,
+          "agent.trigger": run.context.trigger ?? "unknown",
+          "input.value": inputVal,
+          "input.mime_type": oiMime(inputVal)
+        }
+      });
+      const ctx = otel.trace.setSpan(otel.context.active(), span);
+      const timer = setTimeout(() => {
+        const entry = turnSpans.get(run.sessionId);
+        if (entry) {
+          entry.span.setStatus({
+            code: otel?.SpanStatusCode.ERROR ?? 2,
+            message: "Span timed out (possible leak \u2014 task never completed)"
+          });
+          entry.span.end();
+          turnSpans.delete(run.sessionId);
+        }
+      }, spanTimeoutMs);
+      turnSpans.set(run.sessionId, { span, ctx, timer });
+    },
+    onCheckpoint(checkpoint) {
+      const entry = turnSpans.get(checkpoint.run.sessionId);
+      if (!entry) return;
+      const reason = checkpoint.reason;
+      const attrs = {
+        "checkpoint.reason": reason
+      };
+      if (checkpoint.snapshot.activeStep !== void 0) {
+        attrs["checkpoint.step"] = checkpoint.snapshot.activeStep;
+      }
+      const usage = checkpoint.snapshot.usage;
+      if (usage) {
+        attrs["gen_ai.usage.input_tokens"] = usage.inputTokens ?? 0;
+        attrs["gen_ai.usage.output_tokens"] = usage.outputTokens ?? 0;
+      }
+      const toolCalls = checkpoint.snapshot.toolCalls;
+      if (toolCalls.length > 0) {
+        attrs["checkpoint.tools"] = toolCalls.map((tc) => tc.name).join(",");
+      }
+      entry.span.addEvent(`agent.checkpoint.${reason}`, attrs);
+    },
+    onTaskComplete(run, result, _snapshot) {
+      const entry = turnSpans.get(run.sessionId);
+      if (!entry) return;
+      if (entry.timer) clearTimeout(entry.timer);
+      entry.span.setAttributes({
+        ...getUsageAttrs(result.usage),
+        "agent.tool_calls": result.toolCalls?.length ?? 0,
+        "agent.response.length": result.response?.length ?? 0
+      });
+      if (result.response) {
+        const outVal = result.response.slice(0, 4096);
+        entry.span.setAttribute("output.value", outVal);
+        entry.span.setAttribute("output.mime_type", oiMime(outVal));
+      }
+      entry.span.setStatus({ code: otel?.SpanStatusCode.OK ?? 1 });
+      entry.span.end();
+      turnSpans.delete(run.sessionId);
+    },
+    onTaskError(run, error, snapshot) {
+      const entry = turnSpans.get(run.sessionId);
+      if (!entry) return;
+      if (entry.timer) clearTimeout(entry.timer);
+      entry.span.setAttributes(getUsageAttrs(snapshot.usage));
+      entry.span.setStatus({
+        code: otel?.SpanStatusCode.ERROR ?? 2,
+        message: error.message
+      });
+      entry.span.recordException(error);
+      entry.span.end();
+      turnSpans.delete(run.sessionId);
+    },
+    getOtelContext(sessionId) {
+      return turnSpans.get(sessionId)?.ctx;
+    },
+    activateContext(sessionId, fn) {
+      const entry = turnSpans.get(sessionId);
+      if (!entry?.ctx || !otel) return fn();
+      return otel.context.with(entry.ctx, fn);
+    }
+  };
+}
+
+export {
+  DaprExecutionStore,
+  DaprExecutionObserver,
+  createDaprExecutionObserver,
+  createDaprLoggingObserver,
+  createWorkflowObserverBridge,
+  createOtelObserver
+};