bitfab 0.9.2

package/dist/chunk-WUJR72QY.js

@@ -0,0 +1,1214 @@
+import {
+  BitfabError,
+  DEFAULT_SERVICE_URL,
+  HttpClient,
+  asyncStorageReady,
+  createAsyncLocalStorage,
+  getReplayContext,
+  isAsyncStorageInitDone,
+  serializeValue
+} from "./chunk-VGALEXKQ.js";
+
+// 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/tracing.ts
+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 import("./replay-DJ2HXTHQ.js");
+    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
+    );
+  }
+};
+
+export {
+  BitfabOpenAITracingProcessor,
+  getCurrentSpan,
+  getCurrentTrace,
+  Bitfab,
+  BitfabFunction
+};
+//# sourceMappingURL=chunk-WUJR72QY.js.map