@bitfab/sdk 0.18.2 → 0.19.1

package/dist/index.cjs

@@ -45,6 +45,120 @@ var init_errors = __esm({
   }
 });
 
+// src/serialize.ts
+function describeValue(value) {
+  try {
+    const ctorName = value?.constructor?.name;
+    if (ctorName && ctorName !== "Object") {
+      return ctorName;
+    }
+  } catch {
+  }
+  return typeof value;
+}
+function unserializableStub(value, reason) {
+  let summary;
+  try {
+    summary = `<unserializable: ${describeValue(value)} (${reason})>`;
+  } catch {
+    summary = `<unserializable (${reason})>`;
+  }
+  return { json: summary };
+}
+function serializeValue(value) {
+  try {
+    const { json, meta } = import_superjson.default.serialize(value);
+    let size;
+    try {
+      size = JSON.stringify(json).length;
+    } catch {
+      return unserializableStub(value, "stringify_failed_after_superjson");
+    }
+    if (size > MAX_SERIALIZED_BYTES) {
+      return unserializableStub(value, `too_large_${size}_bytes`);
+    }
+    return meta ? { json, meta } : { json };
+  } catch {
+    try {
+      return { json: JSON.parse(JSON.stringify(value)) };
+    } catch {
+      return unserializableStub(value, "json_stringify_failed");
+    }
+  }
+}
+function deserializeValue(serialized) {
+  if (serialized.meta === void 0) {
+    return serialized.json;
+  }
+  return import_superjson.default.deserialize({
+    json: serialized.json,
+    meta: serialized.meta
+  });
+}
+function toJsonSafe(value) {
+  return toJsonSafeInner(value, 0, /* @__PURE__ */ new WeakSet());
+}
+function toJsonSafeInner(value, depth, seen) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  const className = value?.constructor?.name ?? typeof value;
+  if (depth > MAX_SAFE_DEPTH) {
+    return `<${className}>`;
+  }
+  if (typeof value !== "object") {
+    try {
+      return String(value);
+    } catch {
+      return `<${className}>`;
+    }
+  }
+  if (seen.has(value)) {
+    return `<cycle ${className}>`;
+  }
+  seen.add(value);
+  let result;
+  if (Array.isArray(value)) {
+    result = value.map((item) => toJsonSafeInner(item, depth + 1, seen));
+  } else if (typeof value.toJSON === "function") {
+    try {
+      result = toJsonSafeInner(
+        value.toJSON(),
+        depth + 1,
+        seen
+      );
+    } catch {
+      result = `<${className}>`;
+    }
+  } else {
+    try {
+      const obj = {};
+      for (const [k, v] of Object.entries(value)) {
+        if (!k.startsWith("_")) {
+          obj[k] = toJsonSafeInner(v, depth + 1, seen);
+        }
+      }
+      result = obj;
+    } catch {
+      result = `<${className}>`;
+    }
+  }
+  seen.delete(value);
+  return result;
+}
+var import_superjson, MAX_SERIALIZED_BYTES, MAX_SAFE_DEPTH;
+var init_serialize = __esm({
+  "src/serialize.ts"() {
+    "use strict";
+    import_superjson = __toESM(require("superjson"), 1);
+    MAX_SERIALIZED_BYTES = 512e3;
+    MAX_SAFE_DEPTH = 6;
+  }
+});
+
 // src/asyncStorage.ts
 function registerAsyncLocalStorageClass(cls) {
   if (!AsyncLocalStorageClass) {
@@ -106,65 +220,6 @@ var init_replayContext = __esm({
   }
 });
 
-// src/serialize.ts
-function describeValue(value) {
-  try {
-    const ctorName = value?.constructor?.name;
-    if (ctorName && ctorName !== "Object") {
-      return ctorName;
-    }
-  } catch {
-  }
-  return typeof value;
-}
-function unserializableStub(value, reason) {
-  let summary;
-  try {
-    summary = `<unserializable: ${describeValue(value)} (${reason})>`;
-  } catch {
-    summary = `<unserializable (${reason})>`;
-  }
-  return { json: summary };
-}
-function serializeValue(value) {
-  try {
-    const { json, meta } = import_superjson.default.serialize(value);
-    let size;
-    try {
-      size = JSON.stringify(json).length;
-    } catch {
-      return unserializableStub(value, "stringify_failed_after_superjson");
-    }
-    if (size > MAX_SERIALIZED_BYTES) {
-      return unserializableStub(value, `too_large_${size}_bytes`);
-    }
-    return meta ? { json, meta } : { json };
-  } catch {
-    try {
-      return { json: JSON.parse(JSON.stringify(value)) };
-    } catch {
-      return unserializableStub(value, "json_stringify_failed");
-    }
-  }
-}
-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, MAX_SERIALIZED_BYTES;
-var init_serialize = __esm({
-  "src/serialize.ts"() {
-    "use strict";
-    import_superjson = __toESM(require("superjson"), 1);
-    MAX_SERIALIZED_BYTES = 512e3;
-  }
-});
-
 // src/replay.ts
 var replay_exports = {};
 __export(replay_exports, {
@@ -433,13 +488,93 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/version.generated.ts
-var __version__ = "0.18.2";
+var __version__ = "0.19.1";
 
 // src/constants.ts
 var DEFAULT_SERVICE_URL = "https://bitfab.ai";
 
 // src/http.ts
 init_errors();
+function serializePayloadBody(payload) {
+  try {
+    return { body: JSON.stringify(payload), dropped: [] };
+  } catch {
+    const dropped = [];
+    const sanitize = (value, seen) => {
+      const t = typeof value;
+      if (value === null || t === "string" || t === "number" || t === "boolean") {
+        return value;
+      }
+      if (t === "bigint") {
+        dropped.push("BigInt");
+        return "<unserializable: BigInt>";
+      }
+      if (t === "function") {
+        const name = value.name || "Function";
+        dropped.push(name);
+        return `<unserializable: ${name}>`;
+      }
+      if (t === "symbol") {
+        dropped.push("Symbol");
+        return "<unserializable: Symbol>";
+      }
+      if (t !== "object") {
+        return void 0;
+      }
+      const obj = value;
+      const className = obj.constructor?.name || "object";
+      if (seen.has(obj)) {
+        dropped.push(className);
+        return `<cycle: ${className}>`;
+      }
+      seen.add(obj);
+      let result;
+      if (Array.isArray(obj)) {
+        result = obj.map((item) => sanitize(item, seen));
+      } else if (typeof obj.toJSON === "function") {
+        try {
+          result = sanitize(obj.toJSON(), seen);
+        } catch {
+          dropped.push(className);
+          result = `<unserializable: ${className}>`;
+        }
+      } else {
+        const out = {};
+        for (const [k, v] of Object.entries(obj)) {
+          out[k] = sanitize(v, seen);
+        }
+        result = out;
+      }
+      seen.delete(obj);
+      return result;
+    };
+    let sanitized;
+    try {
+      sanitized = sanitize(payload, /* @__PURE__ */ new WeakSet());
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        body: JSON.stringify({ error: `payload_serialize_failed: ${message}` }),
+        dropped
+      };
+    }
+    if (dropped.length > 0 && typeof sanitized === "object" && sanitized !== null && !Array.isArray(sanitized)) {
+      const obj = sanitized;
+      const existing = Array.isArray(obj.errors) ? obj.errors : [];
+      obj.errors = [
+        ...existing,
+        {
+          source: "sdk",
+          step: "json_serialize",
+          error: `stubbed non-serializable value(s): ${[
+            ...new Set(dropped)
+          ].join(", ")}`
+        }
+      ];
+    }
+    return { body: JSON.stringify(sanitized), dropped };
+  }
+}
 var pendingTracePromises = /* @__PURE__ */ new Set();
 function awaitOnExit(promise) {
   pendingTracePromises.add(promise);
@@ -498,23 +633,14 @@ var HttpClient = class {
     const method = options?.method ?? "POST";
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeout);
-    let body;
-    let serializationError;
-    try {
-      body = JSON.stringify(payload);
-    } catch (error) {
-      serializationError = error instanceof Error ? error.message : String(error);
-      body = JSON.stringify({
-        ...Object.fromEntries(
-          Object.entries(payload).filter(
-            ([, v]) => typeof v === "string" || typeof v === "number"
-          )
-        ),
-        rawSpan: {},
-        errors: [
-          { source: "sdk", step: "json_serialize", error: serializationError }
-        ]
-      });
+    const { body, dropped } = serializePayloadBody(payload);
+    if (dropped.length > 0) {
+      try {
+        console.warn(
+          `Bitfab: request body to ${endpoint} held ${dropped.length} non-serializable value(s) (${[...new Set(dropped)].join(", ")}); they were stubbed so the span still sends, but the trace may be incomplete or not replayable. Capture a JSON-safe projection of this input to make it replayable.`
+        );
+      } catch {
+      }
     }
     try {
       const response = await fetch(url, {
@@ -772,56 +898,41 @@ var HttpClient = class {
 };
 
 // src/claudeAgentSdk.ts
+init_serialize();
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
-function safeSerialize(value) {
-  if (value === null || value === void 0) {
-    return value;
-  }
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.map(safeSerialize);
-  }
-  if (typeof value === "object") {
-    if (typeof value.toJSON === "function") {
-      return value.toJSON();
-    }
-    const result = {};
-    for (const [k, v] of Object.entries(value)) {
-      if (!k.startsWith("_")) {
-        result[k] = safeSerialize(v);
-      }
-    }
-    return result;
-  }
-  return String(value);
-}
+var safeSerialize = toJsonSafe;
 function extractContentBlocks(content) {
   if (!Array.isArray(content)) {
     return [];
   }
   return content.map((block) => safeSerialize(block));
 }
+function asTokenCount(val) {
+  return typeof val === "number" && Number.isFinite(val) ? val : null;
+}
 function extractUsage(message) {
   const usageInfo = {};
   const usage = message.usage;
   if (!usage) {
     return usageInfo;
   }
-  const mapping = {
-    input_tokens: "inputTokens",
-    output_tokens: "outputTokens",
-    cache_read_input_tokens: "cacheReadTokens",
-    cache_creation_input_tokens: "cacheCreationTokens"
-  };
-  for (const [srcKey, dstKey] of Object.entries(mapping)) {
-    const val = usage[srcKey];
-    if (val !== void 0 && val !== null) {
-      usageInfo[dstKey] = val;
-    }
+  const baseInput = asTokenCount(usage.input_tokens);
+  const cacheRead = asTokenCount(usage.cache_read_input_tokens);
+  const cacheCreation = asTokenCount(usage.cache_creation_input_tokens);
+  if (baseInput !== null || cacheRead !== null || cacheCreation !== null) {
+    usageInfo.inputTokens = (baseInput ?? 0) + (cacheRead ?? 0) + (cacheCreation ?? 0);
+  }
+  const output = asTokenCount(usage.output_tokens);
+  if (output !== null) {
+    usageInfo.outputTokens = output;
+  }
+  if (cacheRead !== null) {
+    usageInfo.cacheReadTokens = cacheRead;
+  }
+  if (cacheCreation !== null) {
+    usageInfo.cacheCreationTokens = cacheCreation;
   }
   return usageInfo;
 }
@@ -1554,6 +1665,7 @@ function buildSnapshotRef(config, sdkWallClockBeforeFn) {
 }
 
 // src/langgraph.ts
+init_serialize();
 var LANGSMITH_HIDDEN_TAG = "langsmith:hidden";
 var LANGGRAPH_METADATA_KEYS = [
   "langgraph_step",
@@ -1565,56 +1677,7 @@ var LANGGRAPH_METADATA_KEYS = [
 function nowIso2() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
-var MAX_SERIALIZE_DEPTH = 6;
-function safeSerialize2(value) {
-  return safeSerializeInner(value, 0, /* @__PURE__ */ new WeakSet());
-}
-function safeSerializeInner(value, depth, seen) {
-  if (value === null || value === void 0) {
-    return value;
-  }
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return value;
-  }
-  const className = value?.constructor?.name ?? typeof value;
-  if (depth > MAX_SERIALIZE_DEPTH) {
-    return `<${className}>`;
-  }
-  if (typeof value === "object") {
-    if (seen.has(value)) {
-      return `<cycle ${className}>`;
-    }
-    seen.add(value);
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => safeSerializeInner(item, depth + 1, seen));
-  }
-  if (typeof value === "object") {
-    if (typeof value.toJSON === "function") {
-      try {
-        return value.toJSON();
-      } catch {
-        return `<${className}>`;
-      }
-    }
-    try {
-      const result = {};
-      for (const [k, v] of Object.entries(value)) {
-        if (!k.startsWith("_")) {
-          result[k] = safeSerializeInner(v, depth + 1, seen);
-        }
-      }
-      return result;
-    } catch {
-      return `<${className}>`;
-    }
-  }
-  try {
-    return String(value);
-  } catch {
-    return `<${className}>`;
-  }
-}
+var safeSerialize2 = toJsonSafe;
 function convertMessage(message) {
   if (typeof message !== "object" || message === null) {
     return { role: "unknown", content: String(message) };
@@ -1663,7 +1726,7 @@ function extractModelName(serialized, metadata) {
   }
   return void 0;
 }
-function asTokenCount(value) {
+function asTokenCount2(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 function normalizeTokenUsage(raw) {
@@ -1672,10 +1735,10 @@ function normalizeTokenUsage(raw) {
   }
   const u = raw;
   if ("cache_read_input_tokens" in u || "cache_creation_input_tokens" in u) {
-    const cacheRead = asTokenCount(u.cache_read_input_tokens);
-    const cacheCreation = asTokenCount(u.cache_creation_input_tokens);
-    const baseInput = asTokenCount(u.input_tokens);
-    const outputTokens = asTokenCount(u.output_tokens);
+    const cacheRead = asTokenCount2(u.cache_read_input_tokens);
+    const cacheCreation = asTokenCount2(u.cache_creation_input_tokens);
+    const baseInput = asTokenCount2(u.input_tokens);
+    const outputTokens = asTokenCount2(u.output_tokens);
     if (cacheRead === null && cacheCreation === null && baseInput === null && outputTokens === null) {
       return null;
     }
@@ -1690,25 +1753,25 @@ function normalizeTokenUsage(raw) {
   if ("prompt_tokens" in u || "completion_tokens" in u || "promptTokens" in u || "completionTokens" in u) {
     const promptDetails = u.prompt_tokens_details ?? {};
     return withAnyTokenCount({
-      inputTokens: asTokenCount(u.prompt_tokens) ?? asTokenCount(u.promptTokens),
-      outputTokens: asTokenCount(u.completion_tokens) ?? asTokenCount(u.completionTokens),
-      totalTokens: asTokenCount(u.total_tokens) ?? asTokenCount(u.totalTokens),
-      cachedInputTokens: asTokenCount(promptDetails.cached_tokens)
+      inputTokens: asTokenCount2(u.prompt_tokens) ?? asTokenCount2(u.promptTokens),
+      outputTokens: asTokenCount2(u.completion_tokens) ?? asTokenCount2(u.completionTokens),
+      totalTokens: asTokenCount2(u.total_tokens) ?? asTokenCount2(u.totalTokens),
+      cachedInputTokens: asTokenCount2(promptDetails.cached_tokens)
     });
   }
   if ("prompt_token_count" in u || "candidates_token_count" in u) {
     return withAnyTokenCount({
-      inputTokens: asTokenCount(u.prompt_token_count),
-      outputTokens: asTokenCount(u.candidates_token_count),
-      totalTokens: asTokenCount(u.total_token_count),
-      cachedInputTokens: asTokenCount(u.cached_content_token_count)
+      inputTokens: asTokenCount2(u.prompt_token_count),
+      outputTokens: asTokenCount2(u.candidates_token_count),
+      totalTokens: asTokenCount2(u.total_token_count),
+      cachedInputTokens: asTokenCount2(u.cached_content_token_count)
     });
   }
   if ("input_tokens" in u || "output_tokens" in u) {
     const inputDetails = u.input_token_details ?? {};
-    const inputTokens = asTokenCount(u.input_tokens);
-    const outputTokens = asTokenCount(u.output_tokens);
-    let totalTokens = asTokenCount(u.total_tokens);
+    const inputTokens = asTokenCount2(u.input_tokens);
+    const outputTokens = asTokenCount2(u.output_tokens);
+    let totalTokens = asTokenCount2(u.total_tokens);
     if (totalTokens === null && inputTokens !== null && outputTokens !== null) {
       totalTokens = inputTokens + outputTokens;
     }
@@ -1716,7 +1779,7 @@ function normalizeTokenUsage(raw) {
       inputTokens,
       outputTokens,
       totalTokens,
-      cachedInputTokens: asTokenCount(inputDetails.cache_read)
+      cachedInputTokens: asTokenCount2(inputDetails.cache_read)
     });
   }
   return null;