@langfuse/core 4.0.0-beta.4 → 4.0.0-beta.6

package/dist/index.cjs

@@ -32,6 +32,7 @@ __export(index_exports, {
   LangfuseAPIClient: () => LangfuseAPIClient,
   LangfuseAPIError: () => LangfuseAPIError,
   LangfuseAPITimeoutError: () => LangfuseAPITimeoutError,
+  LangfuseMedia: () => LangfuseMedia,
   LangfuseOtelSpanAttributes: () => LangfuseOtelSpanAttributes,
   LogLevel: () => LogLevel,
   Logger: () => Logger,
@@ -47,6 +48,10 @@ __export(index_exports, {
   ServiceUnavailableError: () => ServiceUnavailableError,
   UnauthorizedError: () => UnauthorizedError,
   annotationQueues: () => annotationQueues_exports,
+  base64Decode: () => base64Decode,
+  base64Encode: () => base64Encode,
+  base64ToBytes: () => base64ToBytes,
+  bytesToBase64: () => bytesToBase64,
   comments: () => comments_exports,
   commons: () => commons_exports,
   configureGlobalLogger: () => configureGlobalLogger,
@@ -76,7 +81,6 @@ __export(index_exports, {
   scoreV2: () => scoreV2_exports,
   sessions: () => sessions_exports,
   trace: () => trace_exports,
-  uint8ArrayToBase64: () => uint8ArrayToBase64,
   utils: () => utils_exports
 });
 module.exports = __toCommonJS(index_exports);
@@ -112,14 +116,29 @@ function safeSetTimeout(fn, timeout) {
   }
   return t;
 }
-function uint8ArrayToBase64(arr) {
+function base64ToBytes(base64) {
+  const binString = atob(base64);
+  return Uint8Array.from(binString, (m) => m.codePointAt(0));
+}
+function bytesToBase64(bytes) {
+  const binString = Array.from(bytes, (byte) => String.fromCharCode(byte)).join(
+    ""
+  );
+  return btoa(binString);
+}
+function base64Encode(input) {
   if (typeof Buffer !== "undefined") {
-    return Buffer.from(arr).toString("base64");
+    return Buffer.from(input, "utf8").toString("base64");
   }
-  if (typeof btoa !== "undefined") {
-    return btoa(String.fromCharCode(...arr));
+  const bytes = new TextEncoder().encode(input);
+  return bytesToBase64(bytes);
+}
+function base64Decode(input) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(input, "base64").toString("utf8");
   }
-  throw new Error("Base64 encoding not available");
+  const bytes = base64ToBytes(input);
+  return new TextDecoder().decode(bytes);
 }
 
 // src/logger/index.ts
@@ -297,7 +316,7 @@ var resetGlobalLogger = () => {
 // package.json
 var package_default = {
   name: "@langfuse/core",
-  version: "4.0.0-beta.4",
+  version: "4.0.0-beta.6",
   description: "Core functions and utilities for Langfuse packages",
   type: "module",
   sideEffects: false,
@@ -1364,26 +1383,26 @@ function trimSlashes(str) {
 }
 
 // src/api/core/base64.ts
-function base64ToBytes(base64) {
+function base64ToBytes2(base64) {
   const binString = atob(base64);
   return Uint8Array.from(binString, (m) => m.codePointAt(0));
 }
-function bytesToBase64(bytes) {
+function bytesToBase642(bytes) {
   const binString = String.fromCodePoint(...bytes);
   return btoa(binString);
 }
-function base64Encode(input) {
+function base64Encode2(input) {
   if (typeof Buffer !== "undefined") {
     return Buffer.from(input, "utf8").toString("base64");
   }
   const bytes = new TextEncoder().encode(input);
-  return bytesToBase64(bytes);
+  return bytesToBase642(bytes);
 }
-function base64Decode(input) {
+function base64Decode2(input) {
   if (typeof Buffer !== "undefined") {
     return Buffer.from(input, "base64").toString("utf8");
   }
-  const bytes = base64ToBytes(input);
+  const bytes = base64ToBytes2(input);
   return new TextDecoder().decode(bytes);
 }
 
@@ -1394,12 +1413,12 @@ var BasicAuth = {
     if (basicAuth == null) {
       return void 0;
     }
-    const token = base64Encode(`${basicAuth.username}:${basicAuth.password}`);
+    const token = base64Encode2(`${basicAuth.username}:${basicAuth.password}`);
     return `Basic ${token}`;
   },
   fromAuthorizationHeader: (header) => {
     const credentials = header.replace(BASIC_AUTH_HEADER_PREFIX, "");
-    const decoded = base64Decode(credentials);
+    const decoded = base64Decode2(credentials);
     const [username, password] = decoded.split(":", 2);
     if (username == null || password == null) {
       throw new Error("Invalid basic auth");
@@ -9626,6 +9645,168 @@ var LangfuseAPIClient = class {
     return (_a2 = this._trace) != null ? _a2 : this._trace = new Trace(this._options);
   }
 };
+
+// src/media.ts
+var LangfuseMedia = class {
+  /**
+   * Creates a new LangfuseMedia instance.
+   *
+   * @param params - Media parameters specifying the source and content
+   *
+   * @example
+   * ```typescript
+   * // Create from base64 data URI
+   * const media = new LangfuseMedia({
+   *   source: "base64_data_uri",
+   *   base64DataUri: "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQ..."
+   * });
+   * ```
+   */
+  constructor(params) {
+    const { source } = params;
+    this._source = source;
+    if (source === "base64_data_uri") {
+      const [contentBytesParsed, contentTypeParsed] = this.parseBase64DataUri(
+        params.base64DataUri
+      );
+      this._contentBytes = contentBytesParsed;
+      this._contentType = contentTypeParsed;
+    } else {
+      this._contentBytes = params.contentBytes;
+      this._contentType = params.contentType;
+    }
+  }
+  /**
+   * Parses a base64 data URI to extract content bytes and type.
+   *
+   * @param data - The base64 data URI string
+   * @returns Tuple of [contentBytes, contentType] or [undefined, undefined] on error
+   * @private
+   */
+  parseBase64DataUri(data) {
+    try {
+      if (!data || typeof data !== "string") {
+        throw new Error("Data URI is not a string");
+      }
+      if (!data.startsWith("data:")) {
+        throw new Error("Data URI does not start with 'data:'");
+      }
+      const [header, actualData] = data.slice(5).split(",", 2);
+      if (!header || !actualData) {
+        throw new Error("Invalid URI");
+      }
+      const headerParts = header.split(";");
+      if (!headerParts.includes("base64")) {
+        throw new Error("Data is not base64 encoded");
+      }
+      const contentType = headerParts[0];
+      if (!contentType) {
+        throw new Error("Content type is empty");
+      }
+      return [base64ToBytes(actualData), contentType];
+    } catch (error) {
+      getGlobalLogger().error("Error parsing base64 data URI", error);
+      return [void 0, void 0];
+    }
+  }
+  /**
+   * Gets a unique identifier for this media based on its content hash.
+   *
+   * The ID is derived from the first 22 characters of the URL-safe base64-encoded
+   * SHA-256 hash of the content.
+   *
+   * @returns The unique media ID, or null if hash generation failed
+   *
+   * @example
+   * ```typescript
+   * const media = new LangfuseMedia({...});
+   * console.log(media.id); // "A1B2C3D4E5F6G7H8I9J0K1"
+   * ```
+   */
+  async getId() {
+    const contentSha256Hash = await this.getSha256Hash();
+    if (!contentSha256Hash) return null;
+    const urlSafeContentHash = contentSha256Hash.replaceAll("+", "-").replaceAll("/", "_");
+    return urlSafeContentHash.slice(0, 22);
+  }
+  /**
+   * Gets the length of the media content in bytes.
+   *
+   * @returns The content length in bytes, or undefined if no content is available
+   */
+  get contentLength() {
+    var _a2;
+    return (_a2 = this._contentBytes) == null ? void 0 : _a2.length;
+  }
+  /**
+   * Gets the SHA-256 hash of the media content.
+   *
+   * The hash is used for content integrity verification and generating unique media IDs.
+   * Returns undefined if crypto is not available or hash generation fails.
+   *
+   * @returns The base64-encoded SHA-256 hash, or undefined if unavailable
+   */
+  async getSha256Hash() {
+    if (!this._contentBytes) {
+      return void 0;
+    }
+    try {
+      const hash = await crypto.subtle.digest("SHA-256", this._contentBytes);
+      return bytesToBase64(new Uint8Array(hash));
+    } catch (error) {
+      getGlobalLogger().warn(
+        "[Langfuse] Failed to generate SHA-256 hash for media content:",
+        error
+      );
+      return void 0;
+    }
+  }
+  /**
+   * Gets the media reference tag for embedding in trace data.
+   *
+   * The tag format is: `@@@langfuseMedia:type=<contentType>|id=<mediaId>|source=<source>@@@`
+   * This tag can be embedded in trace attributes and will be replaced with actual
+   * media content when the trace is viewed in Langfuse.
+   *
+   * @returns The media reference tag, or null if required data is missing
+   *
+   * @example
+   * ```typescript
+   * const media = new LangfuseMedia({...});
+   * console.log(media.tag);
+   * // "@@@langfuseMedia:type=image/png|id=A1B2C3D4E5F6G7H8I9J0K1|source=base64_data_uri@@@"
+   * ```
+   */
+  async getTag() {
+    const id = await this.getId();
+    if (!this._contentType || !this._source || !id) return null;
+    return `@@@langfuseMedia:type=${this._contentType}|id=${id}|source=${this._source}@@@`;
+  }
+  /**
+   * Gets the media content as a base64 data URI.
+   *
+   * @returns The complete data URI string, or null if no content is available
+   *
+   * @example
+   * ```typescript
+   * const media = new LangfuseMedia({...});
+   * console.log(media.base64DataUri);
+   * // "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAAB..."
+   * ```
+   */
+  get base64DataUri() {
+    if (!this._contentBytes) return null;
+    return `data:${this._contentType};base64,${bytesToBase64(this._contentBytes)}`;
+  }
+  /**
+   * Serializes the media to JSON (returns the base64 data URI).
+   *
+   * @returns The base64 data URI, or null if no content is available
+   */
+  toJSON() {
+    return this.base64DataUri;
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AccessDeniedError,
@@ -9640,6 +9821,7 @@ var LangfuseAPIClient = class {
   LangfuseAPIClient,
   LangfuseAPIError,
   LangfuseAPITimeoutError,
+  LangfuseMedia,
   LangfuseOtelSpanAttributes,
   LogLevel,
   Logger,
@@ -9655,6 +9837,10 @@ var LangfuseAPIClient = class {
   ServiceUnavailableError,
   UnauthorizedError,
   annotationQueues,
+  base64Decode,
+  base64Encode,
+  base64ToBytes,
+  bytesToBase64,
   comments,
   commons,
   configureGlobalLogger,
@@ -9684,7 +9870,6 @@ var LangfuseAPIClient = class {
   scoreV2,
   sessions,
   trace,
-  uint8ArrayToBase64,
   utils
 });
 //# sourceMappingURL=index.cjs.map