bitfab 0.54.10 → 0.54.11

package/dist/{http-AVWWAMFV.js → http-AXPT27DO.js}

@@ -6,7 +6,7 @@ import {
   flushTraces,
   parseRetryAfterMs,
   serializePayloadBody
-} from "./chunk-B2O33DBH.js";
+} from "./chunk-FMUJONTQ.js";
 import "./chunk-VCRFFCLY.js";
 export {
   BitfabError,
@@ -17,4 +17,4 @@ export {
   parseRetryAfterMs,
   serializePayloadBody
 };
-//# sourceMappingURL=http-AVWWAMFV.js.map
+//# sourceMappingURL=http-AXPT27DO.js.map

package/dist/{http-DH3O3L5X.js → http-JQN2LHHF.js}

@@ -6,7 +6,7 @@ import {
   flushTraces,
   parseRetryAfterMs,
   serializePayloadBody
-} from "./chunk-XLWQOUOP.js";
+} from "./chunk-RUBVHBIK.js";
 export {
   BitfabError,
   HttpClient,
@@ -16,4 +16,4 @@ export {
   parseRetryAfterMs,
   serializePayloadBody
 };
-//# sourceMappingURL=http-DH3O3L5X.js.map
+//# sourceMappingURL=http-JQN2LHHF.js.map

package/dist/index.cjs

@@ -51,7 +51,7 @@ var __version__, __packageName__;
 var init_version_generated = __esm({
   "src/version.generated.ts"() {
     "use strict";
-    __version__ = "0.54.10";
+    __version__ = "0.54.11";
     __packageName__ = "bitfab";
   }
 });
@@ -77,20 +77,20 @@ var init_traceCompletion = __esm({
         this.closed = /* @__PURE__ */ new Map();
       }
       state(traceId) {
-        let state = this.traces.get(traceId);
-        if (state === void 0) {
-          state = { spanIds: /* @__PURE__ */ new Set(), active: /* @__PURE__ */ new Set() };
-          this.traces.set(traceId, state);
+        let state2 = this.traces.get(traceId);
+        if (state2 === void 0) {
+          state2 = { spanIds: /* @__PURE__ */ new Set(), active: /* @__PURE__ */ new Set() };
+          this.traces.set(traceId, state2);
         }
-        return state;
+        return state2;
       }
       start(traceId, spanId) {
         if (this.closed.has(traceId)) {
           return;
         }
-        const state = this.state(traceId);
-        state.spanIds.add(spanId);
-        state.active.add(spanId);
+        const state2 = this.state(traceId);
+        state2.spanIds.add(spanId);
+        state2.active.add(spanId);
       }
       open(traceId) {
         if (!this.closed.has(traceId)) {
@@ -106,24 +106,24 @@ var init_traceCompletion = __esm({
         }
       }
       end(traceId, spanId) {
-        const state = this.traces.get(traceId);
-        if (state !== void 0) {
-          state.active.delete(spanId);
-          this.drain(traceId, state);
+        const state2 = this.traces.get(traceId);
+        if (state2 !== void 0) {
+          state2.active.delete(spanId);
+          this.drain(traceId, state2);
         }
       }
       abort(traceId, spanId) {
-        const state = this.traces.get(traceId);
-        if (state === void 0) {
+        const state2 = this.traces.get(traceId);
+        if (state2 === void 0) {
           return;
         }
-        state.active.delete(spanId);
-        state.spanIds.delete(spanId);
-        if (state.active.size === 0 && state.spanIds.size === 0 && state.complete === void 0) {
+        state2.active.delete(spanId);
+        state2.spanIds.delete(spanId);
+        if (state2.active.size === 0 && state2.spanIds.size === 0 && state2.complete === void 0) {
           this.traces.delete(traceId);
           return;
         }
-        this.drain(traceId, state);
+        this.drain(traceId, state2);
       }
       close(traceId, complete, dropped = false) {
         const count = this.closed.get(traceId);
@@ -131,29 +131,29 @@ var init_traceCompletion = __esm({
           complete(count);
           return;
         }
-        const state = this.traces.get(traceId);
-        if (state === void 0) {
+        const state2 = this.traces.get(traceId);
+        if (state2 === void 0) {
           return;
         }
-        state.complete = complete;
+        state2.complete = complete;
         if (dropped) {
-          state.active.clear();
+          state2.active.clear();
         }
-        this.drain(traceId, state);
+        this.drain(traceId, state2);
       }
-      drain(traceId, state) {
-        if (state.active.size !== 0 || state.complete === void 0) {
+      drain(traceId, state2) {
+        if (state2.active.size !== 0 || state2.complete === void 0) {
           return;
         }
         this.traces.delete(traceId);
-        this.closed.set(traceId, state.spanIds.size);
+        this.closed.set(traceId, state2.spanIds.size);
         if (this.closed.size > 1024) {
           const oldest = this.closed.keys().next().value;
           if (oldest !== void 0) {
             this.closed.delete(oldest);
           }
         }
-        state.complete(state.spanIds.size);
+        state2.complete(state2.spanIds.size);
       }
     };
   }
@@ -404,8 +404,8 @@ function text(value) {
   const trimmed = value?.trim();
   return trimmed ? trimmed : null;
 }
-function isEmptyGitState(state) {
-  return Object.values(state).every((value) => value === null);
+function isEmptyGitState(state2) {
+  return Object.values(state2).every((value) => value === null);
 }
 async function resolveGitState(cwd) {
   const git = await gitRunner({
@@ -426,14 +426,14 @@ async function resolveGitState(cwd) {
   if (!root) {
     return null;
   }
-  const state = {
+  const state2 = {
     githubEmail: text(email),
     branch: text(branch),
     commitSha: sha(commitSha),
     baseSha: sha(baseSha),
     experimentSha: await resolveWorkingTreeSha(run, root.trim())
   };
-  return isEmptyGitState(state) ? null : state;
+  return isEmptyGitState(state2) ? null : state2;
 }
 async function resolveWorkingTreeSha(run, root) {
   let indexPath;
@@ -6980,6 +6980,83 @@ var BitfabOpenAIAgentHandler = class {
   }
 };
 
+// src/openaiAgentsSpanContext.ts
+var OPENAI_AGENTS_CONTEXT_STORAGE = /* @__PURE__ */ Symbol.for(
+  "openai.agents.core.asyncLocalStorage"
+);
+var MAX_OPENAI_AGENTS_SPAN_CHAIN = 64;
+var spanGlobal = globalThis;
+var state = spanGlobal.__bitfabOpenAiAgentsSpansV1 ?? {
+  bitfabTraceIds: /* @__PURE__ */ new Map(),
+  endedSpanIds: /* @__PURE__ */ new Map()
+};
+spanGlobal.__bitfabOpenAiAgentsSpansV1 = state;
+function mapOpenAiAgentsTrace(agentsTraceId, bitfabTraceId) {
+  state.bitfabTraceIds.set(agentsTraceId, bitfabTraceId);
+}
+function unmapOpenAiAgentsTrace(agentsTraceId) {
+  state.bitfabTraceIds.delete(agentsTraceId);
+  state.endedSpanIds.delete(agentsTraceId);
+}
+function endOpenAiAgentsSpan(agentsTraceId, spanId) {
+  if (!state.bitfabTraceIds.has(agentsTraceId)) {
+    return;
+  }
+  const ended = state.endedSpanIds.get(agentsTraceId) ?? /* @__PURE__ */ new Set();
+  ended.add(spanId);
+  state.endedSpanIds.set(agentsTraceId, ended);
+}
+function isOpenAiAgentsContextStorage(value) {
+  return value !== null && typeof value === "object" && typeof value.getStore === "function";
+}
+function currentOpenAiAgentsSpan() {
+  const storage2 = spanGlobal[OPENAI_AGENTS_CONTEXT_STORAGE];
+  if (!isOpenAiAgentsContextStorage(storage2)) {
+    return void 0;
+  }
+  try {
+    const store = storage2.getStore();
+    return store?.active === true ? store.span ?? void 0 : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function currentOpenAiAgentsSpans() {
+  const spans = [];
+  let span = currentOpenAiAgentsSpan();
+  while (span !== void 0 && spans.length < MAX_OPENAI_AGENTS_SPAN_CHAIN) {
+    spans.push(span);
+    span = span.previousSpan ?? void 0;
+  }
+  return spans;
+}
+function openAiAgentsSpanChain() {
+  if (state.bitfabTraceIds.size === 0) {
+    return [];
+  }
+  return currentOpenAiAgentsSpans().map((span) => span.spanId).filter((spanId) => typeof spanId === "string");
+}
+function openAiAgentsParentSpanId(bitfabTraceId, enclosingSpanIds) {
+  if (state.bitfabTraceIds.size === 0) {
+    return void 0;
+  }
+  for (const span of currentOpenAiAgentsSpans()) {
+    if (typeof span.spanId !== "string" || typeof span.traceId !== "string") {
+      return void 0;
+    }
+    if (state.bitfabTraceIds.get(span.traceId) !== bitfabTraceId) {
+      return void 0;
+    }
+    if (enclosingSpanIds?.includes(span.spanId)) {
+      return void 0;
+    }
+    if (!state.endedSpanIds.get(span.traceId)?.has(span.spanId)) {
+      return span.spanId;
+    }
+  }
+  return void 0;
+}
+
 // src/client.ts
 init_policyRefresh();
 init_randomUuid();
@@ -7703,6 +7780,9 @@ var BitfabOpenAITracingProcessor = class {
     const activeContext = this.getActiveSpanContext?.();
     if (activeContext) {
       this.activeSpanMappings[trace.traceId] = activeContext;
+      if (this.shouldRecord()) {
+        mapOpenAiAgentsTrace(trace.traceId, activeContext.traceId);
+      }
     }
     const canonicalTraceId = activeContext?.traceId ?? this.getCanonicalTraceId(trace.traceId);
     this.canonicalTraceIds[trace.traceId] = canonicalTraceId;
@@ -7740,6 +7820,7 @@ var BitfabOpenAITracingProcessor = class {
     }
     this.endedTraces.delete(traceId);
     delete this.activeSpanMappings[traceId];
+    unmapOpenAiAgentsTrace(traceId);
     delete this.canonicalTraceIds[traceId];
     delete this.activeTraces[traceId];
   }
@@ -7764,6 +7845,9 @@ var BitfabOpenAITracingProcessor = class {
   async onSpanEnd(span) {
     const originalTraceId = span.traceId ?? "";
     const traceId = this.activeSpanMappings[originalTraceId]?.traceId ?? originalTraceId;
+    if (span.spanId !== void 0) {
+      endOpenAiAgentsSpan(originalTraceId, span.spanId);
+    }
     try {
       this.sendSpan(span);
     } finally {
@@ -7784,6 +7868,9 @@ var BitfabOpenAITracingProcessor = class {
    * Called when the trace processor is shutting down.
    */
   async shutdown(timeout) {
+    for (const traceId of Object.keys(this.activeSpanMappings)) {
+      unmapOpenAiAgentsTrace(traceId);
+    }
     this.activeTraces = {};
     this.activeSpanMappings = {};
     this.canonicalTraceIds = {};
@@ -8941,16 +9028,16 @@ var Bitfab = class {
     this.simulationPlan.send(payload, rootTraceFunctionKeyOf(payload), submit);
   }
   refreshAutoTraceCapturePolicy(traceFunctionKey) {
-    const state = this.autoTracePolicyRefreshes.get(traceFunctionKey) ?? new PolicyRefresh();
-    this.autoTracePolicyRefreshes.set(traceFunctionKey, state);
-    state.run(
+    const state2 = this.autoTracePolicyRefreshes.get(traceFunctionKey) ?? new PolicyRefresh();
+    this.autoTracePolicyRefreshes.set(traceFunctionKey, state2);
+    state2.run(
       () => this.httpClient.getAutoTracePolicy(
         traceFunctionKey,
         AUTO_TRACE_PROTOCOL
       ),
       (policy) => {
         if (policy.protocol !== AUTO_TRACE_PROTOCOL) {
-          state.hold(AUTO_TRACE_POLICY_RETRY_MS);
+          state2.hold(AUTO_TRACE_POLICY_RETRY_MS);
           return;
         }
         const functionIds = Array.isArray(policy.functionIds) ? policy.functionIds.filter(
@@ -8961,10 +9048,10 @@ var Bitfab = class {
           traceFunctionKey,
           policy.revision === null ? void 0 : functionIds
         );
-        state.hold(AUTO_TRACE_POLICY_REFRESH_MS);
+        state2.hold(AUTO_TRACE_POLICY_REFRESH_MS);
       },
       () => {
-        state.hold(AUTO_TRACE_POLICY_RETRY_MS);
+        state2.hold(AUTO_TRACE_POLICY_RETRY_MS);
       }
     );
   }
@@ -9575,7 +9662,11 @@ var Bitfab = class {
         const seedCtxForTraceId = parentContext ? null : getSeedContext();
         const traceId = parentContext?.traceId ?? replayCtxForTraceId?.traceId ?? seedCtxForTraceId?.traceId ?? randomUuid();
         const spanId = randomUuid();
-        const parentSpanId = parentContext?.spanId ?? null;
+        const openAiAgentsParent = parentContext !== void 0 && options.instrumentation === "trace" ? openAiAgentsParentSpanId(
+          parentContext.traceId,
+          parentContext.openAiAgentsSpanIds
+        ) : void 0;
+        const parentSpanId = openAiAgentsParent ?? parentContext?.spanId ?? null;
         const isRootSpan = parentSpanId === null;
         if (options.enclosingTrace !== void 0) {
           options.enclosingTrace.link.traceId = traceId;
@@ -9589,11 +9680,13 @@ var Bitfab = class {
           parentContext?.surface,
           traceFunctionKey
         );
+        const openAiAgentsSpanIds = openAiAgentsSpanChain();
         const newContext = {
           traceId,
           spanId,
           contexts: [],
-          ...surface !== void 0 && { surface }
+          ...surface !== void 0 && { surface },
+          ...openAiAgentsSpanIds.length > 0 && { openAiAgentsSpanIds }
         };
         newStack = [...currentStack, newContext];
         const inputs = args;