@bitfab/sdk 0.13.0

package/dist/node.cjs

@@ -0,0 +1,3058 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/asyncStorage.ts
+function registerAsyncLocalStorageClass(cls) {
+  if (!AsyncLocalStorageClass) {
+    AsyncLocalStorageClass = cls;
+  }
+  initDone = true;
+}
+function assertAsyncStorageRegistered() {
+  if (!AsyncLocalStorageClass) {
+    console.warn(
+      "Bitfab: AsyncLocalStorage not available \u2014 nested span context will not propagate."
+    );
+  }
+}
+function isAsyncStorageInitDone() {
+  return initDone;
+}
+function createAsyncLocalStorage() {
+  return AsyncLocalStorageClass ? new AsyncLocalStorageClass() : null;
+}
+var AsyncLocalStorageClass, initDone, asyncStorageReady;
+var init_asyncStorage = __esm({
+  "src/asyncStorage.ts"() {
+    "use strict";
+    AsyncLocalStorageClass = null;
+    initDone = false;
+    asyncStorageReady = (typeof process !== "undefined" && process.versions?.node ? (
+      // The join trick hides "node:async_hooks" from static analysis so
+      // bundlers that ban Node.js built-ins don't fail at build time.
+      // webpackIgnore tells webpack/turbopack to emit a native import()
+      // so Node.js can resolve the module at runtime.
+      import(
+        /* webpackIgnore: true */
+        ["node", "async_hooks"].join(":")
+      ).then(
+        (mod) => {
+          registerAsyncLocalStorageClass(mod.AsyncLocalStorage);
+        }
+      ).catch(() => {
+      })
+    ) : Promise.resolve()).then(() => {
+      initDone = true;
+    });
+  }
+});
+
+// src/version.generated.ts
+var __version__;
+var init_version_generated = __esm({
+  "src/version.generated.ts"() {
+    "use strict";
+    __version__ = "0.13.0";
+  }
+});
+
+// src/constants.ts
+var DEFAULT_SERVICE_URL;
+var init_constants = __esm({
+  "src/constants.ts"() {
+    "use strict";
+    init_version_generated();
+    DEFAULT_SERVICE_URL = "https://bitfab.ai";
+  }
+});
+
+// src/http.ts
+function awaitOnExit(promise) {
+  pendingTracePromises.add(promise);
+  void promise.finally(() => {
+    pendingTracePromises.delete(promise);
+  }).catch(() => {
+  });
+  return promise;
+}
+async function flushTraces(timeoutMs = 5e3) {
+  if (pendingTracePromises.size === 0) {
+    return;
+  }
+  await Promise.race([
+    Promise.allSettled(Array.from(pendingTracePromises)),
+    new Promise((resolve) => setTimeout(resolve, timeoutMs))
+  ]);
+}
+var BitfabError, pendingTracePromises, HttpClient;
+var init_http = __esm({
+  "src/http.ts"() {
+    "use strict";
+    init_constants();
+    BitfabError = class extends Error {
+      constructor(message, url) {
+        super(message);
+        this.url = url;
+        this.name = "BitfabError";
+      }
+    };
+    pendingTracePromises = /* @__PURE__ */ new Set();
+    if (typeof process !== "undefined" && process.versions != null && process.versions.node != null) {
+      let isFlushing = false;
+      process.on("beforeExit", () => {
+        if (pendingTracePromises.size > 0 && !isFlushing) {
+          isFlushing = true;
+          Promise.allSettled(
+            Array.from(pendingTracePromises).map(
+              (p) => p.catch(() => {
+              })
+            )
+          ).then(() => {
+            isFlushing = false;
+          }).catch(() => {
+            isFlushing = false;
+          });
+        }
+      });
+    }
+    HttpClient = class {
+      constructor(config) {
+        this.apiKey = config.apiKey;
+        this.serviceUrl = config.serviceUrl;
+        this.timeout = config.timeout ?? 12e4;
+      }
+      /**
+       * Make an HTTP request to the Bitfab API. Defaults to POST; pass
+       * `options.method` to use a different verb (e.g. "PATCH").
+       *
+       * @param endpoint - The API endpoint (without base URL)
+       * @param payload - The request body
+       * @param options - Optional request options
+       * @returns The parsed JSON response
+       * @throws {BitfabError} If the request fails
+       */
+      async request(endpoint, payload, options) {
+        const url = `${this.serviceUrl}${endpoint}`;
+        const timeout = options?.timeout ?? this.timeout;
+        const method = options?.method ?? "POST";
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        let body;
+        let serializationError;
+        try {
+          body = JSON.stringify(payload);
+        } catch (error) {
+          serializationError = error instanceof Error ? error.message : String(error);
+          body = JSON.stringify({
+            ...Object.fromEntries(
+              Object.entries(payload).filter(
+                ([, v]) => typeof v === "string" || typeof v === "number"
+              )
+            ),
+            rawSpan: {},
+            errors: [{ step: "json_serialize", error: serializationError }]
+          });
+        }
+        try {
+          const response = await fetch(url, {
+            method,
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${this.apiKey}`
+            },
+            body,
+            signal: controller.signal
+          });
+          if (!response.ok) {
+            const errorText = await response.text();
+            throw new BitfabError(
+              `HTTP ${response.status}: ${errorText.slice(0, 500)}`
+            );
+          }
+          const result = await response.json();
+          if (result.error) {
+            if (result.url) {
+              throw new BitfabError(
+                `${result.error} Configure it at: ${this.serviceUrl}${result.url}`,
+                result.url
+              );
+            }
+            throw new BitfabError(result.error);
+          }
+          return result;
+        } catch (error) {
+          if (error instanceof BitfabError) {
+            throw error;
+          }
+          if (error instanceof Error) {
+            if (error.name === "AbortError") {
+              throw new BitfabError(`Request timed out after ${timeout}ms`);
+            }
+            throw new BitfabError(error.message);
+          }
+          throw new BitfabError("Unknown error occurred");
+        } finally {
+          clearTimeout(timeoutId);
+        }
+      }
+      /**
+       * Look up a function by name.
+       * Blocks until complete - needed for function execution.
+       */
+      async lookupFunction(name) {
+        return this.request("/api/sdk/functions/lookup", { name });
+      }
+      /**
+       * Send an internal trace (from BAML execution).
+       * Fire-and-forget with awaitOnExit - doesn't block the caller.
+       */
+      sendInternalTrace(functionId, payload) {
+        void awaitOnExit(
+          this.request(`/api/sdk/functions/${functionId}/traces`, {
+            ...payload,
+            sdkVersion: __version__
+          })
+        ).catch((error) => {
+          try {
+            console.error("Bitfab: Failed to create trace:", error);
+          } catch {
+          }
+        });
+      }
+      /**
+       * Send an external span (from withSpan wrapper or OpenAI tracing).
+       * Fire-and-forget with awaitOnExit - doesn't block the caller.
+       * Returns the tracked promise so callers can optionally await it.
+       */
+      sendExternalSpan(payload) {
+        return awaitOnExit(
+          this.request("/api/sdk/externalSpans", {
+            ...payload,
+            sdkVersion: __version__
+          })
+        ).catch((error) => {
+          try {
+            console.error("Bitfab: Failed to create external span:", error);
+          } catch {
+          }
+        });
+      }
+      /**
+       * Send an external trace (from OpenAI tracing).
+       * Fire-and-forget with awaitOnExit - doesn't block the caller.
+       */
+      sendExternalTrace(payload) {
+        void awaitOnExit(
+          this.request("/api/sdk/externalTraces", {
+            ...payload,
+            sdkVersion: __version__
+          })
+        ).catch((error) => {
+          try {
+            console.error("Bitfab: Failed to create external trace:", error);
+          } catch {
+          }
+        });
+      }
+      /**
+       * Partial update of an existing external trace identified by sourceTraceId.
+       * Used by the detached `client.getTrace(id)` handle. Fire-and-forget;
+       * returns a tracked promise that callers may optionally await.
+       */
+      patchTrace(sourceTraceId, payload) {
+        const endpoint = `/api/sdk/externalTraces/${encodeURIComponent(sourceTraceId)}`;
+        return awaitOnExit(
+          this.request(endpoint, payload, { method: "PATCH" })
+        ).catch((error) => {
+          try {
+            console.error("Bitfab: Failed to patch trace:", error);
+          } catch {
+          }
+        });
+      }
+      /**
+       * Start a replay session by fetching historical traces.
+       * Blocking call — creates a test run and returns lightweight item references.
+       */
+      async startReplay(traceFunctionKey, limit, traceIds, codeChangeDescription, codeChangeFiles) {
+        const payload = { traceFunctionKey, limit };
+        if (traceIds) {
+          payload.traceIds = traceIds;
+        }
+        if (codeChangeDescription !== void 0) {
+          payload.codeChangeDescription = codeChangeDescription;
+        }
+        if (codeChangeFiles !== void 0) {
+          payload.codeChangeFiles = codeChangeFiles;
+        }
+        return this.request("/api/sdk/replay/start", payload, {
+          timeout: 3e4
+        });
+      }
+      /**
+       * Fetch an external span by ID.
+       * Blocking GET request.
+       */
+      async getExternalSpan(spanId) {
+        const url = `${this.serviceUrl}/api/sdk/externalSpans/${spanId}`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 3e4);
+        try {
+          const response = await fetch(url, {
+            method: "GET",
+            headers: { Authorization: `Bearer ${this.apiKey}` },
+            signal: controller.signal
+          });
+          if (!response.ok) {
+            const errorText = await response.text();
+            throw new BitfabError(
+              `HTTP ${response.status}: ${errorText.slice(0, 500)}`
+            );
+          }
+          return await response.json();
+        } catch (error) {
+          if (error instanceof BitfabError) {
+            throw error;
+          }
+          if (error instanceof Error) {
+            if (error.name === "AbortError") {
+              throw new BitfabError("Request timed out after 30000ms");
+            }
+            throw new BitfabError(error.message);
+          }
+          throw new BitfabError("Unknown error occurred");
+        } finally {
+          clearTimeout(timeoutId);
+        }
+      }
+      /**
+       * Fetch the span tree for a root span.
+       * Blocking GET request.
+       */
+      async getSpanTree(externalSpanId) {
+        const url = `${this.serviceUrl}/api/sdk/replay/spanTree/${externalSpanId}`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 3e4);
+        try {
+          const response = await fetch(url, {
+            method: "GET",
+            headers: { Authorization: `Bearer ${this.apiKey}` },
+            signal: controller.signal
+          });
+          if (!response.ok) {
+            const errorText = await response.text();
+            throw new BitfabError(
+              `HTTP ${response.status}: ${errorText.slice(0, 500)}`
+            );
+          }
+          return await response.json();
+        } catch (error) {
+          if (error instanceof BitfabError) {
+            throw error;
+          }
+          if (error instanceof Error) {
+            if (error.name === "AbortError") {
+              throw new BitfabError("Request timed out after 30000ms");
+            }
+            throw new BitfabError(error.message);
+          }
+          throw new BitfabError("Unknown error occurred");
+        } finally {
+          clearTimeout(timeoutId);
+        }
+      }
+      /**
+       * Mark a replay test run as completed.
+       * Blocking call.
+       */
+      async completeReplay(testRunId) {
+        return this.request(
+          "/api/sdk/replay/complete",
+          { testRunId },
+          { timeout: 3e4 }
+        );
+      }
+    };
+  }
+});
+
+// src/replayContext.ts
+function getReplayContext() {
+  return replayContextStorage?.getStore() ?? null;
+}
+function runWithReplayContext(ctx, fn) {
+  if (replayContextStorage) {
+    return replayContextStorage.run(ctx, fn);
+  }
+  return fn();
+}
+var replayContextStorage, replayContextReady;
+var init_replayContext = __esm({
+  "src/replayContext.ts"() {
+    "use strict";
+    init_asyncStorage();
+    replayContextStorage = null;
+    replayContextReady = asyncStorageReady.then(() => {
+      replayContextStorage = createAsyncLocalStorage();
+    });
+  }
+});
+
+// src/serialize.ts
+function serializeValue(value) {
+  try {
+    const { json, meta } = import_superjson.default.serialize(value);
+    return meta ? { json, meta } : { json };
+  } catch {
+    try {
+      return { json: JSON.parse(JSON.stringify(value)) };
+    } catch {
+      return { json: String(value) };
+    }
+  }
+}
+function deserializeValue(serialized) {
+  if (serialized.meta === void 0) {
+    return serialized.json;
+  }
+  return import_superjson.default.deserialize({
+    json: serialized.json,
+    meta: serialized.meta
+  });
+}
+var import_superjson;
+var init_serialize = __esm({
+  "src/serialize.ts"() {
+    "use strict";
+    import_superjson = __toESM(require("superjson"), 1);
+  }
+});
+
+// src/replay.ts
+var replay_exports = {};
+__export(replay_exports, {
+  replay: () => replay
+});
+function deserializeInputs(spanData) {
+  const inputMeta = spanData.input_meta;
+  const rawInput = spanData.input;
+  if (inputMeta !== void 0 && inputMeta !== null) {
+    const deserialized = deserializeValue({ json: rawInput, meta: inputMeta });
+    if (Array.isArray(deserialized)) {
+      return deserialized;
+    }
+    return deserialized !== void 0 && deserialized !== null ? [deserialized] : [];
+  }
+  if (Array.isArray(rawInput)) {
+    return rawInput;
+  }
+  return rawInput !== void 0 && rawInput !== null ? [rawInput] : [];
+}
+function deserializeOutput(spanData) {
+  const outputMeta = spanData.output_meta;
+  const rawOutput = spanData.output;
+  if (outputMeta !== void 0 && outputMeta !== null) {
+    return deserializeValue({ json: rawOutput, meta: outputMeta });
+  }
+  return rawOutput;
+}
+function buildMockTree(rootNode) {
+  const spans = /* @__PURE__ */ new Map();
+  const counters = /* @__PURE__ */ new Map();
+  function walk(node) {
+    const key = node.traceFunctionKey;
+    if (key) {
+      const name = node.spanName;
+      const counterKey = `${key}:${name}`;
+      const index = counters.get(counterKey) ?? 0;
+      counters.set(counterKey, index + 1);
+      spans.set(`${counterKey}:${index}`, {
+        sourceSpanId: node.sourceSpanId,
+        output: node.output,
+        outputMeta: node.outputMeta
+      });
+    }
+    for (const child of node.children) {
+      walk(child);
+    }
+  }
+  for (const child of rootNode.children) {
+    walk(child);
+  }
+  return { spans };
+}
+async function processItem(httpClient, serverItem, fn, testRunId, mockStrategy) {
+  const span = await httpClient.getExternalSpan(serverItem.externalSpanId);
+  const spanData = span.rawData?.span_data ?? {};
+  const inputs = deserializeInputs(spanData);
+  const originalOutput = deserializeOutput(spanData);
+  let mockTree;
+  if (mockStrategy === "all" || mockStrategy === "marked") {
+    const treeResponse = await httpClient.getSpanTree(serverItem.externalSpanId);
+    mockTree = buildMockTree(treeResponse.root);
+  }
+  let result;
+  let error = null;
+  try {
+    const maybePromise = runWithReplayContext(
+      {
+        testRunId,
+        inputSourceSpanId: span.id,
+        inputSourceTraceId: span.externalTraceId,
+        mockTree,
+        callCounters: mockTree ? /* @__PURE__ */ new Map() : void 0,
+        mockStrategy
+      },
+      () => fn(...inputs)
+    );
+    result = maybePromise instanceof Promise ? await maybePromise : maybePromise;
+  } catch (e) {
+    error = e instanceof Error ? e.message : String(e);
+  }
+  return {
+    input: inputs,
+    result,
+    originalOutput,
+    error,
+    durationMs: serverItem.durationMs ?? null,
+    tokens: serverItem.tokens ?? null,
+    model: serverItem.model ?? null
+  };
+}
+async function mapWithConcurrency(tasks, maxConcurrency) {
+  const results = new Array(tasks.length);
+  let nextIndex = 0;
+  async function worker() {
+    while (nextIndex < tasks.length) {
+      const index = nextIndex++;
+      results[index] = await tasks[index]();
+    }
+  }
+  const workers = Array.from(
+    { length: Math.min(maxConcurrency, tasks.length) },
+    () => worker()
+  );
+  await Promise.all(workers);
+  return results;
+}
+async function replay(httpClient, serviceUrl, traceFunctionKey, fn, options) {
+  await replayContextReady;
+  const {
+    testRunId,
+    testRunUrl,
+    items: serverItems
+  } = await httpClient.startReplay(
+    traceFunctionKey,
+    options?.limit ?? 5,
+    options?.traceIds,
+    options?.codeChangeDescription,
+    options?.codeChangeFiles
+  );
+  const mockStrategy = options?.mock ?? "none";
+  const maxConcurrency = options?.maxConcurrency ?? 10;
+  const tasks = serverItems.map(
+    (serverItem) => () => processItem(httpClient, serverItem, fn, testRunId, mockStrategy)
+  );
+  const resultItems = await mapWithConcurrency(tasks, maxConcurrency);
+  await flushTraces();
+  try {
+    await httpClient.completeReplay(testRunId);
+  } catch (e) {
+    try {
+      console.error("Bitfab: Failed to complete replay:", e);
+    } catch {
+    }
+  }
+  return {
+    items: resultItems,
+    testRunId,
+    testRunUrl: `${serviceUrl}${testRunUrl}`
+  };
+}
+var init_replay = __esm({
+  "src/replay.ts"() {
+    "use strict";
+    init_http();
+    init_replayContext();
+    init_serialize();
+  }
+});
+
+// src/node.ts
+var node_exports = {};
+__export(node_exports, {
+  Bitfab: () => Bitfab,
+  BitfabClaudeAgentHandler: () => BitfabClaudeAgentHandler,
+  BitfabError: () => BitfabError,
+  BitfabFunction: () => BitfabFunction,
+  BitfabLangGraphCallbackHandler: () => BitfabLangGraphCallbackHandler,
+  BitfabOpenAITracingProcessor: () => BitfabOpenAITracingProcessor,
+  DEFAULT_SERVICE_URL: () => DEFAULT_SERVICE_URL,
+  __version__: () => __version__,
+  flushTraces: () => flushTraces,
+  getCurrentSpan: () => getCurrentSpan,
+  getCurrentTrace: () => getCurrentTrace
+});
+module.exports = __toCommonJS(node_exports);
+
+// src/asyncStorageNode.ts
+var import_node_async_hooks = require("async_hooks");
+init_asyncStorage();
+registerAsyncLocalStorageClass(
+  import_node_async_hooks.AsyncLocalStorage
+);
+
+// src/claudeAgentSdk.ts
+init_constants();
+init_http();
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function safeSerialize(value) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(safeSerialize);
+  }
+  if (typeof value === "object") {
+    if (typeof value.toJSON === "function") {
+      return value.toJSON();
+    }
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (!k.startsWith("_")) {
+        result[k] = safeSerialize(v);
+      }
+    }
+    return result;
+  }
+  return String(value);
+}
+function extractContentBlocks(content) {
+  if (!Array.isArray(content)) {
+    return [];
+  }
+  return content.map((block) => safeSerialize(block));
+}
+function extractUsage(message) {
+  const usageInfo = {};
+  const usage = message.usage;
+  if (!usage) {
+    return usageInfo;
+  }
+  const mapping = {
+    input_tokens: "inputTokens",
+    output_tokens: "outputTokens",
+    cache_read_input_tokens: "cacheReadTokens",
+    cache_creation_input_tokens: "cacheCreationTokens"
+  };
+  for (const [srcKey, dstKey] of Object.entries(mapping)) {
+    const val = usage[srcKey];
+    if (val !== void 0 && val !== null) {
+      usageInfo[dstKey] = val;
+    }
+  }
+  return usageInfo;
+}
+var BitfabClaudeAgentHandler = class {
+  constructor(config) {
+    // Span tracking
+    this.runToSpan = /* @__PURE__ */ new Map();
+    this.traceId = null;
+    this.rootSpanId = null;
+    this.activeContext = null;
+    this.traceStartedAt = null;
+    // LLM turn tracking
+    this.conversationHistory = [];
+    this.pendingMessages = [];
+    this.currentLlmSpanId = null;
+    this.currentLlmMessageId = null;
+    this.currentLlmContent = [];
+    this.currentLlmModel = null;
+    this.currentLlmUsage = {};
+    this.currentLlmStartedAt = null;
+    this.currentLlmHistorySnapshot = [];
+    // Subagent tracking
+    this.activeSubagentSpans = /* @__PURE__ */ new Map();
+    this.httpClient = new HttpClient({
+      apiKey: config.apiKey,
+      serviceUrl: config.serviceUrl ?? DEFAULT_SERVICE_URL,
+      timeout: config.timeout ?? 1e4
+    });
+    this.traceFunctionKey = config.traceFunctionKey;
+    this.getActiveSpanContext = config.getActiveSpanContext ?? null;
+    this.preToolUseHook = this.preToolUseHook.bind(this);
+    this.postToolUseHook = this.postToolUseHook.bind(this);
+    this.postToolUseFailureHook = this.postToolUseFailureHook.bind(this);
+    this.subagentStartHook = this.subagentStartHook.bind(this);
+    this.subagentStopHook = this.subagentStopHook.bind(this);
+  }
+  // ── trace lifecycle ──────────────────────────────────────────
+  ensureTrace() {
+    if (this.traceId !== null) {
+      return this.traceId;
+    }
+    this.activeContext = this.getActiveSpanContext?.() ?? null;
+    if (this.activeContext) {
+      this.traceId = this.activeContext.traceId;
+    } else {
+      this.traceId = crypto.randomUUID();
+    }
+    this.traceStartedAt = nowIso();
+    return this.traceId;
+  }
+  getParentId(agentId) {
+    if (agentId) {
+      const subagentSpanId = this.activeSubagentSpans.get(agentId);
+      if (subagentSpanId) {
+        return subagentSpanId;
+      }
+    }
+    return this.activeContext?.spanId ?? this.rootSpanId ?? null;
+  }
+  // ── span helpers ─────────────────────────────────────────────
+  startSpan(spanId, name, spanType, inputData, parentId) {
+    const traceId = this.ensureTrace();
+    const spanInfo = {
+      spanId,
+      traceId,
+      parentId: parentId ?? null,
+      startedAt: nowIso(),
+      name,
+      type: spanType,
+      input: safeSerialize(inputData),
+      contexts: []
+    };
+    this.runToSpan.set(spanId, spanInfo);
+    return spanInfo;
+  }
+  completeSpan(spanId, output, error, extraContexts) {
+    const spanInfo = this.runToSpan.get(spanId);
+    if (!spanInfo) {
+      return;
+    }
+    this.runToSpan.delete(spanId);
+    spanInfo.endedAt = nowIso();
+    spanInfo.output = safeSerialize(output);
+    if (error !== void 0) {
+      spanInfo.error = error;
+    }
+    if (extraContexts) {
+      spanInfo.contexts.push(extraContexts);
+    }
+    this.sendSpan(spanInfo);
+  }
+  sendSpan(spanInfo) {
+    const spanData = {
+      name: spanInfo.name,
+      type: spanInfo.type
+    };
+    if (spanInfo.input !== void 0) {
+      spanData.input = spanInfo.input;
+    }
+    if (spanInfo.output !== void 0) {
+      spanData.output = spanInfo.output;
+    }
+    if (spanInfo.error !== void 0) {
+      spanData.error = spanInfo.error;
+    }
+    if (spanInfo.contexts.length > 0) {
+      spanData.contexts = spanInfo.contexts;
+    }
+    const rawSpan = {
+      id: spanInfo.spanId,
+      trace_id: spanInfo.traceId,
+      started_at: spanInfo.startedAt,
+      ended_at: spanInfo.endedAt ?? nowIso(),
+      span_data: spanData
+    };
+    if (spanInfo.parentId !== null) {
+      rawSpan.parent_id = spanInfo.parentId;
+    }
+    const payload = {
+      type: "sdk-function",
+      source: "typescript-sdk-claude-agent-sdk",
+      traceFunctionKey: this.traceFunctionKey,
+      sourceTraceId: spanInfo.traceId,
+      rawSpan
+    };
+    try {
+      this.httpClient.sendExternalSpan(payload);
+    } catch {
+    }
+  }
+  sendTraceCompletion(endedAt, metadata) {
+    if (this.traceId === null) {
+      return;
+    }
+    const completed = this.activeContext === null;
+    const traceId = this.traceId;
+    this.traceId = null;
+    const externalTrace = {
+      id: traceId,
+      started_at: this.traceStartedAt ?? nowIso(),
+      ended_at: endedAt ?? nowIso(),
+      workflow_name: this.traceFunctionKey
+    };
+    if (metadata) {
+      externalTrace.metadata = metadata;
+    }
+    const traceData = {
+      type: "sdk-function",
+      source: "typescript-sdk-claude-agent-sdk",
+      traceFunctionKey: this.traceFunctionKey,
+      externalTrace,
+      completed
+    };
+    try {
+      this.httpClient.sendExternalTrace(traceData);
+    } catch {
+    }
+  }
+  // ── hook callbacks ───────────────────────────────────────────
+  async preToolUseHook(inputData, toolUseId, _context) {
+    try {
+      const sid = inputData.tool_use_id ?? toolUseId ?? crypto.randomUUID();
+      const toolName = inputData.tool_name ?? "tool";
+      const toolInput = inputData.tool_input ?? {};
+      const agentId = inputData.agent_id;
+      const parentId = this.getParentId(agentId);
+      this.startSpan(sid, toolName, "function", toolInput, parentId);
+    } catch {
+    }
+    return {};
+  }
+  async postToolUseHook(inputData, toolUseId, _context) {
+    try {
+      const sid = inputData.tool_use_id ?? toolUseId ?? "";
+      const toolResponse = inputData.tool_response;
+      this.completeSpan(sid, toolResponse);
+    } catch {
+    }
+    return {};
+  }
+  async postToolUseFailureHook(inputData, toolUseId, _context) {
+    try {
+      const sid = inputData.tool_use_id ?? toolUseId ?? "";
+      const error = String(inputData.error ?? "Unknown error");
+      this.completeSpan(sid, void 0, error);
+    } catch {
+    }
+    return {};
+  }
+  async subagentStartHook(inputData, _toolUseId, _context) {
+    try {
+      const agentId = inputData.agent_id ?? crypto.randomUUID();
+      const agentType = inputData.agent_type ?? "subagent";
+      const parentId = this.getParentId();
+      const spanId = crypto.randomUUID();
+      this.activeSubagentSpans.set(agentId, spanId);
+      this.startSpan(
+        spanId,
+        `Agent: ${agentType}`,
+        "agent",
+        void 0,
+        parentId
+      );
+    } catch {
+    }
+    return {};
+  }
+  async subagentStopHook(inputData, _toolUseId, _context) {
+    try {
+      const agentId = inputData.agent_id ?? "";
+      const spanId = this.activeSubagentSpans.get(agentId);
+      if (spanId) {
+        this.activeSubagentSpans.delete(agentId);
+        this.completeSpan(spanId);
+      }
+    } catch {
+    }
+    return {};
+  }
+  // ── public API ───────────────────────────────────────────────
+  /**
+   * Inject Bitfab tracing hooks into Claude Agent SDK options.
+   *
+   * Modifies the options object and returns it for convenience.
+   * The SDK's `HookMatcher` is constructed as a plain object
+   * (`{ matcher: null, hooks: [callback] }`) to avoid requiring
+   * `@anthropic-ai/claude-agent-sdk` as a dependency.
+   *
+   * @param options - Options object with a `hooks` property
+   * @returns The modified options object with Bitfab hooks injected
+   */
+  instrumentOptions(options) {
+    const hooks = options.hooks ?? {};
+    if (!options.hooks) {
+      ;
+      options.hooks = hooks;
+    }
+    const hookConfig = [
+      ["PreToolUse", this.preToolUseHook],
+      ["PostToolUse", this.postToolUseHook],
+      ["PostToolUseFailure", this.postToolUseFailureHook],
+      ["SubagentStart", this.subagentStartHook],
+      ["SubagentStop", this.subagentStopHook]
+    ];
+    for (const [event, callback] of hookConfig) {
+      if (!hooks[event]) {
+        hooks[event] = [];
+      }
+      hooks[event].push({ matcher: null, hooks: [callback] });
+    }
+    return options;
+  }
+  /**
+   * Wrap a `ClaudeSDKClient.receiveResponse()` stream to capture LLM turns.
+   *
+   * Yields every message unchanged while capturing AssistantMessage
+   * content as LLM turn spans.
+   */
+  async *wrapResponse(stream) {
+    yield* this.processStream(stream);
+  }
+  /**
+   * Wrap a `query()` async iterator to capture LLM turns.
+   *
+   * Same as `wrapResponse` but for the simpler `query()` API
+   * which does not support hooks (no tool/subagent spans).
+   */
+  async *wrapQuery(stream) {
+    yield* this.processStream(stream);
+  }
+  // ── stream processing ────────────────────────────────────────
+  async *processStream(stream) {
+    try {
+      for await (const message of stream) {
+        try {
+          this.processMessage(message);
+        } catch {
+        }
+        yield message;
+      }
+    } finally {
+      try {
+        this.flushLlmTurn();
+        this.sendTraceCompletion();
+      } catch {
+      }
+      this.resetState();
+    }
+  }
+  processMessage(message) {
+    const typeName = message.constructor?.name ?? "";
+    if (typeName === "AssistantMessage") {
+      this.handleAssistantMessage(message);
+    } else if (typeName === "UserMessage") {
+      this.handleUserMessage(message);
+    } else if (typeName === "ResultMessage") {
+      this.handleResultMessage(message);
+    }
+  }
+  handleAssistantMessage(message) {
+    this.ensureTrace();
+    const messageId = message.message_id;
+    if (messageId !== this.currentLlmMessageId) {
+      this.flushLlmTurn();
+      this.conversationHistory.push(...this.pendingMessages);
+      this.pendingMessages = [];
+      this.currentLlmSpanId = crypto.randomUUID();
+      this.currentLlmMessageId = messageId ?? null;
+      this.currentLlmContent = [];
+      this.currentLlmModel = message.model ?? null;
+      this.currentLlmUsage = {};
+      this.currentLlmStartedAt = nowIso();
+      this.currentLlmHistorySnapshot = [...this.conversationHistory];
+    }
+    const content = message.content;
+    if (Array.isArray(content)) {
+      this.currentLlmContent.push(...extractContentBlocks(content));
+    }
+    const usage = extractUsage(message);
+    if (Object.keys(usage).length > 0) {
+      Object.assign(this.currentLlmUsage, usage);
+    }
+    const model = message.model;
+    if (model) {
+      this.currentLlmModel = model;
+    }
+  }
+  handleUserMessage(message) {
+    const content = message.content;
+    const toolUseResult = message.tool_use_result;
+    if (toolUseResult !== void 0) {
+      this.pendingMessages.push({
+        role: "tool",
+        content: safeSerialize(content),
+        tool_result: safeSerialize(toolUseResult)
+      });
+    } else {
+      this.pendingMessages.push({
+        role: "user",
+        content: safeSerialize(content)
+      });
+    }
+  }
+  handleResultMessage(message) {
+    this.flushLlmTurn();
+    const metadata = {};
+    for (const attr of [
+      "num_turns",
+      "total_cost_usd",
+      "duration_ms",
+      "duration_api_ms",
+      "session_id"
+    ]) {
+      const val = message[attr];
+      if (val !== void 0 && val !== null) {
+        metadata[attr] = val;
+      }
+    }
+    const usage = message.usage;
+    if (usage && typeof usage === "object") {
+      metadata.usage = safeSerialize(usage);
+    }
+    this.sendTraceCompletion(
+      void 0,
+      Object.keys(metadata).length > 0 ? metadata : void 0
+    );
+  }
+  flushLlmTurn() {
+    if (this.currentLlmSpanId === null) {
+      return;
+    }
+    const spanId = this.currentLlmSpanId;
+    const traceId = this.ensureTrace();
+    const parentId = this.getParentId();
+    const llmContext = {};
+    if (this.currentLlmModel) {
+      llmContext.model = this.currentLlmModel;
+    }
+    Object.assign(llmContext, this.currentLlmUsage);
+    const spanInfo = {
+      spanId,
+      traceId,
+      parentId,
+      startedAt: this.currentLlmStartedAt ?? nowIso(),
+      endedAt: nowIso(),
+      name: this.currentLlmModel ?? "llm",
+      type: "llm",
+      input: this.currentLlmHistorySnapshot,
+      output: this.currentLlmContent,
+      contexts: Object.keys(llmContext).length > 0 ? [llmContext] : []
+    };
+    this.sendSpan(spanInfo);
+    this.conversationHistory.push({
+      role: "assistant",
+      content: this.currentLlmContent
+    });
+    this.currentLlmSpanId = null;
+    this.currentLlmMessageId = null;
+    this.currentLlmContent = [];
+    this.currentLlmModel = null;
+    this.currentLlmUsage = {};
+    this.currentLlmStartedAt = null;
+    this.currentLlmHistorySnapshot = [];
+  }
+  resetState() {
+    this.runToSpan.clear();
+    this.traceId = null;
+    this.rootSpanId = null;
+    this.activeContext = null;
+    this.traceStartedAt = null;
+    this.conversationHistory = [];
+    this.pendingMessages = [];
+    this.currentLlmSpanId = null;
+    this.currentLlmMessageId = null;
+    this.currentLlmContent = [];
+    this.currentLlmModel = null;
+    this.currentLlmUsage = {};
+    this.currentLlmStartedAt = null;
+    this.currentLlmHistorySnapshot = [];
+    this.activeSubagentSpans.clear();
+  }
+};
+
+// src/client.ts
+init_asyncStorage();
+
+// src/baml.ts
+var cachedBaml = null;
+async function loadBaml() {
+  if (cachedBaml) {
+    return cachedBaml;
+  }
+  try {
+    cachedBaml = await import("@boundaryml/baml");
+    return cachedBaml;
+  } catch {
+    throw new Error(
+      "@boundaryml/baml is required for Bitfab.call(). Install it with: npm install @boundaryml/baml"
+    );
+  }
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function formatProvider(provider) {
+  const providerMap = {
+    openai: "OpenAI",
+    anthropic: "Anthropic",
+    google: "Google"
+  };
+  return providerMap[provider] ?? capitalize(provider);
+}
+function formatModel(model) {
+  return model.replace(/^gpt-/, "GPT").replace(/\./g, "_").replace(/-/g, "_");
+}
+function getClientName(provider, model) {
+  return `${formatProvider(provider)}_${formatModel(model)}`;
+}
+function generateClientDefinitions(providers) {
+  const definitions = [];
+  for (const providerDef of providers) {
+    for (const model of providerDef.models) {
+      const clientName = getClientName(providerDef.provider, model.model);
+      definitions.push(`client<llm> ${clientName} {
+  provider ${providerDef.provider}
+  options {
+    model "${model.model}"
+    api_key env.${providerDef.apiKeyEnv}
+  }
+}`);
+    }
+  }
+  return definitions.join("\n\n");
+}
+function withDefaultClients(bamlSource, providers) {
+  const hasDefaultClient = bamlSource.includes("client<llm> OpenAI_");
+  if (hasDefaultClient) {
+    return bamlSource;
+  }
+  const defaultClients = generateClientDefinitions(providers);
+  return `${defaultClients}
+
+${bamlSource}`;
+}
+function extractFunctionName(bamlSource) {
+  const match = bamlSource.match(/function\s+(\w+)\s*\(/);
+  return match?.[1] ?? null;
+}
+function extractFunctionParameters(bamlSource) {
+  const functionMatch = bamlSource.match(/function\s+\w+\s*\(([^)]*)\)\s*->/);
+  if (!functionMatch) {
+    return [];
+  }
+  const paramsString = functionMatch[1].trim();
+  if (!paramsString) {
+    return [];
+  }
+  const params = [];
+  const paramParts = splitParameters(paramsString);
+  for (const part of paramParts) {
+    const trimmed = part.trim();
+    if (!trimmed) {
+      continue;
+    }
+    const paramMatch = trimmed.match(/^(\w+)\s*:\s*(.+)$/);
+    if (paramMatch) {
+      const name = paramMatch[1];
+      let type = paramMatch[2].trim();
+      const isOptional = type.endsWith("?");
+      if (isOptional) {
+        type = type.slice(0, -1);
+      }
+      params.push({ name, type, isOptional });
+    }
+  }
+  return params;
+}
+function splitParameters(paramsString) {
+  const parts = [];
+  let current = "";
+  let depth = 0;
+  for (const char of paramsString) {
+    if (char === "<") {
+      depth++;
+      current += char;
+    } else if (char === ">") {
+      depth--;
+      current += char;
+    } else if (char === "," && depth === 0) {
+      parts.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  if (current.trim()) {
+    parts.push(current);
+  }
+  return parts;
+}
+function coerceToType(value, expectedType) {
+  if (expectedType === "string") {
+    return value;
+  }
+  if (expectedType === "int") {
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isNaN(parsed)) {
+      return parsed;
+    }
+    return value;
+  }
+  if (expectedType === "float") {
+    const parsed = Number.parseFloat(value);
+    if (!Number.isNaN(parsed)) {
+      return parsed;
+    }
+    return value;
+  }
+  if (expectedType === "bool") {
+    const lower = value.toLowerCase();
+    if (lower === "true") {
+      return true;
+    }
+    if (lower === "false") {
+      return false;
+    }
+    return value;
+  }
+  if (expectedType.endsWith("[]")) {
+    try {
+      const parsed = JSON.parse(value);
+      if (Array.isArray(parsed)) {
+        return parsed;
+      }
+    } catch {
+    }
+    return value;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function coerceInputs(inputs, expectedTypes) {
+  const coerced = {};
+  for (const [key, value] of Object.entries(inputs)) {
+    if (typeof value === "string") {
+      const expectedType = expectedTypes.get(key);
+      if (expectedType) {
+        coerced[key] = coerceToType(value, expectedType);
+      } else {
+        coerced[key] = value;
+      }
+    } else {
+      coerced[key] = value;
+    }
+  }
+  return coerced;
+}
+function objToDict(obj, depth = 0, maxDepth = 5) {
+  if (depth > maxDepth) {
+    return `<max depth reached: ${typeof obj}>`;
+  }
+  if (obj === null || obj === void 0 || typeof obj === "string" || typeof obj === "number" || typeof obj === "boolean") {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => objToDict(item, depth + 1, maxDepth));
+  }
+  if (typeof obj === "object") {
+    const result = {};
+    if (obj.constructor && obj.constructor.name !== "Object") {
+      result.__type__ = obj.constructor.name;
+    }
+    for (const key of Object.keys(obj)) {
+      if (key.startsWith("_")) {
+        continue;
+      }
+      try {
+        const value = obj[key];
+        if (typeof value === "function") {
+          continue;
+        }
+        result[key] = objToDict(value, depth + 1, maxDepth);
+      } catch (error) {
+        result[key] = `<error: ${error instanceof Error ? error.message : String(error)}>`;
+      }
+    }
+    try {
+      const proto = Object.getPrototypeOf(obj);
+      if (proto && proto !== Object.prototype) {
+        const descriptors = Object.getOwnPropertyDescriptors(proto);
+        for (const [key, descriptor] of Object.entries(descriptors)) {
+          if (key.startsWith("_") || key === "constructor" || key in result) {
+            continue;
+          }
+          if (descriptor.get) {
+            try {
+              const value = obj[key];
+              if (typeof value !== "function") {
+                result[key] = objToDict(value, depth + 1, maxDepth);
+              }
+            } catch {
+            }
+          }
+        }
+      }
+    } catch {
+    }
+    return result;
+  }
+  return String(obj);
+}
+function serializeCollector(collector) {
+  try {
+    return objToDict(collector, 0, 5);
+  } catch (_error) {
+    return null;
+  }
+}
+var ALLOWED_ENV_KEYS = ["OPENAI_API_KEY"];
+function filterEnvVars(envVars) {
+  const filtered = {};
+  for (const key of ALLOWED_ENV_KEYS) {
+    const value = envVars[key];
+    if (value) {
+      filtered[key] = value;
+    }
+  }
+  return filtered;
+}
+async function runFunctionWithBaml(bamlSource, inputs, providers, envVars) {
+  const { BamlRuntime, Collector } = await loadBaml();
+  const functionName = extractFunctionName(bamlSource);
+  if (!functionName) {
+    throw new Error("No function found in BAML source");
+  }
+  const fullSource = withDefaultClients(bamlSource, providers);
+  const filteredEnvVars = filterEnvVars(envVars);
+  const runtime = BamlRuntime.fromFiles(
+    "/tmp/baml_runtime",
+    { "source.baml": fullSource },
+    filteredEnvVars
+  );
+  const ctx = runtime.createContextManager();
+  const collector = new Collector("bitfab-collector");
+  const params = extractFunctionParameters(bamlSource);
+  const expectedTypes = new Map(params.map((p) => [p.name, p.type]));
+  const args = coerceInputs(inputs, expectedTypes);
+  const functionResult = await runtime.callFunction(
+    functionName,
+    args,
+    ctx,
+    null,
+    // TypeBuilder
+    null,
+    // ClientRegistry
+    [collector],
+    // Collectors - capture execution data
+    {},
+    // Tags
+    filteredEnvVars
+  );
+  if (!functionResult.isOk()) {
+    throw new Error("BAML function execution failed");
+  }
+  const rawCollector = serializeCollector(collector);
+  return {
+    result: functionResult.parsed(false),
+    rawCollector
+  };
+}
+
+// src/client.ts
+init_constants();
+init_http();
+
+// src/langgraph.ts
+init_constants();
+init_http();
+var LANGSMITH_HIDDEN_TAG = "langsmith:hidden";
+var LANGGRAPH_METADATA_KEYS = [
+  "langgraph_step",
+  "langgraph_node",
+  "langgraph_triggers",
+  "langgraph_path",
+  "langgraph_checkpoint_ns"
+];
+function nowIso2() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+var MAX_SERIALIZE_DEPTH = 6;
+function safeSerialize2(value) {
+  return safeSerializeInner(value, 0, /* @__PURE__ */ new WeakSet());
+}
+function safeSerializeInner(value, depth, seen) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  const className = value?.constructor?.name ?? typeof value;
+  if (depth > MAX_SERIALIZE_DEPTH) {
+    return `<${className}>`;
+  }
+  if (typeof value === "object") {
+    if (seen.has(value)) {
+      return `<cycle ${className}>`;
+    }
+    seen.add(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => safeSerializeInner(item, depth + 1, seen));
+  }
+  if (typeof value === "object") {
+    if (typeof value.toJSON === "function") {
+      try {
+        return value.toJSON();
+      } catch {
+        return `<${className}>`;
+      }
+    }
+    try {
+      const result = {};
+      for (const [k, v] of Object.entries(value)) {
+        if (!k.startsWith("_")) {
+          result[k] = safeSerializeInner(v, depth + 1, seen);
+        }
+      }
+      return result;
+    } catch {
+      return `<${className}>`;
+    }
+  }
+  try {
+    return String(value);
+  } catch {
+    return `<${className}>`;
+  }
+}
+function convertMessage(message) {
+  if (typeof message !== "object" || message === null) {
+    return { role: "unknown", content: String(message) };
+  }
+  const msg = message;
+  if (typeof msg.toDict === "function") {
+    return msg.toDict();
+  }
+  const typeToRole = {
+    human: "user",
+    ai: "assistant",
+    system: "system",
+    tool: "tool",
+    function: "function"
+  };
+  const result = {};
+  const msgType = msg._getType ? String(msg._getType()) : msg.type;
+  result.role = (msgType ? typeToRole[msgType] : void 0) ?? msg.role ?? "unknown";
+  result.content = msg.content ?? "";
+  if (msg.tool_calls) {
+    result.tool_calls = msg.tool_calls;
+  }
+  if (msg.tool_call_id) {
+    result.tool_call_id = msg.tool_call_id;
+  }
+  if (msg.name) {
+    result.name = msg.name;
+  }
+  return result;
+}
+function extractModelName(serialized, metadata) {
+  if (serialized) {
+    const kwargs = serialized.kwargs;
+    if (kwargs) {
+      const model = kwargs.model_name ?? kwargs.model ?? kwargs.model_id;
+      if (model) {
+        return String(model);
+      }
+    }
+  }
+  if (metadata) {
+    const lsModel = metadata.ls_model_name;
+    if (lsModel) {
+      return String(lsModel);
+    }
+  }
+  return void 0;
+}
+function extractUsage2(output) {
+  const usage = {};
+  const llmOutput = output.llmOutput;
+  const tokenUsage = llmOutput?.tokenUsage ?? llmOutput?.token_usage ?? llmOutput?.usage ?? {};
+  const inputTokens = tokenUsage.promptTokens ?? tokenUsage.prompt_tokens ?? tokenUsage.input_tokens;
+  const outputTokens = tokenUsage.completionTokens ?? tokenUsage.completion_tokens ?? tokenUsage.output_tokens;
+  const totalTokens = tokenUsage.totalTokens ?? tokenUsage.total_tokens;
+  if (inputTokens !== void 0 && inputTokens !== null) {
+    usage.inputTokens = inputTokens;
+  }
+  if (outputTokens !== void 0 && outputTokens !== null) {
+    usage.outputTokens = outputTokens;
+  }
+  if (totalTokens !== void 0 && totalTokens !== null) {
+    usage.totalTokens = totalTokens;
+  }
+  return usage;
+}
+function extractLangGraphMetadata(metadata) {
+  if (!metadata) {
+    return {};
+  }
+  const result = {};
+  for (const key of LANGGRAPH_METADATA_KEYS) {
+    if (key in metadata) {
+      result[key] = metadata[key];
+    }
+  }
+  return result;
+}
+var BitfabLangGraphCallbackHandler = class {
+  constructor(config) {
+    this.name = "BitfabLangGraphCallbackHandler";
+    this.ignoreRetriever = true;
+    this.ignoreRetry = true;
+    this.ignoreCustomEvent = true;
+    this.runToSpan = /* @__PURE__ */ new Map();
+    this.invocations = /* @__PURE__ */ new Map();
+    this.httpClient = new HttpClient({
+      apiKey: config.apiKey,
+      serviceUrl: config.serviceUrl ?? DEFAULT_SERVICE_URL,
+      timeout: config.timeout ?? 1e4
+    });
+    this.traceFunctionKey = config.traceFunctionKey;
+    this.getActiveSpanContext = config.getActiveSpanContext ?? null;
+  }
+  // ── lifecycle helpers ──────────────────────────────────────────
+  startSpan(runId, parentRunId, name, spanType, inputData, metadata, tags) {
+    const parentSpan = parentRunId ? this.runToSpan.get(parentRunId) : void 0;
+    const willHide = tags?.includes(LANGSMITH_HIDDEN_TAG) === true;
+    let invocation;
+    let effectiveParentId;
+    if (parentSpan) {
+      const existing = this.invocations.get(parentSpan.rootRunId);
+      if (existing) {
+        invocation = existing;
+      } else {
+        invocation = {
+          traceId: parentSpan.traceId,
+          activeContext: null,
+          rootRunId: parentSpan.rootRunId
+        };
+        this.invocations.set(invocation.rootRunId, invocation);
+      }
+      if (!willHide) {
+        let resolved = parentSpan;
+        while (resolved?.hidden === true) {
+          resolved = resolved.parentId ? this.runToSpan.get(resolved.parentId) : void 0;
+        }
+        effectiveParentId = resolved ? resolved.spanId : invocation.activeContext?.spanId ?? null;
+      } else {
+        effectiveParentId = parentRunId ?? null;
+      }
+    } else {
+      const activeContext = this.getActiveSpanContext?.() ?? null;
+      invocation = {
+        traceId: activeContext ? activeContext.traceId : crypto.randomUUID(),
+        activeContext,
+        rootRunId: runId
+      };
+      this.invocations.set(runId, invocation);
+      effectiveParentId = activeContext?.spanId ?? null;
+    }
+    const lgMetadata = extractLangGraphMetadata(metadata);
+    const contexts = Object.keys(lgMetadata).length > 0 ? [lgMetadata] : [];
+    const spanInfo = {
+      spanId: runId,
+      traceId: invocation.traceId,
+      rootRunId: invocation.rootRunId,
+      parentId: effectiveParentId,
+      startedAt: nowIso2(),
+      name,
+      type: spanType,
+      input: safeSerialize2(inputData),
+      contexts
+    };
+    if (willHide) {
+      spanInfo.hidden = true;
+    }
+    this.runToSpan.set(runId, spanInfo);
+    return spanInfo;
+  }
+  completeSpan(runId, output, error, extraContexts) {
+    const spanInfo = this.runToSpan.get(runId);
+    if (!spanInfo) {
+      return;
+    }
+    this.runToSpan.delete(runId);
+    spanInfo.endedAt = nowIso2();
+    spanInfo.output = safeSerialize2(output);
+    if (error !== void 0) {
+      spanInfo.error = error;
+    }
+    if (extraContexts && Object.keys(extraContexts).length > 0) {
+      spanInfo.contexts.push(extraContexts);
+    }
+    this.sendSpan(spanInfo);
+    if (runId === spanInfo.rootRunId) {
+      const invocation = this.invocations.get(runId);
+      this.sendTraceCompletion(spanInfo, invocation?.activeContext ?? null);
+      this.invocations.delete(runId);
+    }
+  }
+  sendSpan(spanInfo) {
+    const spanData = {
+      name: spanInfo.name,
+      type: spanInfo.type
+    };
+    if (spanInfo.input !== void 0) {
+      spanData.input = spanInfo.input;
+    }
+    if (spanInfo.output !== void 0) {
+      spanData.output = spanInfo.output;
+    }
+    if (spanInfo.error !== void 0) {
+      spanData.error = spanInfo.error;
+    }
+    if (spanInfo.contexts.length > 0) {
+      spanData.contexts = spanInfo.contexts;
+    }
+    if (spanInfo.hidden) {
+      spanData.hidden = true;
+    }
+    const rawSpan = {
+      id: spanInfo.spanId,
+      trace_id: spanInfo.traceId,
+      started_at: spanInfo.startedAt,
+      ended_at: spanInfo.endedAt ?? nowIso2(),
+      span_data: spanData
+    };
+    if (spanInfo.parentId !== null) {
+      rawSpan.parent_id = spanInfo.parentId;
+    }
+    const payload = {
+      type: "sdk-function",
+      source: "typescript-sdk-langgraph",
+      traceFunctionKey: this.traceFunctionKey,
+      sourceTraceId: spanInfo.traceId,
+      rawSpan
+    };
+    try {
+      this.httpClient.sendExternalSpan(payload);
+    } catch {
+    }
+  }
+  sendTraceCompletion(rootSpan, activeContext) {
+    const completed = activeContext === null;
+    const traceData = {
+      type: "sdk-function",
+      source: "typescript-sdk-langgraph",
+      traceFunctionKey: this.traceFunctionKey,
+      externalTrace: {
+        id: rootSpan.traceId,
+        started_at: rootSpan.startedAt,
+        ended_at: rootSpan.endedAt ?? nowIso2(),
+        workflow_name: this.traceFunctionKey
+      },
+      completed
+    };
+    try {
+      this.httpClient.sendExternalTrace(traceData);
+    } catch {
+    }
+  }
+  // ── chain callbacks (graph nodes) ─────────────────────────────
+  async handleChainStart(chain, inputs, runId, parentRunId, tags, metadata) {
+    try {
+      const idArr = chain.id;
+      const name = chain.name ?? idArr?.[idArr.length - 1] ?? "chain";
+      this.startSpan(
+        runId,
+        parentRunId,
+        String(name),
+        "agent",
+        inputs,
+        metadata,
+        tags
+      );
+    } catch {
+    }
+  }
+  async handleChainEnd(outputs, runId) {
+    try {
+      this.completeSpan(runId, outputs);
+    } catch {
+    }
+  }
+  async handleChainError(error, runId) {
+    try {
+      const errorObj = error;
+      if (errorObj?.constructor?.name === "GraphBubbleUp") {
+        this.completeSpan(runId, void 0, void 0);
+        return;
+      }
+      this.completeSpan(
+        runId,
+        void 0,
+        error instanceof Error ? error.message : String(error)
+      );
+    } catch {
+    }
+  }
+  // ── LLM callbacks ─────────────────────────────────────────────
+  async handleChatModelStart(llm, messages, runId, parentRunId, _extraParams, tags, metadata) {
+    try {
+      const model = extractModelName(llm, metadata);
+      const idArr = llm.id;
+      const name = model ?? idArr?.[idArr.length - 1] ?? "llm";
+      const converted = messages.map((batch) => batch.map(convertMessage));
+      const spanInfo = this.startSpan(
+        runId,
+        parentRunId,
+        String(name),
+        "llm",
+        converted,
+        metadata,
+        tags
+      );
+      spanInfo.model = model;
+    } catch {
+    }
+  }
+  async handleLLMStart(llm, prompts, runId, parentRunId, _extraParams, tags, metadata) {
+    try {
+      const model = extractModelName(llm, metadata);
+      const idArr = llm.id;
+      const name = model ?? idArr?.[idArr.length - 1] ?? "llm";
+      const spanInfo = this.startSpan(
+        runId,
+        parentRunId,
+        String(name),
+        "llm",
+        prompts,
+        metadata,
+        tags
+      );
+      spanInfo.model = model;
+    } catch {
+    }
+  }
+  async handleLLMEnd(output, runId) {
+    try {
+      let llmOutput;
+      const generations = output.generations;
+      if (generations?.length && generations[generations.length - 1]?.length) {
+        const gen = generations[generations.length - 1][generations[generations.length - 1].length - 1];
+        const msg = gen.message;
+        llmOutput = msg ? convertMessage(msg) : gen.text ?? String(gen);
+      }
+      const usage = extractUsage2(output);
+      const spanInfo = this.runToSpan.get(runId);
+      const model = spanInfo?.model;
+      const llmContext = {};
+      if (model) {
+        llmContext.model = model;
+      }
+      Object.assign(llmContext, usage);
+      this.completeSpan(
+        runId,
+        llmOutput,
+        void 0,
+        Object.keys(llmContext).length > 0 ? llmContext : void 0
+      );
+    } catch {
+    }
+  }
+  async handleLLMError(error, runId) {
+    try {
+      this.completeSpan(
+        runId,
+        void 0,
+        error instanceof Error ? error.message : String(error)
+      );
+    } catch {
+    }
+  }
+  async handleLLMNewToken() {
+  }
+  // ── tool callbacks ────────────────────────────────────────────
+  async handleToolStart(tool, input, runId, parentRunId, tags, metadata) {
+    try {
+      const name = tool.name ?? "tool";
+      this.startSpan(
+        runId,
+        parentRunId,
+        String(name),
+        "function",
+        input,
+        metadata,
+        tags
+      );
+    } catch {
+    }
+  }
+  async handleToolEnd(output, runId) {
+    try {
+      this.completeSpan(runId, output);
+    } catch {
+    }
+  }
+  async handleToolError(error, runId) {
+    try {
+      this.completeSpan(
+        runId,
+        void 0,
+        error instanceof Error ? error.message : String(error)
+      );
+    } catch {
+    }
+  }
+  // ── retriever callbacks ───────────────────────────────────────
+  async handleRetrieverStart(retriever, query, runId, parentRunId, tags, metadata) {
+    try {
+      const name = retriever.name ?? "retriever";
+      this.startSpan(
+        runId,
+        parentRunId,
+        String(name),
+        "function",
+        query,
+        metadata,
+        tags
+      );
+    } catch {
+    }
+  }
+  async handleRetrieverEnd(documents, runId) {
+    try {
+      this.completeSpan(runId, documents);
+    } catch {
+    }
+  }
+  async handleRetrieverError(error, runId) {
+    try {
+      this.completeSpan(
+        runId,
+        void 0,
+        error instanceof Error ? error.message : String(error)
+      );
+    } catch {
+    }
+  }
+};
+
+// src/client.ts
+init_replayContext();
+init_serialize();
+
+// src/tracing.ts
+init_constants();
+init_http();
+var BitfabOpenAITracingProcessor = class {
+  /**
+   * Initialize the tracing processor.
+   *
+   * @param config - Configuration options
+   */
+  constructor(config) {
+    this.activeTraces = {};
+    this.activeSpanMappings = {};
+    this.httpClient = new HttpClient({
+      apiKey: config.apiKey,
+      serviceUrl: config.serviceUrl ?? DEFAULT_SERVICE_URL,
+      timeout: config.timeout ?? 1e4
+    });
+    this.getActiveSpanContext = config.getActiveSpanContext ?? null;
+  }
+  /**
+   * Called when a trace is started.
+   * If there's an active withSpan context, the trace ID is remapped to the
+   * outer trace and sent to pre-create the external_traces row on the server.
+   */
+  async onTraceStart(trace) {
+    this.activeTraces[trace.traceId] = trace;
+    const activeContext = this.getActiveSpanContext?.();
+    if (activeContext) {
+      this.activeSpanMappings[trace.traceId] = activeContext;
+    }
+    this.sendTrace(trace, activeContext ? { id: activeContext.traceId } : {});
+  }
+  /**
+   * Called when a trace is ended.
+   * If mapped to a withSpan trace, sends with remapped ID and completed=false
+   * since the parent withSpan handles completion.
+   */
+  async onTraceEnd(trace) {
+    const mapping = this.activeSpanMappings[trace.traceId];
+    this.sendTrace(
+      trace,
+      mapping ? { id: mapping.traceId } : { completed: true }
+    );
+    delete this.activeSpanMappings[trace.traceId];
+    delete this.activeTraces[trace.traceId];
+  }
+  /**
+   * Called when a span is started.
+   */
+  // biome-ignore lint/suspicious/noExplicitAny: OpenAI Agents SDK uses any for span data
+  async onSpanStart(span) {
+    this.sendSpan(span);
+  }
+  /**
+   * Called when a span is ended.
+   *
+   * Send all spans to Bitfab for complete trace capture.
+   */
+  // biome-ignore lint/suspicious/noExplicitAny: OpenAI Agents SDK uses any for span data
+  async onSpanEnd(span) {
+    this.sendSpan(span);
+  }
+  /**
+   * Called when a trace is being flushed.
+   */
+  async forceFlush() {
+  }
+  /**
+   * Called when the trace processor is shutting down.
+   */
+  async shutdown(_timeout) {
+    this.activeTraces = {};
+    this.activeSpanMappings = {};
+  }
+  /**
+   * Send trace to Bitfab API (fire-and-forget).
+   * When traceIdOverride is provided, the trace ID is remapped to link
+   * the OpenAI trace into an outer withSpan trace.
+   */
+  sendTrace(trace, overrides = {}) {
+    try {
+      const { completed, ...traceOverrides } = overrides;
+      const traceData = trace.toJSON();
+      Object.assign(traceData, traceOverrides);
+      this.httpClient.sendExternalTrace({
+        type: "openai",
+        source: "typescript-sdk-openai-tracing",
+        externalTrace: traceData,
+        completed: completed ?? false
+      });
+    } catch {
+    }
+  }
+  /**
+   * Export span to JSON object, collecting any errors.
+   */
+  exportSpan(span) {
+    const errors = [];
+    let serializedSpan;
+    try {
+      const jsonResult = span.toJSON();
+      if (typeof jsonResult !== "object" || jsonResult === null) {
+        errors.push({
+          step: "span.toJSON()",
+          error: `Returned unexpected type: ${typeof jsonResult}`
+        });
+        serializedSpan = {};
+      } else {
+        serializedSpan = jsonResult;
+      }
+    } catch (error) {
+      errors.push({
+        step: "span.toJSON()",
+        error: error instanceof Error ? error.message : String(error)
+      });
+      serializedSpan = {};
+    }
+    if (!serializedSpan.span_data) {
+      serializedSpan.span_data = {};
+    }
+    return [serializedSpan, errors];
+  }
+  /**
+   * Extract and add input/response to serialized span, updating errors list.
+   */
+  extractSpanInputResponse(span, serializedSpan, errors) {
+    const spanData = serializedSpan.span_data;
+    try {
+      spanData.input = span.spanData?._input || [];
+    } catch (error) {
+      errors.push({
+        step: "access_input",
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+    try {
+      spanData.response = span.spanData?._response || null;
+    } catch (error) {
+      errors.push({
+        step: "access_response",
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  /**
+   * If the span's trace is mapped to a withSpan trace, rewrite trace_id and parent_id.
+   */
+  applySpanOverrides(serializedSpan, traceId) {
+    const mapping = this.activeSpanMappings[traceId];
+    if (mapping) {
+      serializedSpan.trace_id = mapping.traceId;
+      if (!serializedSpan.parent_id) {
+        serializedSpan.parent_id = mapping.spanId;
+      }
+    }
+  }
+  /**
+   * Build span payload for the external spans API.
+   */
+  buildSpanPayload(serializedSpan, errors) {
+    const payload = {
+      type: "openai",
+      source: "typescript-sdk-openai-tracing",
+      sourceTraceId: serializedSpan.trace_id ?? "unknown",
+      rawSpan: serializedSpan
+    };
+    if (errors.length > 0) {
+      payload.errors = errors;
+    }
+    return payload;
+  }
+  /**
+   * Send span to Bitfab API (fire-and-forget).
+   * If the span belongs to a trace mapped to a withSpan trace, the trace_id
+   * and parent_id are rewritten to link the span into the withSpan tree.
+   */
+  sendSpan(span) {
+    const errors = [];
+    const [serializedSpan, exportErrors] = this.exportSpan(span);
+    errors.push(...exportErrors);
+    this.extractSpanInputResponse(span, serializedSpan, errors);
+    this.applySpanOverrides(serializedSpan, span.traceId ?? "");
+    const payload = this.buildSpanPayload(serializedSpan, errors);
+    this.httpClient.sendExternalSpan(payload);
+  }
+};
+
+// src/client.ts
+var activeTraceStates = /* @__PURE__ */ new Map();
+var pendingSpanPromises = /* @__PURE__ */ new Map();
+var asyncLocalStorage = null;
+var asyncLocalStorageReady = asyncStorageReady.then(() => {
+  asyncLocalStorage = createAsyncLocalStorage();
+});
+var browserSpanStack = [];
+function getSpanStack() {
+  if (asyncLocalStorage) {
+    return asyncLocalStorage.getStore() ?? [];
+  }
+  return browserSpanStack;
+}
+function runWithSpanStack(stack, fn) {
+  if (asyncLocalStorage) {
+    return asyncLocalStorage.run(stack, fn);
+  }
+  const previousStack = browserSpanStack;
+  browserSpanStack = stack;
+  try {
+    const result = fn();
+    if (result instanceof Promise) {
+      return result.finally(() => {
+        browserSpanStack = previousStack;
+      });
+    }
+    browserSpanStack = previousStack;
+    return result;
+  } catch (error) {
+    browserSpanStack = previousStack;
+    throw error;
+  }
+}
+function isAsyncGenerator(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.next === "function" && typeof candidate.return === "function" && typeof candidate.throw === "function" && typeof candidate[Symbol.asyncIterator] === "function";
+}
+function wrapAsyncGenerator(source, spanStack, sendSpan) {
+  const yielded = [];
+  let returnValue;
+  let finalized = false;
+  const finalize = (errorMsg) => {
+    if (finalized) {
+      return;
+    }
+    finalized = true;
+    void sendSpan({
+      result: { yielded, return: returnValue },
+      ...errorMsg && { error: errorMsg }
+    });
+  };
+  const step = (method, arg) => runWithSpanStack(spanStack, () => {
+    const op = source[method];
+    return op.call(source, arg);
+  });
+  const handle = async (method, arg) => {
+    try {
+      const result = await step(method, arg);
+      if (result.done) {
+        returnValue = result.value;
+        finalize();
+      } else {
+        yielded.push(result.value);
+      }
+      return result;
+    } catch (error) {
+      finalize(error instanceof Error ? error.message : String(error));
+      throw error;
+    }
+  };
+  const wrapped = {
+    next(arg) {
+      return handle("next", arg);
+    },
+    return(value) {
+      return handle("return", value);
+    },
+    throw(err) {
+      return handle("throw", err);
+    },
+    [Symbol.asyncIterator]() {
+      return wrapped;
+    },
+    [Symbol.asyncDispose]() {
+      return handle("return", void 0).then(() => void 0);
+    }
+  };
+  return wrapped;
+}
+var cachedCollectorClass;
+async function loadCollectorClass() {
+  if (cachedCollectorClass !== void 0) {
+    return cachedCollectorClass;
+  }
+  try {
+    const baml = await import("@boundaryml/baml");
+    cachedCollectorClass = baml.Collector;
+    return cachedCollectorClass;
+  } catch {
+    cachedCollectorClass = null;
+    return null;
+  }
+}
+function extractPromptFromCollector(collector) {
+  try {
+    const c = collector;
+    const calls = c?.last?.calls ?? [];
+    const selectedCall = calls.find((call) => call.selected) ?? calls[0];
+    if (!selectedCall?.httpRequest?.body) {
+      return null;
+    }
+    const body = selectedCall.httpRequest.body.json();
+    if (!body || typeof body !== "object") {
+      return null;
+    }
+    const messages = body.messages;
+    if (!Array.isArray(messages) || messages.length === 0) {
+      return null;
+    }
+    const rendered = messages.filter(
+      (msg) => typeof msg === "object" && msg !== null && "role" in msg && typeof msg.role === "string"
+    ).map((msg) => ({
+      role: msg.role,
+      content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content)
+    }));
+    if (rendered.length > 0) {
+      return JSON.stringify(rendered);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function extractContextFromCollector(collector) {
+  try {
+    const c = collector;
+    const calls = c?.last?.calls ?? [];
+    const selectedCall = calls.find((call) => call.selected) ?? calls[0];
+    const usage = c?.usage;
+    const context = {};
+    if (selectedCall?.provider) {
+      context.provider = selectedCall.provider;
+    }
+    const body = selectedCall?.httpRequest?.body?.json();
+    if (body && typeof body === "object" && typeof body.model === "string") {
+      context.model = body.model;
+    } else {
+      const url = selectedCall?.httpRequest?.url;
+      if (url) {
+        const match = url.match(/\/models\/([^/:]+)/);
+        if (match?.[1]) {
+          context.model = match[1];
+        }
+      }
+    }
+    const inputTokens = usage?.inputTokens ?? selectedCall?.usage?.inputTokens ?? null;
+    const outputTokens = usage?.outputTokens ?? selectedCall?.usage?.outputTokens ?? null;
+    if (inputTokens !== null) {
+      context.inputTokens = inputTokens;
+    }
+    if (outputTokens !== null) {
+      context.outputTokens = outputTokens;
+    }
+    const durationMs = c?.last?.timing?.durationMs ?? null;
+    if (durationMs !== null) {
+      context.durationMs = durationMs;
+    }
+    return Object.keys(context).length > 0 ? context : null;
+  } catch {
+    return null;
+  }
+}
+var TRACE_ID_PATTERN = /^[a-zA-Z0-9_\-.:]+$/;
+var TRACE_ID_MAX_LENGTH = 256;
+function validateTraceId(traceId) {
+  if (typeof traceId !== "string" || traceId.length === 0) {
+    throw new BitfabError("traceId is required and must be a non-empty string");
+  }
+  if (traceId.length > TRACE_ID_MAX_LENGTH) {
+    throw new BitfabError(
+      `traceId must be ${TRACE_ID_MAX_LENGTH} characters or fewer`
+    );
+  }
+  if (!TRACE_ID_PATTERN.test(traceId)) {
+    throw new BitfabError(
+      `traceId may only contain letters, digits, "_", "-", ".", ":"`
+    );
+  }
+}
+var noOpSpan = {
+  traceId: "",
+  addContext() {
+  },
+  setPrompt() {
+  }
+};
+var noOpTrace = {
+  setSessionId() {
+  },
+  setMetadata() {
+  },
+  addContext() {
+  }
+};
+function getCurrentSpan() {
+  const stack = getSpanStack();
+  const current = stack[stack.length - 1];
+  if (!current) {
+    return noOpSpan;
+  }
+  return {
+    traceId: current.traceId,
+    addContext(context) {
+      try {
+        if (typeof context !== "object" || context === null) {
+          return;
+        }
+        current.contexts.push(context);
+      } catch {
+      }
+    },
+    setPrompt(prompt) {
+      try {
+        if (typeof prompt !== "string") {
+          return;
+        }
+        current.prompt = prompt;
+      } catch {
+      }
+    }
+  };
+}
+function getCurrentTrace() {
+  const stack = getSpanStack();
+  const current = stack[stack.length - 1];
+  if (!current) {
+    return noOpTrace;
+  }
+  const traceId = current.traceId;
+  const getOrCreateTraceState = () => {
+    let traceState = activeTraceStates.get(traceId);
+    if (!traceState) {
+      traceState = {
+        traceId,
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        contexts: []
+      };
+      activeTraceStates.set(traceId, traceState);
+    }
+    return traceState;
+  };
+  return {
+    setSessionId(sessionId) {
+      try {
+        const traceState = getOrCreateTraceState();
+        traceState.sessionId = sessionId;
+      } catch {
+      }
+    },
+    setMetadata(metadata) {
+      try {
+        if (typeof metadata !== "object" || metadata === null) {
+          return;
+        }
+        const traceState = getOrCreateTraceState();
+        traceState.metadata = { ...traceState.metadata, ...metadata };
+      } catch {
+      }
+    },
+    addContext(context) {
+      try {
+        if (typeof context !== "object" || context === null) {
+          return;
+        }
+        const traceState = getOrCreateTraceState();
+        traceState.contexts.push(context);
+      } catch {
+      }
+    }
+  };
+}
+var Bitfab = class {
+  /**
+   * Initialize the Bitfab client.
+   *
+   * @param config - Configuration options for the client
+   */
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.serviceUrl = config.serviceUrl ?? DEFAULT_SERVICE_URL;
+    this.timeout = config.timeout ?? 12e4;
+    this.envVars = config.envVars ?? {};
+    const enabled = config.enabled ?? true;
+    if (enabled && (!config.apiKey || config.apiKey.trim() === "")) {
+      console.warn(
+        "Bitfab: apiKey is empty \u2014 tracing is disabled. Provide a valid API key to enable tracing."
+      );
+      this.enabled = false;
+    } else {
+      this.enabled = enabled;
+    }
+    this.bamlClient = config.bamlClient ?? null;
+    this.httpClient = new HttpClient({
+      apiKey: this.apiKey,
+      serviceUrl: this.serviceUrl,
+      timeout: this.timeout
+    });
+  }
+  /**
+   * Fetch the function with its current version and BAML prompt from the server.
+   *
+   * @param methodName - The name of the method to fetch
+   * @returns The function with current version, BAML prompt, and provider definitions
+   * @throws {BitfabError} If the function is not found or an error occurs
+   */
+  async fetchFunctionVersion(methodName) {
+    const result = await this.httpClient.lookupFunction(methodName);
+    if (result.id === null) {
+      throw new BitfabError(
+        `Function "${methodName}" not found. Create it at: ${this.serviceUrl}/functions`,
+        "/functions"
+      );
+    }
+    if (!result.prompt) {
+      throw new BitfabError(
+        `Function "${methodName}" has no prompt configured. Add one at: ${this.serviceUrl}/functions/${result.id}`,
+        `/functions/${result.id}`
+      );
+    }
+    return result;
+  }
+  /**
+   * Call a method with the given named arguments via BAML execution.
+   *
+   * @param methodName - The name of the method to call
+   * @param inputs - Named arguments to pass to the method
+   * @returns The result of the BAML function execution
+   * @throws {BitfabError} If service_url is not set, or if an error occurs
+   */
+  async call(methodName, inputs = {}) {
+    try {
+      const functionVersion = await this.fetchFunctionVersion(methodName);
+      const executionResult = await runFunctionWithBaml(
+        functionVersion.prompt,
+        inputs,
+        functionVersion.providers,
+        this.envVars
+      );
+      const resultStr = typeof executionResult.result === "string" ? executionResult.result : JSON.stringify(executionResult.result);
+      this.httpClient.sendInternalTrace(functionVersion.id, {
+        result: resultStr,
+        source: "typescript-sdk",
+        ...Object.keys(inputs).length > 0 && { inputs },
+        ...executionResult.rawCollector != null && {
+          rawCollector: executionResult.rawCollector
+        }
+      });
+      return executionResult.result;
+    } catch (error) {
+      if (error instanceof BitfabError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        throw new BitfabError(error.message);
+      }
+      throw new BitfabError("Unknown error occurred during local execution");
+    }
+  }
+  /**
+   * Get a tracing processor for OpenAI Agents SDK integration.
+   *
+   * This processor automatically captures traces and spans from the OpenAI Agents SDK
+   * and sends them to Bitfab for monitoring and analysis.
+   *
+   * Example usage:
+   * ```typescript
+   * import { addTraceProcessor } from '@openai/agents';
+   *
+   * const client = new Bitfab({ apiKey: 'your-api-key' });
+   * const processor = client.getOpenAiTracingProcessor();
+   * addTraceProcessor(processor);
+   * ```
+   *
+   * @returns A BitfabOpenAITracingProcessor instance configured for this client
+   */
+  getOpenAiTracingProcessor() {
+    return new BitfabOpenAITracingProcessor({
+      apiKey: this.apiKey,
+      serviceUrl: this.serviceUrl,
+      getActiveSpanContext: () => {
+        const stack = getSpanStack();
+        return stack[stack.length - 1] ?? null;
+      }
+    });
+  }
+  /**
+   * Get a LangGraph/LangChain callback handler for tracing.
+   *
+   * The handler captures graph node execution, LLM calls, and tool
+   * invocations as Bitfab spans with proper parent-child hierarchy.
+   *
+   * ```typescript
+   * const handler = client.getLangGraphCallbackHandler("my-agent");
+   * const result = await agent.invoke(
+   *   { messages: [...] },
+   *   { callbacks: [handler] },
+   * );
+   * ```
+   *
+   * @param traceFunctionKey - Groups traces under this key in Bitfab
+   * @returns A BitfabLangGraphCallbackHandler configured for this client
+   */
+  getLangGraphCallbackHandler(traceFunctionKey) {
+    return new BitfabLangGraphCallbackHandler({
+      apiKey: this.apiKey,
+      traceFunctionKey,
+      serviceUrl: this.serviceUrl,
+      getActiveSpanContext: () => {
+        const stack = getSpanStack();
+        return stack[stack.length - 1] ?? null;
+      }
+    });
+  }
+  /**
+   * Get a Claude Agent SDK handler for tracing.
+   *
+   * The handler captures LLM turns, tool invocations, and subagent
+   * execution as Bitfab spans with proper parent-child hierarchy.
+   *
+   * ```typescript
+   * const handler = client.getClaudeAgentHandler("my-agent");
+   * const options = handler.instrumentOptions({
+   *   model: "claude-sonnet-4-5-...",
+   * });
+   * const sdkClient = new ClaudeSDKClient(options);
+   * await sdkClient.connect();
+   * await sdkClient.query("Do something");
+   * for await (const msg of handler.wrapResponse(sdkClient.receiveResponse())) {
+   *   // process messages
+   * }
+   * ```
+   *
+   * @param traceFunctionKey - Groups traces under this key in Bitfab
+   * @returns A BitfabClaudeAgentHandler configured for this client
+   */
+  getClaudeAgentHandler(traceFunctionKey) {
+    return new BitfabClaudeAgentHandler({
+      apiKey: this.apiKey,
+      traceFunctionKey,
+      serviceUrl: this.serviceUrl,
+      getActiveSpanContext: () => {
+        const stack = getSpanStack();
+        return stack[stack.length - 1] ?? null;
+      }
+    });
+  }
+  /**
+   * Wrap a BAML client method to automatically capture prompt and LLM metadata.
+   *
+   * Creates a BAML Collector, calls the method through a tracked client,
+   * then extracts rendered messages and token usage — calling setPrompt()
+   * and addContext() on the current span automatically.
+   *
+   * The BAML client can be provided in the constructor or passed explicitly:
+   *
+   * ```typescript
+   * // Option 1: bamlClient in constructor (use wrapBAML with just the method)
+   * const client = new Bitfab({ apiKey: 'your-api-key', bamlClient: b });
+   * const traced = client.withSpan('classify', { type: 'llm' },
+   *   client.wrapBAML(b.ClassifyText)
+   * );
+   *
+   * // Option 2: pass bamlClient at call site
+   * const client = new Bitfab({ apiKey: 'your-api-key' });
+   * const traced = client.withSpan('classify', { type: 'llm' },
+   *   client.wrapBAML(b, b.ClassifyText)
+   * );
+   * ```
+   *
+   * @param methodOrClient - Either a BAML method (uses constructor bamlClient) or the BAML client instance
+   * @param maybeMethodOrOptions - The BAML method when the first argument is a client, or WrapBAMLOptions when the first argument is the method
+   * @param maybeOptions - WrapBAMLOptions when using the two-argument (client, method) form
+   * @returns An async function with the same signature that instruments the BAML call
+   */
+  wrapBAML(methodOrClient, maybeMethodOrOptions, maybeOptions) {
+    let bamlClient;
+    let method;
+    let options;
+    if (typeof maybeMethodOrOptions === "function") {
+      bamlClient = methodOrClient;
+      method = maybeMethodOrOptions;
+      options = maybeOptions;
+    } else {
+      bamlClient = this.bamlClient;
+      method = methodOrClient;
+      options = maybeMethodOrOptions;
+      if (!bamlClient) {
+        throw new BitfabError(
+          "bamlClient is required for wrapBAML. Pass it in the constructor or as the first argument."
+        );
+      }
+    }
+    const methodName = method.name;
+    if (!methodName) {
+      throw new BitfabError(
+        "wrapBAML requires a named function (e.g., b.ClassifyText)."
+      );
+    }
+    loadCollectorClass();
+    const wrappedFn = async (...args) => {
+      const CollectorClass = await loadCollectorClass();
+      if (!CollectorClass) {
+        wrappedFn.collector = null;
+        return await bamlClient[methodName](...args);
+      }
+      const collector = new CollectorClass("bitfab-baml-tracing");
+      const trackedClient = bamlClient.withOptions({ collector });
+      const trackedMethod = trackedClient[methodName];
+      const result = await trackedMethod.bind(
+        trackedClient
+      )(...args);
+      wrappedFn.collector = collector;
+      try {
+        const prompt = extractPromptFromCollector(collector);
+        if (prompt) {
+          getCurrentSpan().setPrompt(prompt);
+        }
+        const metadata = extractContextFromCollector(collector);
+        if (metadata) {
+          getCurrentSpan().addContext(metadata);
+        }
+      } catch {
+      }
+      try {
+        options?.onCollector?.(collector);
+      } catch {
+      }
+      return result;
+    };
+    wrappedFn.collector = null;
+    return wrappedFn;
+  }
+  /**
+   * Wrap a function to automatically create a span for its inputs and outputs.
+   *
+   * The wrapped function behaves identically to the original, but sends
+   * span data to Bitfab in the background after each call.
+   *
+   * Example usage:
+   * ```typescript
+   * const client = new Bitfab({ apiKey: 'your-api-key' });
+   *
+   * async function processOrder(orderId: string, items: string[]): Promise<{ total: number }> {
+   *   // ... process order
+   *   return { total: 100 };
+   * }
+   *
+   * // Basic usage (defaults to "custom" span type)
+   * const tracedProcessOrder = client.withSpan('order-processing', processOrder);
+   *
+   * // With explicit span type
+   * const tracedProcessOrder = client.withSpan('order-processing', { type: 'function' }, processOrder);
+   *
+   * // Call the wrapped function normally
+   * const result = await tracedProcessOrder('order-123', ['item-1', 'item-2']);
+   * // Span is automatically sent to Bitfab
+   * ```
+   *
+   * @param traceFunctionKey - A string identifier for grouping spans (e.g., 'order-processing', 'user-auth')
+   * @param optionsOrFn - Either SpanOptions or the function to wrap
+   * @param maybeFn - The function to wrap if options were provided
+   * @returns A wrapped function with the same signature that creates spans for inputs and outputs
+   */
+  withSpan(traceFunctionKey, optionsOrFn, maybeFn) {
+    if (!this.enabled) {
+      const fn2 = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
+      return fn2;
+    }
+    const options = typeof optionsOrFn === "function" ? {} : optionsOrFn;
+    const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
+    const self = this;
+    const fnIsAsyncFunction = fn.constructor.name === "AsyncFunction";
+    const fnReturnsPromise = fnIsAsyncFunction || (() => {
+      try {
+        const src = fn.toString();
+        return /\b(?:Promise|await)\b/.test(src);
+      } catch {
+        return false;
+      }
+    })();
+    const wrappedFn = function(...args) {
+      if (!asyncLocalStorage && !isAsyncStorageInitDone()) {
+        return asyncLocalStorageReady.then(
+          () => wrappedFn.apply(this, args)
+        );
+      }
+      const currentStack = getSpanStack();
+      const parentContext = currentStack[currentStack.length - 1];
+      const traceId = parentContext?.traceId ?? crypto.randomUUID();
+      const spanId = crypto.randomUUID();
+      const parentSpanId = parentContext?.spanId ?? null;
+      const isRootSpan = parentSpanId === null;
+      const newContext = { traceId, spanId, contexts: [] };
+      const newStack = [...currentStack, newContext];
+      const inputs = args;
+      const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+      if (isRootSpan && !activeTraceStates.has(traceId)) {
+        const replayCtxAtRoot = getReplayContext();
+        activeTraceStates.set(traceId, {
+          traceId,
+          startedAt,
+          contexts: [],
+          ...replayCtxAtRoot?.testRunId && {
+            testRunId: replayCtxAtRoot.testRunId
+          },
+          ...replayCtxAtRoot?.inputSourceTraceId && {
+            inputSourceTraceId: replayCtxAtRoot.inputSourceTraceId
+          }
+        });
+        pendingSpanPromises.set(traceId, []);
+      }
+      const functionName = fn.name !== "" ? fn.name : void 0;
+      const baseSpanParams = {
+        traceFunctionKey,
+        functionName,
+        spanName: options.name ?? functionName ?? traceFunctionKey,
+        traceId,
+        spanId,
+        parentSpanId,
+        inputs,
+        startedAt,
+        spanType: options.type ?? "custom"
+      };
+      const sendSpan = async (params) => {
+        try {
+          const endedAt = (/* @__PURE__ */ new Date()).toISOString();
+          const replayCtx = getReplayContext();
+          const spanPromise = self.sendWrapperSpan({
+            ...baseSpanParams,
+            ...params,
+            contexts: newContext.contexts,
+            prompt: newContext.prompt,
+            endedAt,
+            ...replayCtx?.testRunId && { testRunId: replayCtx.testRunId },
+            ...replayCtx?.inputSourceSpanId && {
+              inputSourceSpanId: replayCtx.inputSourceSpanId
+            }
+          });
+          if (isRootSpan) {
+            const pending = pendingSpanPromises.get(traceId) ?? [];
+            pending.push(spanPromise);
+            await Promise.race([
+              Promise.allSettled(pending),
+              new Promise((resolve) => setTimeout(resolve, 5e3))
+            ]);
+            pendingSpanPromises.delete(traceId);
+            const traceState = activeTraceStates.get(traceId);
+            self.sendTraceCompletion({
+              traceFunctionKey,
+              traceId,
+              startedAt: traceState?.startedAt ?? startedAt,
+              endedAt,
+              sessionId: traceState?.sessionId,
+              metadata: traceState?.metadata,
+              contexts: traceState?.contexts ?? [],
+              testRunId: traceState?.testRunId,
+              inputSourceTraceId: traceState?.inputSourceTraceId
+            });
+            activeTraceStates.delete(traceId);
+          } else {
+            const pending = pendingSpanPromises.get(traceId);
+            if (pending) {
+              pending.push(spanPromise);
+            } else {
+              pendingSpanPromises.set(traceId, [spanPromise]);
+            }
+          }
+        } catch {
+        }
+      };
+      const replayCtxForMock = getReplayContext();
+      if (replayCtxForMock?.mockTree && !isRootSpan) {
+        const counters = replayCtxForMock.callCounters;
+        const counterKey = `${traceFunctionKey}:${baseSpanParams.spanName}`;
+        const callIndex = counters.get(counterKey) ?? 0;
+        counters.set(counterKey, callIndex + 1);
+        const shouldMock = replayCtxForMock.mockStrategy === "all" || replayCtxForMock.mockStrategy === "marked" && options.mockOnReplay === true;
+        if (shouldMock) {
+          const mockKey = `${counterKey}:${callIndex}`;
+          const mockSpan = replayCtxForMock.mockTree.spans.get(mockKey);
+          if (mockSpan) {
+            let output = mockSpan.output;
+            if (mockSpan.outputMeta !== void 0 && mockSpan.outputMeta !== null) {
+              output = deserializeValue({
+                json: mockSpan.output,
+                meta: mockSpan.outputMeta
+              });
+            }
+            void sendSpan({ result: output });
+            if (fnReturnsPromise) {
+              return Promise.resolve(output);
+            }
+            return output;
+          }
+        }
+      }
+      const executeWithContext = () => {
+        const result = fn(...args);
+        if (result instanceof Promise) {
+          return result.then((resolvedResult) => {
+            void sendSpan({ result: resolvedResult });
+            return resolvedResult;
+          }).catch((error) => {
+            void sendSpan({
+              result: void 0,
+              error: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+          });
+        }
+        if (isAsyncGenerator(result)) {
+          return wrapAsyncGenerator(result, newStack, sendSpan);
+        }
+        void sendSpan({ result });
+        return result;
+      };
+      return runWithSpanStack(newStack, executeWithContext);
+    };
+    return wrappedFn;
+  }
+  /**
+   * Get a detached handle to a previously-created trace, looked up by the
+   * caller-supplied id (the same id passed at trace creation).
+   *
+   * The returned handle is not tied to AsyncLocalStorage — each method sends
+   * to the server immediately. Useful for adding context to a trace from a
+   * different process or thread than the one that created it.
+   *
+   * Throws synchronously if `traceId` is malformed (empty, too long, or
+   * contains characters outside `[a-zA-Z0-9_\-.:]`). Server returns 404 if
+   * no trace exists with that id in the org; the failure surfaces as a
+   * logged warning (fire-and-forget) or via the awaited promise.
+   *
+   * Example:
+   * ```typescript
+   * const trace = client.getTrace("order_abc_123");
+   * await trace.addContext({ refund_status: "approved" });
+   * await trace.setMetadata({ region: "us-west" });
+   * ```
+   */
+  getTrace(traceId) {
+    validateTraceId(traceId);
+    return {
+      traceId,
+      addContext: (context) => {
+        if (!this.enabled) {
+          return Promise.resolve();
+        }
+        if (typeof context !== "object" || context === null) {
+          return Promise.resolve();
+        }
+        return this.httpClient.patchTrace(traceId, {
+          appendContexts: [context]
+        });
+      },
+      setMetadata: (metadata) => {
+        if (!this.enabled) {
+          return Promise.resolve();
+        }
+        if (typeof metadata !== "object" || metadata === null) {
+          return Promise.resolve();
+        }
+        return this.httpClient.patchTrace(traceId, { mergeMetadata: metadata });
+      },
+      setSessionId: (sessionId) => {
+        if (!this.enabled) {
+          return Promise.resolve();
+        }
+        if (typeof sessionId !== "string" || sessionId.length === 0) {
+          return Promise.resolve();
+        }
+        return this.httpClient.patchTrace(traceId, { setSessionId: sessionId });
+      }
+    };
+  }
+  /**
+   * Get a function wrapper for a specific trace function key.
+   *
+   * This provides a fluent API alternative to calling withSpan directly,
+   * allowing you to bind the traceFunctionKey once and wrap multiple functions.
+   *
+   * Example usage:
+   * ```typescript
+   * const client = new Bitfab({ apiKey: 'your-api-key' });
+   *
+   * const orderFunc = client.getFunction('order-processing');
+   * const tracedProcessOrder = orderFunc.withSpan(processOrder);
+   * const tracedValidateOrder = orderFunc.withSpan(validateOrder);
+   * ```
+   *
+   * @param traceFunctionKey - A string identifier for grouping spans
+   * @returns A BitfabFunction instance for wrapping functions
+   */
+  getFunction(traceFunctionKey) {
+    return new BitfabFunction(this, traceFunctionKey);
+  }
+  /**
+   * Send trace completion when a root span ends.
+   * Internal method to record trace completion with end time.
+   * Fire-and-forget - sends to externalTraces endpoint via httpClient.
+   */
+  sendTraceCompletion(params) {
+    const rawTrace = {
+      id: params.traceId,
+      started_at: params.startedAt,
+      ended_at: params.endedAt,
+      workflow_name: params.traceFunctionKey
+    };
+    if (params.metadata && Object.keys(params.metadata).length > 0) {
+      rawTrace.metadata = params.metadata;
+    }
+    if (params.contexts && params.contexts.length > 0) {
+      rawTrace.contexts = params.contexts;
+    }
+    if (params.inputSourceTraceId) {
+      rawTrace.input_source_trace_id = params.inputSourceTraceId;
+    }
+    this.httpClient.sendExternalTrace({
+      type: "sdk-function",
+      source: "typescript-sdk-function",
+      traceFunctionKey: params.traceFunctionKey,
+      externalTrace: rawTrace,
+      completed: true,
+      ...params.sessionId && { sessionId: params.sessionId },
+      ...params.testRunId && { testRunId: params.testRunId }
+    });
+  }
+  /**
+   * Send a wrapper span from function execution.
+   * Internal method to record spans when using withSpan.
+   * Fire-and-forget - sends to externalSpans endpoint via httpClient.
+   */
+  sendWrapperSpan(params) {
+    const serializedInputs = serializeValue(params.inputs);
+    const serializedResult = serializeValue(params.result);
+    const externalSpan = {
+      id: params.spanId,
+      trace_id: params.traceId,
+      started_at: params.startedAt,
+      ended_at: params.endedAt,
+      span_data: {
+        name: params.spanName,
+        type: params.spanType,
+        input: serializedInputs.json,
+        output: serializedResult.json,
+        // Include superjson meta for type preservation
+        ...serializedInputs.meta !== void 0 && {
+          input_meta: serializedInputs.meta
+        },
+        ...serializedResult.meta !== void 0 && {
+          output_meta: serializedResult.meta
+        },
+        ...params.functionName !== void 0 && {
+          function_name: params.functionName
+        },
+        ...params.error !== void 0 && { error: params.error },
+        ...params.contexts && params.contexts.length > 0 && {
+          contexts: params.contexts
+        },
+        ...params.prompt !== void 0 && { prompt: params.prompt }
+      }
+    };
+    if (params.parentSpanId) {
+      externalSpan.parent_id = params.parentSpanId;
+    }
+    if (params.inputSourceSpanId) {
+      externalSpan.input_source_span_id = params.inputSourceSpanId;
+    }
+    return this.httpClient.sendExternalSpan({
+      type: "sdk-function",
+      source: "typescript-sdk-function",
+      sourceTraceId: params.traceId,
+      traceFunctionKey: params.traceFunctionKey,
+      rawSpan: externalSpan,
+      ...params.testRunId && { testRunId: params.testRunId }
+    });
+  }
+  /**
+   * Replay historical traces through a function and create a test run.
+   *
+   * Fetches the last N traces for the given trace function key, re-runs each
+   * through the provided function, and returns comparison data.
+   *
+   * The function must have been wrapped with `withSpan` — replay injects
+   * `testRunId` via async context so new spans are linked to the test run.
+   *
+   * @param traceFunctionKey - The trace function key to replay
+   * @param fn - The function to replay (must be the return value of `withSpan`)
+   * @param options - Optional replay options (limit, traceIds)
+   * @returns ReplayResult with items, testRunId, and testRunUrl
+   */
+  async replay(traceFunctionKey, fn, options) {
+    const { replay: doReplay } = await Promise.resolve().then(() => (init_replay(), replay_exports));
+    return doReplay(
+      this.httpClient,
+      this.serviceUrl,
+      traceFunctionKey,
+      fn,
+      options
+    );
+  }
+};
+var BitfabFunction = class {
+  constructor(client, traceFunctionKey) {
+    this.client = client;
+    this.traceFunctionKey = traceFunctionKey;
+  }
+  /**
+   * Wrap a function to automatically create a span for its inputs and outputs.
+   *
+   * The wrapped function behaves identically to the original, but sends
+   * span data to Bitfab in the background after each call.
+   *
+   * Example usage:
+   * ```typescript
+   * const orderFunc = client.getFunction('order-processing');
+   *
+   * // Basic usage (defaults to "custom" span type)
+   * const tracedProcessOrder = orderFunc.withSpan(processOrder);
+   *
+   * // With explicit span type
+   * const tracedProcessOrder = orderFunc.withSpan({ type: 'function' }, processOrder);
+   * ```
+   *
+   * @param optionsOrFn - Either SpanOptions or the function to wrap
+   * @param maybeFn - The function to wrap if options were provided
+   * @returns A wrapped function with the same signature that creates spans
+   */
+  withSpan(optionsOrFn, maybeFn) {
+    const options = typeof optionsOrFn === "function" ? {} : optionsOrFn;
+    const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
+    return this.client.withSpan(this.traceFunctionKey, options, fn);
+  }
+  /**
+   * Wrap a BAML client method to automatically capture prompt and LLM metadata.
+   * Delegates to the parent client's wrapBAML method.
+   *
+   * @param methodOrClient - Either a BAML method (uses constructor bamlClient) or the BAML client instance
+   * @param maybeMethodOrOptions - The BAML method when the first argument is a client, or WrapBAMLOptions when the first argument is the method
+   * @param maybeOptions - WrapBAMLOptions when using the two-argument (client, method) form
+   * @returns An async function with the same signature that instruments the BAML call
+   */
+  wrapBAML(methodOrClient, maybeMethodOrOptions, maybeOptions) {
+    return this.client.wrapBAML(
+      methodOrClient,
+      maybeMethodOrOptions,
+      maybeOptions
+    );
+  }
+};
+
+// src/index.ts
+init_constants();
+init_http();
+
+// src/node.ts
+init_asyncStorage();
+assertAsyncStorageRegistered();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Bitfab,
+  BitfabClaudeAgentHandler,
+  BitfabError,
+  BitfabFunction,
+  BitfabLangGraphCallbackHandler,
+  BitfabOpenAITracingProcessor,
+  DEFAULT_SERVICE_URL,
+  __version__,
+  flushTraces,
+  getCurrentSpan,
+  getCurrentTrace
+});
+//# sourceMappingURL=node.cjs.map