@botpress/evals 1.19.0-beta.9 → 2.0.0-alpha.1

package/dist/spans/index.js

@@ -0,0 +1,725 @@
+// ../analytics/src/errors.ts
+var AdkError = class extends Error {
+  /**
+   * Marker for cross-module-instance checks — `instanceof` breaks when a
+   * package is duplicated in the dependency graph.
+   * @internal
+   */
+  static __IS_ADK_BASE_ERROR = true;
+  /**
+   * Stable SCREAMING_SNAKE_CASE identifier, e.g. 'BOT_NOT_FOUND'. Subclasses
+   * pin `Code` to a literal union (`class EvalRunnerError extends
+   * AdkError<EvalErrorCode>`) so typos are compile errors and `code` narrows
+   * in switches.
+   */
+  code;
+  /**
+   * True for user/environment conditions the developer can fix themselves
+   * (validation, auth, connectivity). False for internal bugs. Defaults to
+   * false so unclassified errors surface as bugs until someone triages them.
+   */
+  expected;
+  /** Structured context. Sanitized before any telemetry leaves the machine. */
+  details;
+  /** Actionable next step shown to the user, e.g. "Run 'adk login' first." */
+  suggestion;
+  constructor(opts) {
+    super(opts.message, opts.cause !== void 0 ? { cause: opts.cause } : void 0);
+    this.name = this.constructor.name;
+    this.code = opts.code;
+    this.expected = opts.expected ?? false;
+    if (opts.details !== void 0) {
+      this.details = opts.details;
+    }
+    if (opts.suggestion !== void 0) {
+      this.suggestion = opts.suggestion;
+    }
+  }
+};
+
+// src/errors.ts
+var EvalRunnerError = class extends AdkError {
+};
+
+// src/spans/sse-collector.ts
+function spanKey(span) {
+  return `${span.id.trace}:${span.id.span}`;
+}
+function spanData(span) {
+  return span.data && typeof span.data === "object" ? span.data : {};
+}
+var TURN_HANDLER_SPAN_NAMES = /* @__PURE__ */ new Set(["handler.conversation", "handler.event"]);
+function isTurnHandlerSpan(span) {
+  return TURN_HANDLER_SPAN_NAMES.has(span.name);
+}
+var SSECollector = class _SSECollector {
+  devServerUrl;
+  headers;
+  /** All spans accumulated since connect(), keyed by spanKey for dedup. */
+  spanMap = /* @__PURE__ */ new Map();
+  /** Index into spanMap insertion order marking where the current turn started. */
+  turnStartKeys = /* @__PURE__ */ new Set();
+  /** Handler span IDs seen before the current turn (for startTurn filtering). */
+  seenHandlerKeys = /* @__PURE__ */ new Set();
+  /** Callbacks waiting for span updates. */
+  waiters = [];
+  /** AbortController for the active SSE connection. */
+  abortController = null;
+  /** Whether the background loop is running. */
+  connected = false;
+  /** Error from the SSE stream if it died unexpectedly. */
+  streamError = null;
+  /** Passive counters used only to explain timeout failures. */
+  updateEventCount = 0;
+  keepaliveEventCount = 0;
+  lastEvent = null;
+  /** Set while a settle phase is in flight; called by disconnect() to short-circuit. */
+  _cancelSettle = null;
+  constructor(devServerUrl, headers = {}) {
+    this.devServerUrl = devServerUrl;
+    this.headers = headers;
+  }
+  /**
+   * Open a streaming SSE connection filtered by conversationId or workflowId.
+   * Starts a background loop that parses SSE events and accumulates spans.
+   */
+  async connect(filter) {
+    const attributeName = "conversationId" in filter ? "conversationId" : "workflowId";
+    const attributeValue = "conversationId" in filter ? filter.conversationId : filter.workflowId;
+    const url = `${this.devServerUrl}/api/traces/stream?attributeName=${encodeURIComponent(attributeName)}&attributeValue=${encodeURIComponent(attributeValue)}`;
+    this.abortController = new AbortController();
+    const myController = this.abortController;
+    const response = await fetch(url, {
+      headers: { ...this.headers, Accept: "text/event-stream" },
+      signal: myController.signal
+    });
+    if (!response.ok) {
+      throw new EvalRunnerError({
+        code: "SSE_CONNECT_FAILED",
+        message: `SSE connection failed: ${response.status} ${response.statusText}`,
+        expected: true,
+        suggestion: "Make sure the dev server is running (`adk dev`) and reachable."
+      });
+    }
+    if (!response.body) {
+      throw new EvalRunnerError({ code: "SSE_NO_BODY", message: "SSE response has no body" });
+    }
+    this.connected = true;
+    this._consumeStream(response.body).catch((err) => {
+      if (this.connected && this.abortController === myController) {
+        this.streamError = err instanceof Error ? err : new Error(String(err));
+      }
+    });
+    await this._waitForSnapshot();
+  }
+  /**
+   * Re-point at a new conversation, keeping `spanMap` and `seenHandlerKeys` (so
+   * the earlier conversation stays visible and its completed handler can't
+   * satisfy the next turn). Resets the snapshot latch so connect() awaits the
+   * new conversation's snapshot.
+   */
+  async repoint(filter) {
+    this.connected = false;
+    this.abortController?.abort();
+    this.abortController = null;
+    this._cancelSettle?.();
+    this._cancelSettle = null;
+    this.waiters = [];
+    this.snapshotReceived = false;
+    this.snapshotResolvers = [];
+    this.streamError = null;
+    await this.connect(filter);
+  }
+  /**
+   * Mark the beginning of a new turn.
+   * Records which turn-handler span IDs (handler.conversation / handler.event)
+   * have been seen so far, so waitForTurnComplete() only resolves on NEW
+   * handler completions.
+   */
+  startTurn() {
+    this.turnStartKeys = new Set(this.spanMap.keys());
+    for (const [key, span] of this.spanMap) {
+      if (isTurnHandlerSpan(span)) {
+        this.seenHandlerKeys.add(key);
+      }
+    }
+  }
+  static SETTLE_MS = 100;
+  /**
+   * Wait for a turn-handler span (handler.conversation or handler.event) to
+   * reach terminal status (ok or error).
+   * Only considers spans NOT seen before the last startTurn() call.
+   *
+   * After the handler closes, waits for a quiet period (no new spans for SETTLE_MS)
+   * to ensure all child spans (tool calls, messages, state saves) have arrived.
+   * The runtime's HttpSpanExporter fires POSTs without awaiting them, so child
+   * spans may arrive slightly after the handler close event.
+   */
+  async waitForTurnComplete(opts) {
+    const accept = opts.acceptSpanNames;
+    const settle = { quietMs: opts.settleQuietMs, maxMs: opts.settleMaxMs };
+    if (this._hasNewCompletedHandler(accept)) {
+      return this._settleAfterHandler(settle);
+    }
+    if (opts.abortSignal?.aborted) {
+      throw new Error("waitForTurnComplete aborted");
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this._removeWaiter(waiter);
+        opts.abortSignal?.removeEventListener("abort", onAbort);
+        const expected = accept ? [...accept].join(" or ") : "handler.conversation or handler.event";
+        const reason = this.streamError ? `SSE stream died: ${this.streamError.message}` : `no ${expected} span completed`;
+        reject(
+          new Error(
+            `waitForTurnComplete timed out after ${opts.timeout}ms \u2014 ${reason}; diagnostics: ${this._formatTurnDiagnostics()}`
+          )
+        );
+      }, opts.timeout);
+      const onAbort = () => {
+        clearTimeout(timer);
+        this._removeWaiter(waiter);
+        reject(new Error("waitForTurnComplete aborted"));
+      };
+      opts.abortSignal?.addEventListener("abort", onAbort, { once: true });
+      const waiter = (_span) => {
+        if (this._hasNewCompletedHandler(accept)) {
+          clearTimeout(timer);
+          this._removeWaiter(waiter);
+          opts.abortSignal?.removeEventListener("abort", onAbort);
+          this._settleAfterHandler(settle).then(resolve, reject);
+        }
+      };
+      this.waiters.push(waiter);
+    });
+  }
+  static MAX_SETTLE_MS = 2e3;
+  /**
+   * After the handler span closes, wait for spans to stop arriving.
+   * Resolves when no new spans arrive for SETTLE_MS, or after MAX_SETTLE_MS hard cap.
+   *
+   * Exposes a cancellation hook via _cancelSettle so disconnect() can short-
+   * circuit an in-flight settle phase and avoid leaking timers for up to 2s.
+   */
+  _settleAfterHandler(settle) {
+    const quietMs = settle?.quietMs ?? _SSECollector.SETTLE_MS;
+    const maxMs = settle?.maxMs ?? _SSECollector.MAX_SETTLE_MS;
+    return new Promise((resolve) => {
+      let resolved = false;
+      const done = () => {
+        if (resolved) return;
+        resolved = true;
+        clearTimeout(hardCap);
+        clearTimeout(settleTimer);
+        this._removeWaiter(settleWaiter);
+        this._cancelSettle = null;
+        resolve();
+      };
+      const hardCap = setTimeout(done, maxMs);
+      let settleTimer = setTimeout(done, quietMs);
+      const settleWaiter = () => {
+        if (resolved) return;
+        clearTimeout(settleTimer);
+        settleTimer = setTimeout(done, quietMs);
+      };
+      this.waiters.push(settleWaiter);
+      this._cancelSettle = done;
+    });
+  }
+  /**
+   * Wait for a handler.workflow span with matching workflow name.
+   * - signal 'entered': resolves when the span appears (any status)
+   * - signal 'completed': resolves when the span has status !== 'running'
+   */
+  async waitForWorkflow(name, opts) {
+    if (this._matchesWorkflowCondition(name, opts.signal)) {
+      return;
+    }
+    if (opts.abortSignal?.aborted) {
+      throw new Error(`waitForWorkflow("${name}", { signal: "${opts.signal}" }) aborted`);
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this._removeWaiter(waiter);
+        opts.abortSignal?.removeEventListener("abort", onAbort);
+        const reason = this.streamError ? `SSE stream died: ${this.streamError.message}` : "span not found";
+        reject(
+          new Error(
+            `waitForWorkflow("${name}", { signal: "${opts.signal}" }) timed out after ${opts.timeout}ms \u2014 ${reason}`
+          )
+        );
+      }, opts.timeout);
+      const onAbort = () => {
+        clearTimeout(timer);
+        this._removeWaiter(waiter);
+        reject(new Error(`waitForWorkflow("${name}", { signal: "${opts.signal}" }) aborted`));
+      };
+      opts.abortSignal?.addEventListener("abort", onAbort, { once: true });
+      const waiter = (_span) => {
+        if (this._matchesWorkflowCondition(name, opts.signal)) {
+          clearTimeout(timer);
+          this._removeWaiter(waiter);
+          opts.abortSignal?.removeEventListener("abort", onAbort);
+          resolve();
+        }
+      };
+      this.waiters.push(waiter);
+    });
+  }
+  /**
+   * Return spans accumulated since the last startTurn() call.
+   */
+  getTurnSpans() {
+    const result = [];
+    for (const [key, span] of this.spanMap) {
+      if (!this.turnStartKeys.has(key)) {
+        result.push(span);
+      }
+    }
+    return result;
+  }
+  /**
+   * Return all spans accumulated since connect().
+   */
+  getAllSpans() {
+    return Array.from(this.spanMap.values());
+  }
+  /**
+   * Close the SSE connection and clean up.
+   */
+  disconnect() {
+    this.connected = false;
+    this.abortController?.abort();
+    this.abortController = null;
+    this._cancelSettle?.();
+    this._cancelSettle = null;
+    this.waiters = [];
+    this.snapshotResolvers = [];
+  }
+  // ── Private ──────────────────────────────────────────────────
+  /** Whether we have received the initial snapshot. */
+  snapshotReceived = false;
+  snapshotResolvers = [];
+  static SNAPSHOT_TIMEOUT_MS = 1e4;
+  /**
+   * Returns a promise that resolves once the snapshot event has been processed,
+   * or rejects after a timeout to prevent connect() from hanging indefinitely.
+   */
+  _waitForSnapshot() {
+    if (this.snapshotReceived) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const resolver = () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        resolve();
+      };
+      const timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        const idx = this.snapshotResolvers.indexOf(resolver);
+        if (idx !== -1) this.snapshotResolvers.splice(idx, 1);
+        reject(
+          new Error(
+            `SSE snapshot not received within ${_SSECollector.SNAPSHOT_TIMEOUT_MS}ms \u2014 is the dev server healthy?`
+          )
+        );
+      }, _SSECollector.SNAPSHOT_TIMEOUT_MS);
+      this.snapshotResolvers.push(resolver);
+    });
+  }
+  /**
+   * Consume the ReadableStream body, parse SSE lines, and dispatch events.
+   */
+  async _consumeStream(body) {
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const reader = body.getReader();
+    try {
+      while (this.connected) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const parts = buffer.split("\n\n");
+        buffer = parts.pop() ?? "";
+        for (const part of parts) {
+          this._parseSSEBlock(part);
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+  /**
+   * Parse a single SSE event block (text between \n\n boundaries).
+   * Extracts event name and data payload.
+   */
+  _parseSSEBlock(block) {
+    const lines = block.split("\n");
+    let eventName = "";
+    let dataLine = "";
+    for (const line of lines) {
+      if (line.startsWith("event:")) {
+        eventName = line.slice("event:".length).trim();
+      } else if (line.startsWith("data:")) {
+        const value = line.slice("data:".length).trim();
+        dataLine = dataLine ? `${dataLine}
+${value}` : value;
+      }
+    }
+    if (!eventName || !dataLine) {
+      if (!this.snapshotReceived && block.includes("retry:")) {
+      }
+      return;
+    }
+    try {
+      const payload = JSON.parse(dataLine);
+      this._handleEvent(eventName, payload);
+    } catch {
+    }
+  }
+  /**
+   * Dispatch a parsed SSE event to the appropriate handler.
+   */
+  _handleEvent(eventName, payload) {
+    this._recordEvent(eventName);
+    if (eventName === "snapshot") {
+      const data = payload;
+      const spans = Array.isArray(data.spans) ? data.spans : [];
+      for (const span of spans) {
+        this._upsertSpan(span);
+      }
+      this.snapshotReceived = true;
+      for (const resolve of this.snapshotResolvers) {
+        resolve();
+      }
+      this.snapshotResolvers = [];
+    } else if (eventName === "update") {
+      const data = payload;
+      if (data.span) {
+        this._upsertSpan(data.span);
+        this._notifyWaiters(data.span);
+      }
+    }
+  }
+  _recordEvent(eventName) {
+    this.lastEvent = { name: eventName, at: Date.now() };
+    if (eventName === "update") {
+      this.updateEventCount++;
+    } else if (eventName === "keepalive") {
+      this.keepaliveEventCount++;
+    }
+  }
+  _formatTurnDiagnostics() {
+    const turnSpans = this.getTurnSpans();
+    const spanNames = /* @__PURE__ */ new Set();
+    const handlerStatuses = /* @__PURE__ */ new Set();
+    for (const span of turnSpans) {
+      spanNames.add(span.name);
+      if (isTurnHandlerSpan(span)) {
+        handlerStatuses.add(span.status);
+      }
+    }
+    const lastEvent = this.lastEvent ? `${this.lastEvent.name} ${Date.now() - this.lastEvent.at}ms ago` : "none";
+    return [
+      `snapshotReceived=${this.snapshotReceived}`,
+      `totalUpdates=${this.updateEventCount}`,
+      `totalKeepalives=${this.keepaliveEventCount}`,
+      `lastEvent=${lastEvent}`,
+      `totalSpans=${this.spanMap.size}`,
+      `turnSpans=${turnSpans.length}`,
+      `turnSpanNames=${this._formatSet(spanNames)}`,
+      `turnHandlerStatuses=${this._formatSet(handlerStatuses)}`
+    ].join(", ");
+  }
+  _formatSet(values, limit = 12) {
+    if (values.size === 0) {
+      return "none";
+    }
+    const items = Array.from(values);
+    const suffix = items.length > limit ? `|+${items.length - limit} more` : "";
+    return `${items.slice(0, limit).join("|")}${suffix}`;
+  }
+  /**
+   * Insert or replace a span in the map (dedup by trace+span ID).
+   */
+  _upsertSpan(span) {
+    this.spanMap.set(spanKey(span), span);
+  }
+  /**
+   * Notify all waiters that a new span was received.
+   */
+  _notifyWaiters(span) {
+    const current = [...this.waiters];
+    for (const waiter of current) {
+      waiter(span);
+    }
+  }
+  /**
+   * Remove a waiter callback from the list.
+   */
+  _removeWaiter(fn) {
+    const idx = this.waiters.indexOf(fn);
+    if (idx !== -1) {
+      this.waiters.splice(idx, 1);
+    }
+  }
+  /**
+   * Check if there is a turn-handler span (handler.conversation / handler.event) that:
+   * 1. Was NOT seen before startTurn()
+   * 2. Has terminal status (ok or error)
+   *
+   * Marks the matched key as consumed so the same handler span cannot
+   * satisfy both the current turn's settle phase AND the next turn's
+   * waitForTurnComplete check (which would otherwise resolve instantly
+   * against stale data instead of waiting for the new turn's handler).
+   */
+  _hasNewCompletedHandler(acceptSpanNames) {
+    for (const [key, span] of this.spanMap) {
+      if (isTurnHandlerSpan(span) && (!acceptSpanNames || acceptSpanNames.has(span.name)) && !this.seenHandlerKeys.has(key) && (span.status === "ok" || span.status === "error")) {
+        this.seenHandlerKeys.add(key);
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Check if a handler.workflow span matches the given condition.
+   */
+  _matchesWorkflowCondition(name, signal) {
+    for (const span of this.spanMap.values()) {
+      if (span.name !== "handler.workflow") continue;
+      const d = spanData(span);
+      const wfName = d["workflow.name"] || d["workflowName"];
+      if (wfName !== name) continue;
+      if (signal === "entered") {
+        return true;
+      }
+      if (signal === "completed") {
+        return span.status === "ok" || span.status === "error";
+      }
+    }
+    return false;
+  }
+};
+
+// src/spans/local-span-source.ts
+var LocalSpanSource = class {
+  collector;
+  constructor(devServerUrl, headers = {}) {
+    this.collector = new SSECollector(devServerUrl, headers);
+  }
+  async connect(filter) {
+    await this.collector.connect(filter);
+  }
+  async repoint(filter) {
+    await this.collector.repoint(filter);
+  }
+  startTurn() {
+    this.collector.startTurn();
+  }
+  async waitForTurnComplete(opts) {
+    await this.collector.waitForTurnComplete(opts);
+  }
+  async waitForWorkflow(name, opts) {
+    await this.collector.waitForWorkflow(name, opts);
+  }
+  getTurnSpans() {
+    return this.collector.getTurnSpans();
+  }
+  getAllSpans() {
+    return this.collector.getAllSpans();
+  }
+  disconnect() {
+    this.collector.disconnect();
+  }
+};
+
+// src/spans/vortex-span-source.ts
+function spanKey2(span) {
+  return `${span.id.trace}:${span.id.span}`;
+}
+function spanData2(span) {
+  return span.data && typeof span.data === "object" ? span.data : {};
+}
+function normalizeSpan(span) {
+  if (span.status !== "running") return span;
+  const data = spanData2(span);
+  const autonomousStatus = data["autonomous.status"];
+  if (autonomousStatus === "generation_error" || autonomousStatus === "execution_error" || autonomousStatus === "invalid_code_error" || autonomousStatus === "exit_error" || autonomousStatus === "aborted") {
+    return { ...span, status: "error" };
+  }
+  if (autonomousStatus === "thinking_requested" || autonomousStatus === "callback_requested" || autonomousStatus === "exit_success") {
+    return { ...span, status: "ok" };
+  }
+  const { startedAt, endedAt } = span.timing;
+  if (typeof endedAt === "number" && Number.isFinite(endedAt) && endedAt > startedAt) {
+    return { ...span, status: "ok" };
+  }
+  return span;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) return reject(new Error("aborted"));
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new Error("aborted"));
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+var VortexSpanSource = class _VortexSpanSource {
+  config;
+  conversationId = "";
+  traceIds = /* @__PURE__ */ new Set();
+  spanMap = /* @__PURE__ */ new Map();
+  turnStartKeys = /* @__PURE__ */ new Set();
+  seenHandlerKeys = /* @__PURE__ */ new Set();
+  consecutiveFailures = 0;
+  constructor(config) {
+    this.config = {
+      url: config.url.replace(/\/$/, ""),
+      botId: config.botId,
+      pollIntervalMs: config.pollIntervalMs ?? 500,
+      ...config.workspaceId ? { workspaceId: config.workspaceId } : {},
+      ...config.token ? { token: config.token } : {}
+    };
+  }
+  async connect(filter) {
+    this.conversationId = filter.conversationId;
+    await this._pollOnce();
+  }
+  /**
+   * Switch polling to a new conversation, keeping `spanMap` and
+   * `seenHandlerKeys`. `traceIds` resets — they belonged to the prior conversation.
+   */
+  async repoint(filter) {
+    this.conversationId = filter.conversationId;
+    this.traceIds = /* @__PURE__ */ new Set();
+    await this._pollOnce();
+  }
+  static TURN_HANDLER_SPAN_NAMES = /* @__PURE__ */ new Set(["handler.conversation", "handler.event"]);
+  startTurn() {
+    this.turnStartKeys = new Set(this.spanMap.keys());
+    for (const [key, span] of this.spanMap) {
+      if (_VortexSpanSource.TURN_HANDLER_SPAN_NAMES.has(span.name)) {
+        this.seenHandlerKeys.add(key);
+      }
+    }
+  }
+  static SETTLE_POLLS = 3;
+  async waitForTurnComplete(opts) {
+    const deadline = Date.now() + opts.timeout;
+    const maxPolls = opts.settleMaxMs ? Math.floor(opts.settleMaxMs / this.config.pollIntervalMs) : Infinity;
+    const settlePolls = Math.min(
+      maxPolls,
+      Math.max(
+        _VortexSpanSource.SETTLE_POLLS,
+        opts.settleQuietMs ? Math.ceil(opts.settleQuietMs / this.config.pollIntervalMs) : 0
+      )
+    );
+    while (Date.now() < deadline) {
+      if (opts.abortSignal?.aborted) throw new Error("waitForTurnComplete aborted");
+      await this._pollOnce();
+      if (this._hasNewCompletedHandler(opts.acceptSpanNames)) {
+        for (let i = 0; i < settlePolls; i++) {
+          await sleep(this.config.pollIntervalMs, opts.abortSignal).catch(() => {
+          });
+          await this._pollOnce();
+        }
+        return;
+      }
+      await sleep(this.config.pollIntervalMs, opts.abortSignal).catch(() => {
+      });
+    }
+    throw new Error(`waitForTurnComplete timed out after ${opts.timeout}ms`);
+  }
+  async waitForWorkflow(name, opts) {
+    const deadline = Date.now() + opts.timeout;
+    while (Date.now() < deadline) {
+      if (opts.abortSignal?.aborted) throw new Error(`waitForWorkflow("${name}") aborted`);
+      await this._pollOnce();
+      if (this._matchesWorkflowCondition(name, opts.signal)) return;
+      await sleep(this.config.pollIntervalMs, opts.abortSignal).catch(() => {
+      });
+    }
+    throw new Error(`waitForWorkflow("${name}", { signal: "${opts.signal}" }) timed out after ${opts.timeout}ms`);
+  }
+  getTurnSpans() {
+    const result = [];
+    for (const [key, span] of this.spanMap) {
+      if (!this.turnStartKeys.has(key)) {
+        result.push(span);
+      }
+    }
+    return result;
+  }
+  getAllSpans() {
+    return Array.from(this.spanMap.values());
+  }
+  disconnect() {
+  }
+  async _pollOnce() {
+    const url = new URL(`${this.config.url}/v1/traces/bot/${this.config.botId}/spans/adk`);
+    url.searchParams.set("conversationId", this.conversationId);
+    for (const traceId of this.traceIds) {
+      url.searchParams.append("traceId", traceId);
+    }
+    const res = await fetch(url, {
+      headers: {
+        Accept: "application/json",
+        ...this.config.token ? { Authorization: `Bearer ${this.config.token}` } : {}
+      }
+    });
+    if (!res.ok) {
+      this.consecutiveFailures++;
+      const body = await res.text().catch(() => "");
+      const msg = `Vortex poll failed: ${res.status} ${body.slice(0, 200)}`;
+      if (this.consecutiveFailures >= 5) {
+        throw new Error(`${msg} (${this.consecutiveFailures} consecutive failures)`);
+      }
+      console.warn(`[VortexSpanSource] ${msg}`);
+      return;
+    }
+    this.consecutiveFailures = 0;
+    const payload = await res.json();
+    const spans = Array.isArray(payload) ? payload : Array.isArray(payload.spans) ? payload.spans : [];
+    for (const rawSpan of spans) {
+      const span = normalizeSpan(rawSpan);
+      this.spanMap.set(spanKey2(span), span);
+      this.traceIds.add(span.id.trace);
+    }
+  }
+  _hasNewCompletedHandler(acceptSpanNames) {
+    for (const [key, span] of this.spanMap) {
+      if (_VortexSpanSource.TURN_HANDLER_SPAN_NAMES.has(span.name) && (!acceptSpanNames || acceptSpanNames.has(span.name)) && !this.seenHandlerKeys.has(key) && (span.status === "ok" || span.status === "error")) {
+        this.seenHandlerKeys.add(key);
+        return true;
+      }
+    }
+    return false;
+  }
+  _matchesWorkflowCondition(name, signal) {
+    for (const span of this.spanMap.values()) {
+      if (span.name !== "handler.workflow") continue;
+      const d = spanData2(span);
+      const wfName = d["workflow.name"] || d["workflowName"];
+      if (wfName !== name) continue;
+      if (signal === "entered") return true;
+      if (signal === "completed") return span.status === "ok" || span.status === "error";
+    }
+    return false;
+  }
+};
+export {
+  LocalSpanSource,
+  VortexSpanSource
+};
+//# sourceMappingURL=index.js.map