bitfab 0.9.2

package/dist/node.cjs

@@ -0,0 +1,1749 @@
+"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.9.2";
+  }
+});
+
+// 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 POST request to the Bitfab API.
+       *
+       * @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 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: "POST",
+            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 {
+          }
+        });
+      }
+      /**
+       * Start a replay session by fetching historical traces.
+       * Blocking call — creates a test run and returns lightweight item references.
+       */
+      async startReplay(traceFunctionKey, limit, traceIds) {
+        const payload = { traceFunctionKey, limit };
+        if (traceIds) {
+          payload.traceIds = traceIds;
+        }
+        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);
+        }
+      }
+      /**
+       * 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;
+}
+async function processItem(httpClient, serverItem, fn, testRunId) {
+  const span = await httpClient.getExternalSpan(serverItem.externalSpanId);
+  const spanData = span.rawData?.span_data ?? {};
+  const inputs = deserializeInputs(spanData);
+  const originalOutput = deserializeOutput(spanData);
+  let result;
+  let error = null;
+  try {
+    const maybePromise = runWithReplayContext(
+      { testRunId, inputSourceSpanId: span.id },
+      () => 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 };
+}
+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
+  );
+  const maxConcurrency = options?.maxConcurrency ?? 10;
+  const tasks = serverItems.map(
+    (serverItem) => () => processItem(httpClient, serverItem, fn, testRunId)
+  );
+  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,
+  BitfabError: () => BitfabError,
+  BitfabFunction: () => BitfabFunction,
+  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/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();
+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;
+  }
+}
+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 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;
+      }
+    });
+  }
+  /**
+   * 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 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)) {
+        activeTraceStates.set(traceId, {
+          traceId,
+          startedAt,
+          contexts: []
+        });
+        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 ?? []
+            });
+            activeTraceStates.delete(traceId);
+          } else {
+            const pending = pendingSpanPromises.get(traceId);
+            if (pending) {
+              pending.push(spanPromise);
+            } else {
+              pendingSpanPromises.set(traceId, [spanPromise]);
+            }
+          }
+        } catch {
+        }
+      };
+      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;
+          });
+        }
+        void sendSpan({ result });
+        return result;
+      };
+      return runWithSpanStack(newStack, executeWithContext);
+    };
+    return wrappedFn;
+  }
+  /**
+   * 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;
+    }
+    this.httpClient.sendExternalTrace({
+      type: "sdk-function",
+      source: "typescript-sdk-function",
+      traceFunctionKey: params.traceFunctionKey,
+      externalTrace: rawTrace,
+      completed: true,
+      ...params.sessionId && { sessionId: params.sessionId }
+    });
+  }
+  /**
+   * 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,
+  BitfabError,
+  BitfabFunction,
+  BitfabOpenAITracingProcessor,
+  DEFAULT_SERVICE_URL,
+  __version__,
+  flushTraces,
+  getCurrentSpan,
+  getCurrentTrace
+});
+//# sourceMappingURL=node.cjs.map