@bitfab/sdk 0.38.1 → 0.38.2

package/dist/index.d.cts

@@ -523,6 +523,7 @@ declare class HttpClient {
      * Blocks until complete - needed for function execution.
      */
     lookupFunction<T>(name: string): Promise<T>;
+    getAutoTracePolicy<T>(traceFunctionKey: string, protocol: string): Promise<T>;
     getTraceSpan(traceId: string, lookup: SpanLookup): Promise<CapturedSpan | null>;
     private get;
     /**
@@ -2098,6 +2099,27 @@ interface SpanMethodDecoratorContext<TThis, TValue> {
 }
 /** A standard ECMAScript method decorator produced by {@link Bitfab.span}. */
 type SpanMethodDecorator = <TThis, TArgs extends unknown[], TReturn>(originalMethod: (this: TThis, ...args: TArgs) => TReturn, context: SpanMethodDecoratorContext<TThis, (this: TThis, ...args: TArgs) => TReturn>) => (this: TThis, ...args: TArgs) => TReturn;
+/** Options for experimental automatic subtree tracing. */
+interface TraceOptions {
+    /** Root span name. Defaults to the decorated or wrapped function name. */
+    name?: string;
+    /** Root span type. Descendants are always `function` spans. */
+    type?: SpanType;
+    /** Maximum number of recorded descendant levels. Defaults to 30. */
+    maxDepth?: number;
+    /** Maximum descendant spans recorded per root invocation. Defaults to 500. */
+    maxSpans?: number;
+    /** Qualified or simple function names to leave out of the subtree. */
+    exclude?: readonly string[] | ReadonlySet<string>;
+    /** Record rest-argument wrapper functions. Defaults to false. */
+    includeWrappers?: boolean;
+}
+type StandardTraceMethodDecorator = <This, TArgs extends unknown[], TReturn>(method: (this: This, ...args: TArgs) => TReturn, context: {
+    kind: "method";
+    name: string | symbol;
+}) => (this: This, ...args: TArgs) => TReturn;
+type LegacyTraceMethodDecorator = <This, TArgs extends unknown[], TReturn>(target: object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<(this: This, ...args: TArgs) => TReturn>) => void;
+type TraceMethodDecorator = StandardTraceMethodDecorator & LegacyTraceMethodDecorator;
 
 /**
  * Client for making provider-based API calls via BAML.
@@ -2117,6 +2139,7 @@ declare class Bitfab {
     private readonly httpClient;
     private readonly bamlClient;
     private readonly dbSnapshot;
+    private readonly autoTracePolicyRefreshes;
     /**
      * Mock overrides registered via {@link Bitfab.registerMockOverride}, applied
      * to every `replay` on this client (after any per-call `mockOverride`). In
@@ -2129,6 +2152,37 @@ declare class Bitfab {
      * @param config - Configuration options for the client
      */
     constructor(config: BitfabConfig);
+    /**
+     * Decorate a class method as an automatically expanded trace root.
+     *
+     * Build instrumentation turns repository functions called beneath this
+     * method into nested spans. Every generated span preserves structure; only
+     * function IDs selected by the capture policy include inputs and output.
+     * Without a compatible build transform, this still records the decorated
+     * method as a normal rich root span but cannot discover child calls.
+     *
+     * @param traceFunctionKey - Groups traces and their capture policy.
+     * @param options - Root presentation, subtree bounds, and exclusions.
+     * @experimental Automatic child-call instrumentation is experimental.
+     */
+    trace(traceFunctionKey: string, options?: TraceOptions): TraceMethodDecorator;
+    /**
+     * Wrap a function as an automatically expanded trace root.
+     *
+     * This is the function-oriented equivalent of {@link Bitfab.trace}. Build
+     * instrumentation turns repository functions called beneath the wrapped
+     * function into nested spans. Without a compatible transform, this still
+     * records one normal rich root span and runs the function unchanged.
+     *
+     * @param traceFunctionKey - Groups traces and their capture policy.
+     * @param optionsOrFn - Options or the workflow entrypoint to wrap.
+     * @param maybeFn - Workflow entrypoint when options are provided.
+     * @experimental Automatic child-call instrumentation is experimental.
+     */
+    withTrace<This, TArgs extends unknown[], TReturn>(traceFunctionKey: string, fn: (this: This, ...args: TArgs) => TReturn): (this: This, ...args: TArgs) => TReturn;
+    withTrace<This, TArgs extends unknown[], TReturn>(traceFunctionKey: string, options: TraceOptions, fn: (this: This, ...args: TArgs) => TReturn): (this: This, ...args: TArgs) => TReturn;
+    private createAutoTraceRoot;
+    private refreshAutoTraceCapturePolicy;
     /**
      * Flush and permanently close this client's tracing resources: its pending
      * requests and the single span-transport worker shared by its decorators and
@@ -2663,7 +2717,7 @@ declare class BitfabFunction {
 /**
  * SDK version from package.json (injected at build time)
  */
-declare const __version__ = "0.38.1";
+declare const __version__ = "0.38.2";
 
 /**
  * Constants for the Bitfab SDK.

package/dist/index.d.ts

@@ -523,6 +523,7 @@ declare class HttpClient {
      * Blocks until complete - needed for function execution.
      */
     lookupFunction<T>(name: string): Promise<T>;
+    getAutoTracePolicy<T>(traceFunctionKey: string, protocol: string): Promise<T>;
     getTraceSpan(traceId: string, lookup: SpanLookup): Promise<CapturedSpan | null>;
     private get;
     /**
@@ -2098,6 +2099,27 @@ interface SpanMethodDecoratorContext<TThis, TValue> {
 }
 /** A standard ECMAScript method decorator produced by {@link Bitfab.span}. */
 type SpanMethodDecorator = <TThis, TArgs extends unknown[], TReturn>(originalMethod: (this: TThis, ...args: TArgs) => TReturn, context: SpanMethodDecoratorContext<TThis, (this: TThis, ...args: TArgs) => TReturn>) => (this: TThis, ...args: TArgs) => TReturn;
+/** Options for experimental automatic subtree tracing. */
+interface TraceOptions {
+    /** Root span name. Defaults to the decorated or wrapped function name. */
+    name?: string;
+    /** Root span type. Descendants are always `function` spans. */
+    type?: SpanType;
+    /** Maximum number of recorded descendant levels. Defaults to 30. */
+    maxDepth?: number;
+    /** Maximum descendant spans recorded per root invocation. Defaults to 500. */
+    maxSpans?: number;
+    /** Qualified or simple function names to leave out of the subtree. */
+    exclude?: readonly string[] | ReadonlySet<string>;
+    /** Record rest-argument wrapper functions. Defaults to false. */
+    includeWrappers?: boolean;
+}
+type StandardTraceMethodDecorator = <This, TArgs extends unknown[], TReturn>(method: (this: This, ...args: TArgs) => TReturn, context: {
+    kind: "method";
+    name: string | symbol;
+}) => (this: This, ...args: TArgs) => TReturn;
+type LegacyTraceMethodDecorator = <This, TArgs extends unknown[], TReturn>(target: object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<(this: This, ...args: TArgs) => TReturn>) => void;
+type TraceMethodDecorator = StandardTraceMethodDecorator & LegacyTraceMethodDecorator;
 
 /**
  * Client for making provider-based API calls via BAML.
@@ -2117,6 +2139,7 @@ declare class Bitfab {
     private readonly httpClient;
     private readonly bamlClient;
     private readonly dbSnapshot;
+    private readonly autoTracePolicyRefreshes;
     /**
      * Mock overrides registered via {@link Bitfab.registerMockOverride}, applied
      * to every `replay` on this client (after any per-call `mockOverride`). In
@@ -2129,6 +2152,37 @@ declare class Bitfab {
      * @param config - Configuration options for the client
      */
     constructor(config: BitfabConfig);
+    /**
+     * Decorate a class method as an automatically expanded trace root.
+     *
+     * Build instrumentation turns repository functions called beneath this
+     * method into nested spans. Every generated span preserves structure; only
+     * function IDs selected by the capture policy include inputs and output.
+     * Without a compatible build transform, this still records the decorated
+     * method as a normal rich root span but cannot discover child calls.
+     *
+     * @param traceFunctionKey - Groups traces and their capture policy.
+     * @param options - Root presentation, subtree bounds, and exclusions.
+     * @experimental Automatic child-call instrumentation is experimental.
+     */
+    trace(traceFunctionKey: string, options?: TraceOptions): TraceMethodDecorator;
+    /**
+     * Wrap a function as an automatically expanded trace root.
+     *
+     * This is the function-oriented equivalent of {@link Bitfab.trace}. Build
+     * instrumentation turns repository functions called beneath the wrapped
+     * function into nested spans. Without a compatible transform, this still
+     * records one normal rich root span and runs the function unchanged.
+     *
+     * @param traceFunctionKey - Groups traces and their capture policy.
+     * @param optionsOrFn - Options or the workflow entrypoint to wrap.
+     * @param maybeFn - Workflow entrypoint when options are provided.
+     * @experimental Automatic child-call instrumentation is experimental.
+     */
+    withTrace<This, TArgs extends unknown[], TReturn>(traceFunctionKey: string, fn: (this: This, ...args: TArgs) => TReturn): (this: This, ...args: TArgs) => TReturn;
+    withTrace<This, TArgs extends unknown[], TReturn>(traceFunctionKey: string, options: TraceOptions, fn: (this: This, ...args: TArgs) => TReturn): (this: This, ...args: TArgs) => TReturn;
+    private createAutoTraceRoot;
+    private refreshAutoTraceCapturePolicy;
     /**
      * Flush and permanently close this client's tracing resources: its pending
      * requests and the single span-transport worker shared by its decorators and
@@ -2663,7 +2717,7 @@ declare class BitfabFunction {
 /**
  * SDK version from package.json (injected at build time)
  */
-declare const __version__ = "0.38.1";
+declare const __version__ = "0.38.2";
 
 /**
  * Constants for the Bitfab SDK.

package/dist/index.js

@@ -11,7 +11,8 @@ import {
   getCurrentReplayBranch,
   getCurrentSpan,
   getCurrentTrace
-} from "./chunk-WD4AO3BK.js";
+} from "./chunk-CWXCVY75.js";
+import "./chunk-GFBQ2AMO.js";
 import {
   BITFAB_PROGRESS_PREFIX,
   BitfabError,
@@ -23,7 +24,8 @@ import {
   flushTraces,
   reportReplayProgress,
   serializeReplayResult
-} from "./chunk-MGA7ROIK.js";
+} from "./chunk-SU7EAKOV.js";
+import "./chunk-H6LZRFMN.js";
 export {
   BITFAB_PROGRESS_PREFIX,
   Bitfab,

package/dist/node.cjs

@@ -88,7 +88,7 @@ var __version__, __packageName__;
 var init_version_generated = __esm({
   "src/version.generated.ts"() {
     "use strict";
-    __version__ = "0.38.1";
+    __version__ = "0.38.2";
     __packageName__ = "@bitfab/sdk";
   }
 });
@@ -819,7 +819,7 @@ var init_otel = __esm({
     EXPORT_CONCURRENCY_ENV = "BITFAB_OTEL_EXPORT_CONCURRENCY";
     MAX_QUEUE_SIZE = 8192;
     DIRECT_MAX_EXPORT_BATCH_SIZE = 512;
-    DIRECT_MAX_REQUEST_BATCH_SIZE = 8;
+    DIRECT_MAX_REQUEST_BATCH_SIZE = 128;
     DEFAULT_EXPORT_CONCURRENCY = 32;
     MAX_EXPORT_CONCURRENCY = 64;
     SCHEDULE_DELAY_MILLIS = 5e3;
@@ -1711,6 +1711,12 @@ var init_http = __esm({
       async lookupFunction(name) {
         return this.request("/api/sdk/functions/lookup", { name });
       }
+      async getAutoTracePolicy(traceFunctionKey, protocol) {
+        return this.request("/api/sdk/auto-trace/policy", {
+          traceFunctionKey,
+          protocol
+        });
+      }
       async getTraceSpan(traceId, lookup) {
         const searchParams = new URLSearchParams();
         if (lookup.id !== void 0) {
@@ -3763,6 +3769,80 @@ var BitfabClaudeAgentHandler = class {
 // src/client.ts
 init_asyncStorage();
 
+// src/autoTrace.ts
+init_asyncStorage();
+var autoTraceGlobal = globalThis;
+var autoTraceState = autoTraceGlobal.__bitfabAutoTraceStateV3 ?? {
+  storage: null,
+  browserScope: void 0,
+  capturePolicies: /* @__PURE__ */ new WeakMap(),
+  activeRoots: 0
+};
+autoTraceGlobal.__bitfabAutoTraceStateV3 = autoTraceState;
+function initializeAutoTraceStorage() {
+  autoTraceState.storage ?? (autoTraceState.storage = createAsyncLocalStorage());
+}
+function runWithAutoTraceContext(context, fn, depth = 0) {
+  initializeAutoTraceStorage();
+  const scope = { context, depth };
+  if (autoTraceState.storage) {
+    return autoTraceState.storage.run(scope, fn);
+  }
+  const previous = autoTraceState.browserScope;
+  autoTraceState.browserScope = scope;
+  try {
+    return fn();
+  } finally {
+    autoTraceState.browserScope = previous;
+  }
+}
+function runWithAutoTraceRootContext(context, fn) {
+  autoTraceState.activeRoots += 1;
+  let result;
+  try {
+    result = runWithAutoTraceContext(context, fn);
+  } catch (error) {
+    autoTraceState.activeRoots -= 1;
+    throw error;
+  }
+  if (isAutoTraceAsyncGenerator(result)) {
+    autoTraceState.activeRoots -= 1;
+    return wrapAutoTraceAsyncGenerator(context, result);
+  }
+  if (result instanceof Promise) {
+    return result.finally(() => {
+      autoTraceState.activeRoots -= 1;
+    });
+  }
+  autoTraceState.activeRoots -= 1;
+  return result;
+}
+function isAutoTraceAsyncGenerator(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.next === "function" && typeof candidate.return === "function" && typeof candidate.throw === "function" && typeof candidate[Symbol.asyncIterator] === "function";
+}
+function wrapAutoTraceAsyncGenerator(context, source) {
+  const step = (method, value) => runWithAutoTraceRootContext(context, () => source[method](value));
+  const wrapped = {
+    next: (value) => step("next", value),
+    return: (value) => step("return", value),
+    throw: (error) => step("throw", error),
+    [Symbol.asyncIterator]: () => wrapped
+  };
+  return wrapped;
+}
+function __setBitfabAutoTraceCapturePolicy(client, traceFunctionKey, functionIds) {
+  const policies = autoTraceState.capturePolicies.get(client) ?? /* @__PURE__ */ new Map();
+  policies.set(traceFunctionKey, new Set(functionIds));
+  autoTraceState.capturePolicies.set(client, policies);
+}
+function getAutoTraceCapturePolicy(client, traceFunctionKey) {
+  return autoTraceState.capturePolicies.get(client)?.get(traceFunctionKey) ?? /* @__PURE__ */ new Set();
+}
+
 // src/optionalPeer.ts
 function importOptionalPeer(specifierParts) {
   const specifier = specifierParts.join("/");
@@ -5504,6 +5584,14 @@ function readEnv2(name) {
   }
   return void 0;
 }
+var DEFAULT_AUTO_TRACE_MAX_DEPTH = 30;
+var DEFAULT_AUTO_TRACE_MAX_SPANS = 500;
+var AUTO_TRACE_PROTOCOL = "ts-auto-v1";
+var AUTO_TRACE_POLICY_REFRESH_MS = 6e4;
+var AUTO_TRACE_POLICY_RETRY_MS = 1e4;
+function autoTraceLimit(value, fallback) {
+  return value !== void 0 && Number.isFinite(value) && value >= 0 ? Math.floor(value) : fallback;
+}
 var Bitfab = class {
   /**
    * Initialize the Bitfab client.
@@ -5513,6 +5601,7 @@ var Bitfab = class {
   constructor(config) {
     /** Gate the empty-key warning to fire at most once. */
     this.apiKeyWarned = false;
+    this.autoTracePolicyRefreshes = /* @__PURE__ */ new Map();
     /**
      * Mock overrides registered via {@link Bitfab.registerMockOverride}, applied
      * to every `replay` on this client (after any per-call `mockOverride`). In
@@ -5536,6 +5625,178 @@ var Bitfab = class {
       timeout: this.timeout
     });
   }
+  /**
+   * Decorate a class method as an automatically expanded trace root.
+   *
+   * Build instrumentation turns repository functions called beneath this
+   * method into nested spans. Every generated span preserves structure; only
+   * function IDs selected by the capture policy include inputs and output.
+   * Without a compatible build transform, this still records the decorated
+   * method as a normal rich root span but cannot discover child calls.
+   *
+   * @param traceFunctionKey - Groups traces and their capture policy.
+   * @param options - Root presentation, subtree bounds, and exclusions.
+   * @experimental Automatic child-call instrumentation is experimental.
+   */
+  trace(traceFunctionKey, options = {}) {
+    const decorator = (...args) => {
+      if (args.length === 3) {
+        const propertyKey = args[1];
+        const descriptor = args[2];
+        if (!descriptor || typeof descriptor.value !== "function") {
+          throw new BitfabError("@bitfab.trace can only decorate methods");
+        }
+        if (!this.explicitlyEnabled) {
+          return;
+        }
+        descriptor.value = this.createAutoTraceRoot(
+          traceFunctionKey,
+          String(propertyKey),
+          options,
+          descriptor.value
+        );
+        return;
+      }
+      const method = args[0];
+      const context = args[1];
+      if (typeof method !== "function" || context?.kind !== "method" || context.name === void 0) {
+        throw new BitfabError("@bitfab.trace can only decorate methods");
+      }
+      if (!this.explicitlyEnabled) {
+        return method;
+      }
+      return this.createAutoTraceRoot(
+        traceFunctionKey,
+        String(context.name),
+        options,
+        method
+      );
+    };
+    return decorator;
+  }
+  withTrace(traceFunctionKey, optionsOrFn, maybeFn) {
+    const options = typeof optionsOrFn === "function" ? {} : optionsOrFn;
+    const fn = typeof optionsOrFn === "function" ? optionsOrFn : maybeFn;
+    if (!fn) {
+      throw new BitfabError("bitfab.withTrace requires a function");
+    }
+    if (!this.explicitlyEnabled) {
+      return fn;
+    }
+    const name = fn.name !== "" ? fn.name : traceFunctionKey;
+    return this.createAutoTraceRoot(traceFunctionKey, name, options, fn);
+  }
+  createAutoTraceRoot(traceFunctionKey, name, options, fn) {
+    const self = this;
+    const maxDepth = autoTraceLimit(
+      options.maxDepth,
+      DEFAULT_AUTO_TRACE_MAX_DEPTH
+    );
+    const maxSpans = autoTraceLimit(
+      options.maxSpans,
+      DEFAULT_AUTO_TRACE_MAX_SPANS
+    );
+    const excluded = new Set(options.exclude ?? []);
+    const includeWrappers = options.includeWrappers ?? false;
+    const tracedRoot = this.withSpan(
+      traceFunctionKey,
+      { name: options.name ?? name, type: options.type ?? "custom" },
+      function(...args) {
+        const capturePolicy = getAutoTraceCapturePolicy(self, traceFunctionKey);
+        self.refreshAutoTraceCapturePolicy(traceFunctionKey);
+        let spansUsed = 0;
+        let truncated = false;
+        const warnTruncated = () => {
+          if (!truncated) {
+            truncated = true;
+            getCurrentTrace().setMetadata({
+              bitfabAutoTrace: {
+                protocol: AUTO_TRACE_PROTOCOL,
+                truncated: true,
+                maxDepth,
+                maxSpans
+              }
+            });
+          }
+          warnOnce(
+            `auto-trace-truncated:${traceFunctionKey}`,
+            `"${traceFunctionKey}" hit an automatic subtree capture limit (maxDepth=${maxDepth}, maxSpans=${maxSpans}); its trace is incomplete. Raise the limits or narrow the subtree with exclude.`
+          );
+        };
+        const autoTraceContext = {
+          invoke(definition, inputs, invokeFn, depth) {
+            const nameParts = definition.name.split(".");
+            const simpleName = nameParts[nameParts.length - 1];
+            if (excluded.has(definition.name) || simpleName !== void 0 && excluded.has(simpleName) || definition.wrapper === true && !includeWrappers) {
+              return invokeFn();
+            }
+            if (depth >= maxDepth || spansUsed >= maxSpans) {
+              warnTruncated();
+              return invokeFn();
+            }
+            spansUsed += 1;
+            const childOptions = {
+              name: definition.name,
+              type: "function",
+              captureWhen: "nested",
+              functionId: definition.id,
+              captureContent: capturePolicy.has(definition.id),
+              autoTraceDefinition: definition
+            };
+            const tracedChild = self.withSpan(
+              traceFunctionKey,
+              childOptions,
+              (..._inputs) => runWithAutoTraceContext(autoTraceContext, invokeFn, depth + 1)
+            );
+            return tracedChild(...inputs);
+          }
+        };
+        return runWithAutoTraceRootContext(
+          autoTraceContext,
+          () => fn.apply(this, args)
+        );
+      }
+    );
+    const autoTraceRoot = function(...args) {
+      if (!self.isTracingEnabled()) {
+        return fn.apply(this, args);
+      }
+      return tracedRoot.apply(this, args);
+    };
+    Object.defineProperty(autoTraceRoot, "_bitfabTraceFunctionKey", {
+      value: traceFunctionKey
+    });
+    return autoTraceRoot;
+  }
+  refreshAutoTraceCapturePolicy(traceFunctionKey) {
+    const now = Date.now();
+    const state = this.autoTracePolicyRefreshes.get(traceFunctionKey) ?? {
+      refreshAfter: 0
+    };
+    if (state.inFlight || now < state.refreshAfter) {
+      return;
+    }
+    const request = this.httpClient.getAutoTracePolicy(
+      traceFunctionKey,
+      AUTO_TRACE_PROTOCOL
+    ).then((policy) => {
+      if (policy.protocol !== AUTO_TRACE_PROTOCOL) {
+        state.refreshAfter = Date.now() + AUTO_TRACE_POLICY_RETRY_MS;
+        return;
+      }
+      const functionIds = Array.isArray(policy.functionIds) ? policy.functionIds.filter(
+        (id) => typeof id === "string" && id.startsWith(`${AUTO_TRACE_PROTOCOL}:`)
+      ).slice(0, DEFAULT_AUTO_TRACE_MAX_SPANS) : [];
+      __setBitfabAutoTraceCapturePolicy(this, traceFunctionKey, functionIds);
+      state.refreshAfter = Date.now() + AUTO_TRACE_POLICY_REFRESH_MS;
+    }).catch(() => {
+      state.refreshAfter = Date.now() + AUTO_TRACE_POLICY_RETRY_MS;
+    }).finally(() => {
+      state.inFlight = void 0;
+    });
+    state.inFlight = request;
+    this.autoTracePolicyRefreshes.set(traceFunctionKey, state);
+  }
   /**
    * Flush and permanently close this client's tracing resources: its pending
    * requests and the single span-transport worker shared by its decorators and
@@ -6082,7 +6343,10 @@ var Bitfab = class {
           parentSpanId,
           inputs,
           startedAt,
-          spanType: options.type ?? "custom"
+          spanType: options.type ?? "custom",
+          functionId: options.functionId,
+          captureContent: options.captureContent ?? true,
+          autoTraceDefinition: options.autoTraceDefinition
         };
         const sendSpan = async (params) => {
           const replayCtx = getReplayContext();
@@ -6247,7 +6511,16 @@ var Bitfab = class {
           }
         };
         executeWithContext = () => {
-          const result = fn.apply(this, args);
+          let result;
+          try {
+            result = fn.apply(this, args);
+          } catch (error) {
+            void sendSpan({
+              result: void 0,
+              error: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+          }
           if (result instanceof Promise) {
             return result.then((resolvedResult) => {
               recordSpan(resolvedResult);
@@ -6488,8 +6761,8 @@ var Bitfab = class {
    * Queued on the client's span transport; delivery is the transport's job.
    */
   sendWrapperSpan(params) {
-    const serializedInputs = serializeValue(params.inputs);
-    const serializedResult = serializeValue(params.result);
+    const serializedInputs = params.captureContent ? serializeValue(params.inputs) : void 0;
+    const serializedResult = params.captureContent ? serializeValue(params.result) : void 0;
     const externalSpan = {
       id: params.spanId,
       trace_id: params.traceId,
@@ -6498,26 +6771,38 @@ var Bitfab = class {
       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
+        ...params.functionId !== void 0 && {
+          function_id: params.functionId,
+          content_captured: params.captureContent
+        },
+        ...params.autoTraceDefinition !== void 0 && {
+          function_file: params.autoTraceDefinition.file,
+          function_line: params.autoTraceDefinition.line,
+          function_column: params.autoTraceDefinition.column
         },
-        ...serializedResult.meta !== void 0 && {
-          output_meta: serializedResult.meta
+        ...serializedInputs !== void 0 && {
+          input: serializedInputs.json,
+          ...serializedInputs.meta !== void 0 && {
+            input_meta: serializedInputs.meta
+          }
+        },
+        ...serializedResult !== void 0 && {
+          output: serializedResult.json,
+          ...serializedResult.meta !== void 0 && {
+            output_meta: serializedResult.meta
+          }
         },
         ...params.functionName !== void 0 && {
           function_name: params.functionName
         },
-        ...params.error !== void 0 && {
+        ...params.captureContent && params.error !== void 0 && {
           error: params.error,
           error_source: "code"
         },
-        ...params.contexts && params.contexts.length > 0 && {
+        ...params.captureContent && params.contexts && params.contexts.length > 0 && {
           contexts: params.contexts
         },
-        ...params.prompt !== void 0 && { prompt: params.prompt }
+        ...params.captureContent && params.prompt !== void 0 && { prompt: params.prompt }
       }
     };
     if (params.parentSpanId) {