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

package/dist/spans/local-span-source.js

@@ -0,0 +1,543 @@
+// ../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();
+  }
+};
+export {
+  LocalSpanSource
+};
+//# sourceMappingURL=local-span-source.js.map

package/dist/spans/local-span-source.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../analytics/src/errors.ts", "../../src/errors.ts", "../../src/spans/sse-collector.ts", "../../src/spans/local-span-source.ts"],
+  "sourcesContent": ["/**\n * Shared base error for ADK packages. Lives in `@botpress/analytics` because\n * it's the dependency-light package every surface already shares (cli, adk,\n * ui) \u2014 so all typed errors can genuinely inherit one base instead of\n * mirroring its shape.\n *\n * The policy lives in docs/ERROR-HANDLING.md. The short version: every error\n * we *intend* to throw should carry a stable `code` (so PostHog error\n * tracking can slice issues by code) and an `expected` flag separating\n * user/environment conditions (bad input, not logged in, network down \u2014 render\n * a friendly message, low alert priority) from internal bugs (invariant\n * violations \u2014 full stack, page someone).\n *\n * The runtime package is out of scope and keeps its own `Errors.AbstractError`\n * hierarchy. The adk typed families (`DependencyError`, `Agent0*Error`) extend\n * this base; new code should start here.\n */\nexport class AdkError<Code extends string = string> extends Error {\n  /**\n   * Marker for cross-module-instance checks \u2014 `instanceof` breaks when a\n   * package is duplicated in the dependency graph.\n   * @internal\n   */\n  public static readonly __IS_ADK_BASE_ERROR = true\n\n  /**\n   * Stable SCREAMING_SNAKE_CASE identifier, e.g. 'BOT_NOT_FOUND'. Subclasses\n   * pin `Code` to a literal union (`class EvalRunnerError extends\n   * AdkError<EvalErrorCode>`) so typos are compile errors and `code` narrows\n   * in switches.\n   */\n  readonly code: Code\n  /**\n   * True for user/environment conditions the developer can fix themselves\n   * (validation, auth, connectivity). False for internal bugs. Defaults to\n   * false so unclassified errors surface as bugs until someone triages them.\n   */\n  readonly expected: boolean\n  /** Structured context. Sanitized before any telemetry leaves the machine. */\n  readonly details?: Record<string, unknown>\n  /** Actionable next step shown to the user, e.g. \"Run 'adk login' first.\" */\n  readonly suggestion?: string\n\n  constructor(opts: {\n    code: Code\n    message: string\n    expected?: boolean\n    details?: Record<string, unknown>\n    suggestion?: string\n    cause?: unknown\n  }) {\n    super(opts.message, opts.cause !== undefined ? { cause: opts.cause } : undefined)\n    this.name = this.constructor.name\n    this.code = opts.code\n    this.expected = opts.expected ?? false\n    // Conditional assignment keeps the optional fields absent-not-undefined,\n    // which downstream tsconfigs with exactOptionalPropertyTypes require.\n    if (opts.details !== undefined) {\n      this.details = opts.details\n    }\n    if (opts.suggestion !== undefined) {\n      this.suggestion = opts.suggestion\n    }\n  }\n}\n\n/**\n * Duck-typed guard that survives duplicated module instances in the\n * dependency graph, where `instanceof AdkError` returns false for an error\n * constructed from another copy of this module. No manual prototype walking\n * needed: static properties are inherited through the constructor chain, so\n * a subclass's constructor resolves the marker in one lookup.\n */\nexport function isAdkError(error: unknown): error is AdkError {\n  if (error instanceof AdkError) return true\n  if (!(error instanceof Error)) return false\n  return (error.constructor as unknown as Record<string, unknown> | undefined)?.__IS_ADK_BASE_ERROR === true\n}\n", "import { AdkError } from '@botpress/analytics'\n\n/**\n * Stable error codes for the eval engine. Typed as a literal union so a typo'd\n * code is a compile error and PostHog issue-slicing stays consistent.\n * Conventions per docs/ERROR-HANDLING.md.\n */\nexport const EVAL_ERROR_CODES = [\n  'EVAL_LOAD_FAILED',\n  'EVAL_FILE_EMPTY',\n  'EVAL_DUPLICATE_NAME',\n  'EVAL_SEED_NO_CONVERSATION',\n  'EVAL_NO_CONVERSATION_ID',\n  'EVAL_TURN_CONFIG_INVALID',\n  'SSE_CONNECT_FAILED',\n  'SSE_NO_BODY',\n  'CHAT_CLIENT_MISSING',\n  'CHAT_NOT_CONNECTED',\n  'CHAT_INTEGRATION_MISSING',\n  'CHAT_CHANNEL_UNBOUND',\n] as const\n\nexport type EvalErrorCode = (typeof EVAL_ERROR_CODES)[number]\n\n/**\n * Typed error for the eval engine. Named EvalRunnerError (not EvalError) to\n * avoid shadowing the JS built-in `EvalError`.\n */\nexport class EvalRunnerError extends AdkError<EvalErrorCode> {}\n", "/**\n * SSECollector \u2014 connects to the ADK dev server's SSE trace stream,\n * accumulates spans, and provides promise-based wait methods for\n * turn completion and workflow signals.\n *\n * Uses fetch() + async iteration with manual SSE line parsing\n * (Bun does not have native EventSource).\n */\n\nimport type { Span } from './trace'\nimport { EvalRunnerError } from '../errors'\n\ntype SSEFilter = { conversationId: string } | { workflowId: string }\n\ninterface WaitOptions {\n  timeout: number\n  /**\n   * Optional abort signal \u2014 when fired, the wait rejects immediately rather\n   * than burning the full timeout. Used by the runner so Stop unblocks\n   * pending workflow assertions (otherwise a single negative-result wait\n   * can hold the suite hostage for `idleTimeout` per assertion).\n   */\n  abortSignal?: AbortSignal\n}\n\ninterface WorkflowWaitOptions extends WaitOptions {\n  signal: 'entered' | 'completed'\n}\n\ninterface TurnWaitOptions extends WaitOptions {\n  /**\n   * Which handler span names may complete this turn. A user-message turn\n   * completes via `handler.conversation` only \u2014 async noise such as a\n   * workflow callback closes a silent `handler.event` span, and counting it\n   * releases the runner early, whose next message then interrupts the\n   * still-running handler. An event-driven turn completes via\n   * `handler.event`. Omitted = any turn-handler span (legacy behavior).\n   */\n  acceptSpanNames?: ReadonlySet<string>\n  /**\n   * Quiet window after the handler closes before the turn is considered\n   * settled (default 100 ms). The runner raises it so async follow-through\n   * the handler scheduled \u2014 a tool-started workflow run and its callback,\n   * which only execute AFTER the handler closes \u2014 finishes before the next\n   * message is sent. A message sent into that window can be absorbed by the\n   * follow-through's transcript save and silently skipped as already\n   * processed.\n   */\n  settleQuietMs?: number\n  /** Hard cap on the settle phase (default 2 s; the runner raises it with settleQuietMs). */\n  settleMaxMs?: number\n}\n\n/**\n * Unique key for span deduplication.\n */\nfunction spanKey(span: Span): string {\n  return `${span.id.trace}:${span.id.span}`\n}\n\n/**\n * Type-safe accessor for span.data fields.\n */\nfunction spanData(span: Span): Record<string, unknown> {\n  return span.data && typeof span.data === 'object' ? (span.data as Record<string, unknown>) : {}\n}\n\n/**\n * Span names that mark a Conversation handler reaching the end of a turn.\n *\n * A turn driven by a user message emits `handler.conversation`; a turn driven\n * by an event (a Conversation's `events:` subscription \u2014 e.g. greeting on a\n * conversation-start signal) emits `handler.event`. Both close exactly once\n * per handler invocation, so either is a valid \"turn complete\" signal.\n */\nconst TURN_HANDLER_SPAN_NAMES = new Set(['handler.conversation', 'handler.event'])\n\nfunction isTurnHandlerSpan(span: Span): boolean {\n  return TURN_HANDLER_SPAN_NAMES.has(span.name)\n}\n\nexport class SSECollector {\n  private devServerUrl: string\n  private headers: Record<string, string>\n\n  /** All spans accumulated since connect(), keyed by spanKey for dedup. */\n  private spanMap = new Map<string, Span>()\n\n  /** Index into spanMap insertion order marking where the current turn started. */\n  private turnStartKeys = new Set<string>()\n\n  /** Handler span IDs seen before the current turn (for startTurn filtering). */\n  private seenHandlerKeys = new Set<string>()\n\n  /** Callbacks waiting for span updates. */\n  private waiters: Array<(span: Span) => void> = []\n\n  /** AbortController for the active SSE connection. */\n  private abortController: AbortController | null = null\n\n  /** Whether the background loop is running. */\n  private connected = false\n\n  /** Error from the SSE stream if it died unexpectedly. */\n  private streamError: Error | null = null\n\n  /** Passive counters used only to explain timeout failures. */\n  private updateEventCount = 0\n  private keepaliveEventCount = 0\n  private lastEvent: { name: string; at: number } | null = null\n\n  /** Set while a settle phase is in flight; called by disconnect() to short-circuit. */\n  private _cancelSettle: (() => void) | null = null\n\n  constructor(devServerUrl: string, headers: Record<string, string> = {}) {\n    this.devServerUrl = devServerUrl\n    this.headers = headers\n  }\n\n  /**\n   * Open a streaming SSE connection filtered by conversationId or workflowId.\n   * Starts a background loop that parses SSE events and accumulates spans.\n   */\n  async connect(filter: SSEFilter): Promise<void> {\n    const attributeName = 'conversationId' in filter ? 'conversationId' : 'workflowId'\n    const attributeValue = 'conversationId' in filter ? filter.conversationId : filter.workflowId\n\n    const url = `${this.devServerUrl}/api/traces/stream?attributeName=${encodeURIComponent(attributeName)}&attributeValue=${encodeURIComponent(attributeValue)}`\n\n    this.abortController = new AbortController()\n    const myController = this.abortController\n\n    const response = await fetch(url, {\n      headers: { ...this.headers, Accept: 'text/event-stream' },\n      signal: myController.signal,\n    })\n\n    if (!response.ok) {\n      throw new EvalRunnerError({\n        code: 'SSE_CONNECT_FAILED',\n        message: `SSE connection failed: ${response.status} ${response.statusText}`,\n        expected: true,\n        suggestion: 'Make sure the dev server is running (`adk dev`) and reachable.',\n      })\n    }\n\n    if (!response.body) {\n      throw new EvalRunnerError({ code: 'SSE_NO_BODY', message: 'SSE response has no body' })\n    }\n\n    this.connected = true\n\n    // Start background parsing loop\n    this._consumeStream(response.body).catch((err) => {\n      // Ignore the deliberate abort from repoint(): only the current stream's failure counts.\n      if (this.connected && this.abortController === myController) {\n        this.streamError = err instanceof Error ? err : new Error(String(err))\n      }\n    })\n\n    // Wait for the initial snapshot to arrive before returning.\n    // This ensures that connect() resolves only after the snapshot\n    // has been processed so callers can immediately check spans.\n    await this._waitForSnapshot()\n  }\n\n  /**\n   * Re-point at a new conversation, keeping `spanMap` and `seenHandlerKeys` (so\n   * the earlier conversation stays visible and its completed handler can't\n   * satisfy the next turn). Resets the snapshot latch so connect() awaits the\n   * new conversation's snapshot.\n   */\n  async repoint(filter: SSEFilter): Promise<void> {\n    this.connected = false\n    this.abortController?.abort()\n    this.abortController = null\n    this._cancelSettle?.()\n    this._cancelSettle = null\n    this.waiters = []\n    this.snapshotReceived = false\n    this.snapshotResolvers = []\n    // Clear any prior stream's error so a later timeout reports the new\n    // conversation's state, not a dead connection we intentionally closed.\n    this.streamError = null\n    await this.connect(filter)\n  }\n\n  /**\n   * Mark the beginning of a new turn.\n   * Records which turn-handler span IDs (handler.conversation / handler.event)\n   * have been seen so far, so waitForTurnComplete() only resolves on NEW\n   * handler completions.\n   */\n  startTurn(): void {\n    // Snapshot the current set of span keys as the turn boundary\n    this.turnStartKeys = new Set(this.spanMap.keys())\n\n    // Record all turn-handler spans seen so far\n    for (const [key, span] of this.spanMap) {\n      if (isTurnHandlerSpan(span)) {\n        this.seenHandlerKeys.add(key)\n      }\n    }\n  }\n\n  private static readonly SETTLE_MS = 100\n\n  /**\n   * Wait for a turn-handler span (handler.conversation or handler.event) to\n   * reach terminal status (ok or error).\n   * Only considers spans NOT seen before the last startTurn() call.\n   *\n   * After the handler closes, waits for a quiet period (no new spans for SETTLE_MS)\n   * to ensure all child spans (tool calls, messages, state saves) have arrived.\n   * The runtime's HttpSpanExporter fires POSTs without awaiting them, so child\n   * spans may arrive slightly after the handler close event.\n   */\n  async waitForTurnComplete(opts: TurnWaitOptions): Promise<void> {\n    const accept = opts.acceptSpanNames\n    const settle = { quietMs: opts.settleQuietMs, maxMs: opts.settleMaxMs }\n    // Check if a completed handler already exists (e.g. from snapshot)\n    if (this._hasNewCompletedHandler(accept)) {\n      return this._settleAfterHandler(settle)\n    }\n    if (opts.abortSignal?.aborted) {\n      throw new Error('waitForTurnComplete aborted')\n    }\n\n    return new Promise<void>((resolve, reject) => {\n      const timer = setTimeout(() => {\n        this._removeWaiter(waiter)\n        opts.abortSignal?.removeEventListener('abort', onAbort)\n        const expected = accept ? [...accept].join(' or ') : 'handler.conversation or handler.event'\n        const reason = this.streamError\n          ? `SSE stream died: ${this.streamError.message}`\n          : `no ${expected} span completed`\n        reject(\n          new Error(\n            `waitForTurnComplete timed out after ${opts.timeout}ms \u2014 ${reason}; diagnostics: ${this._formatTurnDiagnostics()}`\n          )\n        )\n      }, opts.timeout)\n\n      const onAbort = () => {\n        clearTimeout(timer)\n        this._removeWaiter(waiter)\n        reject(new Error('waitForTurnComplete aborted'))\n      }\n      opts.abortSignal?.addEventListener('abort', onAbort, { once: true })\n\n      const waiter = (_span: Span) => {\n        if (this._hasNewCompletedHandler(accept)) {\n          clearTimeout(timer)\n          this._removeWaiter(waiter)\n          opts.abortSignal?.removeEventListener('abort', onAbort)\n          this._settleAfterHandler(settle).then(resolve, reject)\n        }\n      }\n\n      this.waiters.push(waiter)\n    })\n  }\n\n  private static readonly MAX_SETTLE_MS = 2_000\n\n  /**\n   * After the handler span closes, wait for spans to stop arriving.\n   * Resolves when no new spans arrive for SETTLE_MS, or after MAX_SETTLE_MS hard cap.\n   *\n   * Exposes a cancellation hook via _cancelSettle so disconnect() can short-\n   * circuit an in-flight settle phase and avoid leaking timers for up to 2s.\n   */\n  private _settleAfterHandler(settle?: { quietMs?: number; maxMs?: number }): Promise<void> {\n    const quietMs = settle?.quietMs ?? SSECollector.SETTLE_MS\n    const maxMs = settle?.maxMs ?? SSECollector.MAX_SETTLE_MS\n    return new Promise<void>((resolve) => {\n      let resolved = false\n      const done = () => {\n        if (resolved) return\n        resolved = true\n        clearTimeout(hardCap)\n        clearTimeout(settleTimer)\n        this._removeWaiter(settleWaiter)\n        this._cancelSettle = null\n        resolve()\n      }\n\n      const hardCap = setTimeout(done, maxMs)\n\n      let settleTimer = setTimeout(done, quietMs)\n\n      const settleWaiter = () => {\n        if (resolved) return\n        clearTimeout(settleTimer)\n        settleTimer = setTimeout(done, quietMs)\n      }\n\n      this.waiters.push(settleWaiter)\n      this._cancelSettle = done\n    })\n  }\n\n  /**\n   * Wait for a handler.workflow span with matching workflow name.\n   * - signal 'entered': resolves when the span appears (any status)\n   * - signal 'completed': resolves when the span has status !== 'running'\n   */\n  async waitForWorkflow(name: string, opts: WorkflowWaitOptions): Promise<void> {\n    // Check if condition is already met\n    if (this._matchesWorkflowCondition(name, opts.signal)) {\n      return\n    }\n    if (opts.abortSignal?.aborted) {\n      throw new Error(`waitForWorkflow(\"${name}\", { signal: \"${opts.signal}\" }) aborted`)\n    }\n\n    return new Promise<void>((resolve, reject) => {\n      const timer = setTimeout(() => {\n        this._removeWaiter(waiter)\n        opts.abortSignal?.removeEventListener('abort', onAbort)\n        const reason = this.streamError ? `SSE stream died: ${this.streamError.message}` : 'span not found'\n        reject(\n          new Error(\n            `waitForWorkflow(\"${name}\", { signal: \"${opts.signal}\" }) timed out after ${opts.timeout}ms \u2014 ${reason}`\n          )\n        )\n      }, opts.timeout)\n\n      const onAbort = () => {\n        clearTimeout(timer)\n        this._removeWaiter(waiter)\n        reject(new Error(`waitForWorkflow(\"${name}\", { signal: \"${opts.signal}\" }) aborted`))\n      }\n      opts.abortSignal?.addEventListener('abort', onAbort, { once: true })\n\n      const waiter = (_span: Span) => {\n        if (this._matchesWorkflowCondition(name, opts.signal)) {\n          clearTimeout(timer)\n          this._removeWaiter(waiter)\n          opts.abortSignal?.removeEventListener('abort', onAbort)\n          resolve()\n        }\n      }\n\n      this.waiters.push(waiter)\n    })\n  }\n\n  /**\n   * Return spans accumulated since the last startTurn() call.\n   */\n  getTurnSpans(): Span[] {\n    const result: Span[] = []\n    for (const [key, span] of this.spanMap) {\n      if (!this.turnStartKeys.has(key)) {\n        result.push(span)\n      }\n    }\n    return result\n  }\n\n  /**\n   * Return all spans accumulated since connect().\n   */\n  getAllSpans(): Span[] {\n    return Array.from(this.spanMap.values())\n  }\n\n  /**\n   * Close the SSE connection and clean up.\n   */\n  disconnect(): void {\n    this.connected = false\n    this.abortController?.abort()\n    this.abortController = null\n    // Short-circuit an in-flight settle phase so its hardCap / settleTimer\n    // don't fire after disconnect.\n    this._cancelSettle?.()\n    this._cancelSettle = null\n    // Waiters hold setTimeout references that will reject on their own;\n    // clearing the array just prevents further notifications.\n    this.waiters = []\n    this.snapshotResolvers = []\n  }\n\n  // \u2500\u2500 Private \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n  /** Whether we have received the initial snapshot. */\n  private snapshotReceived = false\n  private snapshotResolvers: Array<() => void> = []\n\n  private static readonly SNAPSHOT_TIMEOUT_MS = 10_000\n\n  /**\n   * Returns a promise that resolves once the snapshot event has been processed,\n   * or rejects after a timeout to prevent connect() from hanging indefinitely.\n   */\n  private _waitForSnapshot(): Promise<void> {\n    if (this.snapshotReceived) {\n      return Promise.resolve()\n    }\n    return new Promise<void>((resolve, reject) => {\n      let settled = false\n      const resolver = () => {\n        if (settled) return\n        settled = true\n        clearTimeout(timer)\n        resolve()\n      }\n      const timer = setTimeout(() => {\n        if (settled) return\n        settled = true\n        const idx = this.snapshotResolvers.indexOf(resolver)\n        if (idx !== -1) this.snapshotResolvers.splice(idx, 1)\n        reject(\n          new Error(\n            `SSE snapshot not received within ${SSECollector.SNAPSHOT_TIMEOUT_MS}ms \u2014 is the dev server healthy?`\n          )\n        )\n      }, SSECollector.SNAPSHOT_TIMEOUT_MS)\n      this.snapshotResolvers.push(resolver)\n    })\n  }\n\n  /**\n   * Consume the ReadableStream body, parse SSE lines, and dispatch events.\n   */\n  private async _consumeStream(body: ReadableStream<Uint8Array>): Promise<void> {\n    const decoder = new TextDecoder()\n    let buffer = ''\n\n    const reader = body.getReader()\n\n    try {\n      while (this.connected) {\n        const { done, value } = await reader.read()\n        if (done) break\n\n        buffer += decoder.decode(value, { stream: true })\n\n        // Split on double-newline boundaries to get complete SSE events\n        const parts = buffer.split('\\n\\n')\n        // The last part may be incomplete \u2014 keep it in the buffer\n        buffer = parts.pop() ?? ''\n\n        for (const part of parts) {\n          this._parseSSEBlock(part)\n        }\n      }\n    } finally {\n      reader.releaseLock()\n    }\n  }\n\n  /**\n   * Parse a single SSE event block (text between \\n\\n boundaries).\n   * Extracts event name and data payload.\n   */\n  private _parseSSEBlock(block: string): void {\n    const lines = block.split('\\n')\n    let eventName = ''\n    let dataLine = ''\n\n    for (const line of lines) {\n      if (line.startsWith('event:')) {\n        eventName = line.slice('event:'.length).trim()\n      } else if (line.startsWith('data:')) {\n        const value = line.slice('data:'.length).trim()\n        dataLine = dataLine ? `${dataLine}\\n${value}` : value\n      }\n      // id: and retry: lines are ignored\n    }\n\n    if (!eventName || !dataLine) {\n      // Could be a retry: line or empty block \u2014 skip\n      if (!this.snapshotReceived && block.includes('retry:')) {\n        // The retry line comes before the snapshot; don't resolve yet\n      }\n      return\n    }\n\n    try {\n      const payload = JSON.parse(dataLine)\n      this._handleEvent(eventName, payload)\n    } catch {\n      // Malformed JSON \u2014 skip\n    }\n  }\n\n  /**\n   * Dispatch a parsed SSE event to the appropriate handler.\n   */\n  private _handleEvent(eventName: string, payload: unknown): void {\n    this._recordEvent(eventName)\n\n    if (eventName === 'snapshot') {\n      const data = payload as { spans: Span[] }\n      const spans = Array.isArray(data.spans) ? data.spans : []\n      for (const span of spans) {\n        this._upsertSpan(span)\n      }\n      this.snapshotReceived = true\n      for (const resolve of this.snapshotResolvers) {\n        resolve()\n      }\n      this.snapshotResolvers = []\n    } else if (eventName === 'update') {\n      const data = payload as { span: Span }\n      if (data.span) {\n        this._upsertSpan(data.span)\n        this._notifyWaiters(data.span)\n      }\n    }\n    // keepalive events are intentionally ignored\n  }\n\n  private _recordEvent(eventName: string): void {\n    this.lastEvent = { name: eventName, at: Date.now() }\n\n    if (eventName === 'update') {\n      this.updateEventCount++\n    } else if (eventName === 'keepalive') {\n      this.keepaliveEventCount++\n    }\n  }\n\n  private _formatTurnDiagnostics(): string {\n    const turnSpans = this.getTurnSpans()\n    const spanNames = new Set<string>()\n    const handlerStatuses = new Set<string>()\n\n    for (const span of turnSpans) {\n      spanNames.add(span.name)\n      // Tracks both handler.conversation and handler.event so an event-driven\n      // turn that times out still surfaces its handler status.\n      if (isTurnHandlerSpan(span)) {\n        handlerStatuses.add(span.status)\n      }\n    }\n\n    const lastEvent = this.lastEvent ? `${this.lastEvent.name} ${Date.now() - this.lastEvent.at}ms ago` : 'none'\n\n    return [\n      `snapshotReceived=${this.snapshotReceived}`,\n      `totalUpdates=${this.updateEventCount}`,\n      `totalKeepalives=${this.keepaliveEventCount}`,\n      `lastEvent=${lastEvent}`,\n      `totalSpans=${this.spanMap.size}`,\n      `turnSpans=${turnSpans.length}`,\n      `turnSpanNames=${this._formatSet(spanNames)}`,\n      `turnHandlerStatuses=${this._formatSet(handlerStatuses)}`,\n    ].join(', ')\n  }\n\n  private _formatSet(values: Set<string>, limit = 12): string {\n    if (values.size === 0) {\n      return 'none'\n    }\n\n    const items = Array.from(values)\n    const suffix = items.length > limit ? `|+${items.length - limit} more` : ''\n    return `${items.slice(0, limit).join('|')}${suffix}`\n  }\n\n  /**\n   * Insert or replace a span in the map (dedup by trace+span ID).\n   */\n  private _upsertSpan(span: Span): void {\n    this.spanMap.set(spanKey(span), span)\n  }\n\n  /**\n   * Notify all waiters that a new span was received.\n   */\n  private _notifyWaiters(span: Span): void {\n    // Copy the array since waiters may remove themselves during iteration\n    const current = [...this.waiters]\n    for (const waiter of current) {\n      waiter(span)\n    }\n  }\n\n  /**\n   * Remove a waiter callback from the list.\n   */\n  private _removeWaiter(fn: (span: Span) => void): void {\n    const idx = this.waiters.indexOf(fn)\n    if (idx !== -1) {\n      this.waiters.splice(idx, 1)\n    }\n  }\n\n  /**\n   * Check if there is a turn-handler span (handler.conversation / handler.event) that:\n   * 1. Was NOT seen before startTurn()\n   * 2. Has terminal status (ok or error)\n   *\n   * Marks the matched key as consumed so the same handler span cannot\n   * satisfy both the current turn's settle phase AND the next turn's\n   * waitForTurnComplete check (which would otherwise resolve instantly\n   * against stale data instead of waiting for the new turn's handler).\n   */\n  private _hasNewCompletedHandler(acceptSpanNames?: ReadonlySet<string>): boolean {\n    for (const [key, span] of this.spanMap) {\n      if (\n        isTurnHandlerSpan(span) &&\n        (!acceptSpanNames || acceptSpanNames.has(span.name)) &&\n        !this.seenHandlerKeys.has(key) &&\n        (span.status === 'ok' || span.status === 'error')\n      ) {\n        this.seenHandlerKeys.add(key)\n        return true\n      }\n    }\n    return false\n  }\n\n  /**\n   * Check if a handler.workflow span matches the given condition.\n   */\n  private _matchesWorkflowCondition(name: string, signal: 'entered' | 'completed'): boolean {\n    for (const span of this.spanMap.values()) {\n      if (span.name !== 'handler.workflow') continue\n\n      const d = spanData(span)\n      const wfName = d['workflow.name'] || d['workflowName']\n      if (wfName !== name) continue\n\n      if (signal === 'entered') {\n        // Any status means the workflow was entered\n        return true\n      }\n\n      if (signal === 'completed') {\n        return span.status === 'ok' || span.status === 'error'\n      }\n    }\n    return false\n  }\n}\n", "import type { SpanSource, TurnWaitOptions, WaitOptions, WorkflowWaitOptions } from './span-source'\nimport type { Span } from './trace'\nimport { SSECollector } from './sse-collector'\n\nexport class LocalSpanSource implements SpanSource {\n  private collector: SSECollector\n\n  constructor(devServerUrl: string, headers: Record<string, string> = {}) {\n    this.collector = new SSECollector(devServerUrl, headers)\n  }\n\n  async connect(filter: { conversationId: string }): Promise<void> {\n    await this.collector.connect(filter)\n  }\n\n  async repoint(filter: { conversationId: string }): Promise<void> {\n    await this.collector.repoint(filter)\n  }\n\n  startTurn(): void {\n    this.collector.startTurn()\n  }\n\n  async waitForTurnComplete(opts: TurnWaitOptions): Promise<void> {\n    await this.collector.waitForTurnComplete(opts)\n  }\n\n  async waitForWorkflow(name: string, opts: WorkflowWaitOptions): Promise<void> {\n    await this.collector.waitForWorkflow(name, opts)\n  }\n\n  getTurnSpans(): Span[] {\n    return this.collector.getTurnSpans()\n  }\n\n  getAllSpans(): Span[] {\n    return this.collector.getAllSpans()\n  }\n\n  disconnect(): void {\n    this.collector.disconnect()\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/spans/span-source.d.ts

@@ -0,0 +1,40 @@
+import type { Span } from './trace';
+export interface WaitOptions {
+    timeout: number;
+    abortSignal?: AbortSignal;
+}
+export interface WorkflowWaitOptions extends WaitOptions {
+    signal: 'entered' | 'completed';
+}
+export interface TurnWaitOptions extends WaitOptions {
+    /**
+     * Which handler span names may complete this turn (e.g. a user-message turn
+     * completes via `handler.conversation`, an event-driven turn via
+     * `handler.event`). Omitted = any turn-handler span.
+     */
+    acceptSpanNames?: ReadonlySet<string>;
+    /** Quiet window after the handler closes before the turn counts as settled. */
+    settleQuietMs?: number;
+    /** Hard cap on the settle phase. */
+    settleMaxMs?: number;
+}
+export interface SpanSource {
+    connect(filter: {
+        conversationId: string;
+    }): Promise<void>;
+    /**
+     * Re-point the stream at a new conversation, keeping spans already
+     * accumulated (so outcome assertions still see the earlier conversation and
+     * its completed handler can't satisfy the next turn).
+     */
+    repoint(filter: {
+        conversationId: string;
+    }): Promise<void>;
+    startTurn(): void;
+    waitForTurnComplete(opts: TurnWaitOptions): Promise<void>;
+    waitForWorkflow(name: string, opts: WorkflowWaitOptions): Promise<void>;
+    getTurnSpans(): Span[];
+    getAllSpans(): Span[];
+    disconnect(): void;
+}
+//# sourceMappingURL=span-source.d.ts.map

package/dist/spans/span-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"span-source.d.ts","sourceRoot":"","sources":["../../src/spans/span-source.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAEnC,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,CAAC,EAAE,WAAW,CAAA;CAC1B;AAED,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IACtD,MAAM,EAAE,SAAS,GAAG,WAAW,CAAA;CAChC;AAED,MAAM,WAAW,eAAgB,SAAQ,WAAW;IAClD;;;;OAIG;IACH,eAAe,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IACrC,+EAA+E;IAC/E,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,oCAAoC;IACpC,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,CAAC,MAAM,EAAE;QAAE,cAAc,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC1D;;;;OAIG;IACH,OAAO,CAAC,MAAM,EAAE;QAAE,cAAc,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC1D,SAAS,IAAI,IAAI,CAAA;IACjB,mBAAmB,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACzD,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACvE,YAAY,IAAI,IAAI,EAAE,CAAA;IACtB,WAAW,IAAI,IAAI,EAAE,CAAA;IACrB,UAAU,IAAI,IAAI,CAAA;CACnB"}