@hue-run/sdk 0.19.0 → 0.19.1

package/CLI.md

@@ -42,7 +42,7 @@ project manifest are refused because managers can update ancestor locks; Python
 The generated `hue.setup.mjs` or `hue_setup.py` always selects `captureContent: false` /
 `capture_content=False`. For a supported application, setup installs the dependency and adds the
 managed import and middleware registration to the existing entrypoint; an unreferenced helper is
-not a completed integration. TypeScript uses `@hue-run/sdk@0.19.0`, `@opentelemetry/api@1.9.1` and
+not a completed integration. TypeScript uses `@hue-run/sdk@0.19.1`, `@opentelemetry/api@1.9.1` and
 `@opentelemetry/context-async-hooks@2.11.0`; Python setup uses its separately tested package pin.
 Content capture requires an ordinary account-managed key and a later explicit application decision.
 
@@ -379,8 +379,8 @@ and Hue never receives or stores them. The command is part of the `hue` executab
 #   LANGFUSE_PUBLIC_KEY=pk-lf-...
 #   LANGFUSE_SECRET_KEY=sk-lf-...
 #   LANGFUSE_BASE_URL=https://cloud.langfuse.com
-npx -y @hue-run/sdk@0.19.0 import langfuse --env-path .env.langfuse --from 2026-01-01 --dry-run
-npx -y @hue-run/sdk@0.19.0 import langfuse --env-path .env.langfuse --from 2026-01-01 --media
+npx -y @hue-run/sdk@0.19.1 import langfuse --env-path .env.langfuse --from 2026-01-01 --dry-run
+npx -y @hue-run/sdk@0.19.1 import langfuse --env-path .env.langfuse --from 2026-01-01 --media
 ```
 
 `LANGFUSE_PUBLIC_KEY` and `LANGFUSE_SECRET_KEY` come from the environment or `--env-path`
@@ -595,7 +595,7 @@ node packages/sdk-typescript/scripts/verify-package.mjs --artifacts-dir .artifac
 # Set project to an existing supported fixture; use the same directory on resume.
 project=/absolute/path/to/supported-fixture
 node packages/sdk-typescript/scripts/verify-setup-live.mjs \
-  --archive .artifacts/typescript/hue-run-sdk-0.19.0.tgz \
+  --archive .artifacts/typescript/hue-run-sdk-0.19.1.tgz \
   --origin https://STAGING_ORIGIN \
   --project "$project" --command setup \
   --evidence .context/setup-staging-before-claim.json
@@ -606,7 +606,7 @@ the private local handoff and finish the real browser claim, then reconcile the
 
 ```sh
 node packages/sdk-typescript/scripts/verify-setup-live.mjs \
-  --archive .artifacts/typescript/hue-run-sdk-0.19.0.tgz \
+  --archive .artifacts/typescript/hue-run-sdk-0.19.1.tgz \
   --origin https://STAGING_ORIGIN \
   --project "$project" --command claim \
   --evidence .context/setup-staging-after-claim.json
@@ -648,10 +648,10 @@ otherwise. Never hand the agent Hue-native tools (`context.tools`, `context.mcp`
 production agent lacks. Pin the SDK, so the agent's repository gains no dependency:
 
 ```sh
-npx -y @hue-run/sdk@0.19.0 eval --case "Refund an eligible charge" --command "node agent.js"
-npx -y @hue-run/sdk@0.19.0 eval --case https://app.hue.run/projects/demo/scenarios/<id> --command "python agent.py" --timeout 120 --baseline <run id>
-npx -y @hue-run/sdk@0.19.0 eval --set "Billing regressions" --scorer-version <id> --command "node agent.js" --save-version
-npx -y @hue-run/sdk@0.19.0 eval --worker --command "node agent.js" --agent-key support-agent --revision <new-agent-revision>
+npx -y @hue-run/sdk@0.19.1 eval --case "Refund an eligible charge" --command "node agent.js"
+npx -y @hue-run/sdk@0.19.1 eval --case https://app.hue.run/projects/demo/scenarios/<id> --command "python agent.py" --timeout 120 --baseline <run id>
+npx -y @hue-run/sdk@0.19.1 eval --set "Billing regressions" --scorer-version <id> --command "node agent.js" --save-version
+npx -y @hue-run/sdk@0.19.1 eval --worker --command "node agent.js" --agent-key support-agent --revision <new-agent-revision>
 ```
 
 One invocation creates one run holding every selected case; it prints the run URL
@@ -689,7 +689,7 @@ export default function runMyAgent(inputs: JsonValue, context: SimulationTargetC
 ```
 
 ```sh
-npx -y @hue-run/sdk@0.19.0 eval --case "Refund an eligible charge" ./hue-agent.ts --content
+npx -y @hue-run/sdk@0.19.1 eval --case "Refund an eligible charge" ./hue-agent.ts --content
 ```
 
 `--scenario` remains an alias for `--case` for existing scripts. Pass one selection flag.

package/README.md

@@ -266,10 +266,17 @@ Each uploaded file is listed in the record's `hue.blobs`, keyed `<attribute>#<JS
 - An OpenAI assistant message's `audio` loses `audio.data` and the message carries `sha256` and
   `size` (`gen_ai.output.messages#/0`). Its media type comes from `audio.format`, else from the
   bytes' WAV, MP3, AAC, FLAC or Ogg signature, else `application/octet-stream`.
+- Raw 16-bit PCM keeps the format its type declares: `audio/pcm`, `audio/x-pcm` or `audio/L16`
+  with a `rate` from 8000 to 192000 and 1 or 2 `channels` is listed as
+  `audio/pcm;rate=24000;channels=1` (`audio/L16;…` for big-endian samples), and OpenAI `pcm16`
+  audio as `audio/pcm;rate=24000;channels=1`, so Hue plays the stored file. Other types are listed
+  without their parameters.
 - A whole `data:` URL string becomes a GenAI `blob` part,
   `{"type":"blob","mime_type":"image/png","modality":"image","sha256":"…","size":68}`, keyed at
-  the string (`input.value#/image`). A value that is entirely one, such as a metadata attribute,
-  becomes that part's JSON text, keyed `<attribute>#`.
+  the string (`input.value#/image`). A value that is entirely one, such as a metadata attribute
+  or the string input or output a Langfuse SDK records as it is, becomes that part's JSON text,
+  keyed `<attribute>#`: an attribute read as JSON whose text is not JSON is read as that text, as
+  Hue reads it.
 - A file inside a JSON-encoded tool string takes the digest form inside the string. Its key goes on
   through the string, which no JSON pointer can address, so Hue matches it by its digest.
 - Text media over 64 KiB of decoded bytes in a provider part keeps a UTF-8-safe 16 KiB prefix in
@@ -516,6 +523,7 @@ the recorded model call again with the real image, document or audio. See
 | --- | --- | --- |
 | Base64 data URIs in an observation's input, output or metadata | | [Automatic capture](#automatically-captured-media), for the attributes and shapes listed there |
 | `LangfuseMedia` | `Attachment` | [`Attachment`](#attach-a-file-anywhere), at the same position |
+| `LangfuseMedia` and data URIs, keeping Langfuse's SDK | | Unchanged: with Hue's processor [beside Langfuse's](#existing-opentelemetry-providers), each file uploads to Hue in the background |
 | `resolveMediaReferences({ obj, resolveWith: "base64DataUri" })` | | `client.media.resolve(obj, { traceId })` |
 | `GET /api/public/media/{mediaId}` | `ReadonlyAttachment.data()` | `client.media.fetch({ traceId, sha256 })` |
 | Media tokens (`@@@langfuseMedia:…@@@`) | `ExternalAttachment` | Left as recorded: Hue never fetches a remote URL or a file another service holds. [`hue import langfuse --media`](#import-from-langfuse) copies Langfuse's files with your keys |
@@ -528,8 +536,8 @@ the Langfuse project's own keys (`LANGFUSE_PUBLIC_KEY`, `LANGFUSE_SECRET_KEY`, a
 `HUE_API_KEY`:
 
 ```sh
-npx -y @hue-run/sdk@0.19.0 import langfuse --env-path .env.langfuse --from 2026-01-01 --dry-run
-npx -y @hue-run/sdk@0.19.0 import langfuse --env-path .env.langfuse --from 2026-01-01 --media
+npx -y @hue-run/sdk@0.19.1 import langfuse --env-path .env.langfuse --from 2026-01-01 --dry-run
+npx -y @hue-run/sdk@0.19.1 import langfuse --env-path .env.langfuse --from 2026-01-01 --media
 ```
 
 - It reads Langfuse Cloud and self-hosted v4 through the Observations API v2, and self-hosted v3

package/dist/blobs.d.ts

@@ -249,7 +249,8 @@ export declare class BlobUploader {
     private reserve;
     /** A 200 answer read: `exists`, or an upload whose URL and headers are usable as given. */
     private reservation;
-    /** The PUT of the value's bytes, with exactly the headers Hue signed. A source that no longer
+    /** The PUT of the value's bytes, with exactly the headers Hue signed. No answer, a 408, a 429 or
+     * a 5xx is transient, with the answer's `Retry-After` when it gave one. A source that no longer
      * holds its bytes (a file changed since it was recorded) ends the request before its body is
      * complete, and fails the value without a retry. */
     private put;

package/dist/blobs.js

@@ -542,8 +542,9 @@ export class BlobUploader {
                 return { ok: false, reason: "failed", changed: true };
             if (this.closed)
                 return { ok: false, reason: "failed" };
-            if (put === "transient") {
-                if (++attempt >= UPLOAD_ATTEMPTS || !(await this.retryWait(attempt - 1, undefined, upload)))
+            if (typeof put === "object") {
+                if (++attempt >= UPLOAD_ATTEMPTS ||
+                    !(await this.retryWait(attempt - 1, put.retryAfter, upload)))
                     return { ok: false, reason: "failed" };
                 if (Date.now() < grant.expiresAt)
                     continue;
@@ -662,7 +663,8 @@ export class BlobUploader {
             grant: { url, headers, expiresAt: Number.isFinite(expiresAt) ? expiresAt : Infinity },
         };
     }
-    /** The PUT of the value's bytes, with exactly the headers Hue signed. A source that no longer
+    /** The PUT of the value's bytes, with exactly the headers Hue signed. No answer, a 408, a 429 or
+     * a 5xx is transient, with the answer's `Retry-After` when it gave one. A source that no longer
      * holds its bytes (a file changed since it was recorded) ends the request before its body is
      * complete, and fails the value without a retry. */
     async put(grant, value, size, deadline) {
@@ -670,7 +672,7 @@ export class BlobUploader {
         if (isByteSource(value) && value.changed)
             return "changed";
         if (!reply)
-            return "transient";
+            return { retryAfter: undefined };
         // 412: the object exists already (another upload of the same value won). A success answered
         // before the whole body was written stores nothing that was sent.
         if (reply.status === 412)
@@ -680,7 +682,7 @@ export class BlobUploader {
         if (reply.status === 403)
             return reply.body.toString("utf8").includes("Request has expired") ? "expired" : "failed";
         if (reply.status >= 500 || reply.status === 408 || reply.status === 429)
-            return "transient";
+            return { retryAfter: retryAfterMillis(reply.headers) };
         return "failed";
     }
     /**

package/dist/inline-files.d.ts

@@ -21,6 +21,19 @@ export declare function literalKeys(attributes: unknown): ReadonlySet<string>;
 /** Whether a span attribute is one whose value the SDK inspects for inline media: the attributes
  * Hue's reader reads files from. */
 export declare function isMediaKey(key: string): boolean;
+/**
+ * The canonical media type of raw 16-bit PCM whose type declares its format, as Hue's reader reads
+ * one and names it: `audio/pcm;rate=<Hz>;channels=<n>` for little-endian `audio/pcm` and
+ * `audio/x-pcm`, `audio/L16;rate=<Hz>;channels=<n>` for big-endian `audio/L16`, `rate` a whole
+ * 8000 to 192000 and `channels` 1 or 2 (1 when absent). Undefined for any other type, raw PCM
+ * without a rate or with any other parameter included: Hue plays raw PCM only in a format its
+ * type declares.
+ */
+export declare function pcmMediaType(mediaType: string): string | undefined;
+/** The media type a `data:` URL's header (between `data:` and its comma) gives its file: raw PCM
+ * whose parameters declare its format as its canonical type (`pcmMediaType`), any other type
+ * without its parameters. Empty when the header names no type. */
+export declare function headerMediaType(header: string): string;
 /** An inline file's bytes, whether they were decoded from the part's text (base64 or
  * percent-escapes) rather than taken as its UTF-8, and the media type its `data:` URL names. */
 export interface InlineFileBytes {
@@ -124,10 +137,12 @@ export interface MediaValue {
 export declare function mediaIn(value: unknown, source?: string): MediaValue;
 /**
  * An attribute's recorded text read for files as Hue's reader reads that attribute: JSON by its
- * convention; metadata as JSON when it reads as an object or array, otherwise as the text itself;
- * an OpenLLMetry content as the parts list it encodes (any other content stays text); an
- * OpenInference image URL as the text itself. Undefined for text that reading finds nothing in.
- * Throws for JSON that does not parse or nests too deep.
+ * convention, text that does not parse as the text itself (a Langfuse SDK records a string input
+ * or output as it is, so a whole `data:` URL is a file); metadata as JSON when it reads as an
+ * object or array, otherwise as the text itself; an OpenLLMetry content as the parts list it
+ * encodes (any other content stays text); an OpenInference image URL as the text itself.
+ * Undefined for text that reading finds nothing in. Throws for metadata or parts JSON that does
+ * not parse.
  */
 export declare function readMediaText(key: string, text: string): MediaValue | undefined;
 /** The recorded value's text once its files are placed: its JSON text as recorded with only the
@@ -151,6 +166,8 @@ export declare function keepsPrefix(file: InlineFilePart, textual: boolean, deco
  * `client.media.resolve`, write in a `blob` or `media` part for every media type), anything else
  * as its UTF-8. */
 export declare function mediaBytes(file: InlineFilePart): InlineFileBytes;
+/** The type a file is reserved and listed under: the type its part declares, else its `data:`
+ * URL's, raw PCM whose type declares its format in its canonical form (`pcmMediaType`). */
 export declare function mediaContentType(file: InlineFilePart, decoded: Pick<InlineFileBytes, "decoded" | "urlMediaType">): string;
 export interface FileDigest {
     sha256: string;

package/dist/inline-files.js

@@ -102,6 +102,74 @@ function base64Header(header) {
     return semicolon !== -1 && `${header.slice(semicolon)};`.includes(";base64;");
 }
 const hexPair = /^[0-9A-Fa-f]{2}$/;
+/** Raw 16-bit PCM media types and the byte order of their samples, as Hue's reader names them. */
+const pcmEndian = new Map([
+    ["audio/l16", "big"],
+    ["audio/pcm", "little"],
+    ["audio/x-pcm", "little"],
+]);
+/** One media type parameter (`name=value`, the value a token or a quoted string) or an empty one,
+ * then the `;` that ends it or the end of the type (RFC 9110 section 8.3.1). */
+const pcmParameter = /[ \t]*(?:([!#$%&'*+.^_`|~0-9A-Za-z-]+)[ \t]*=[ \t]*([!#$%&'*+.^_`|~0-9A-Za-z-]+|"(?:[^"\\]|\\.)*")[ \t]*)?(;|$)/y;
+/** A whole number written in decimal digits alone, within `[min, max]`. */
+function wholeIn(value, min, max) {
+    if (value === undefined || !/^\d{1,7}$/.test(value))
+        return undefined;
+    const number = Number(value);
+    return number >= min && number <= max ? number : undefined;
+}
+/**
+ * The canonical media type of raw 16-bit PCM whose type declares its format, as Hue's reader reads
+ * one and names it: `audio/pcm;rate=<Hz>;channels=<n>` for little-endian `audio/pcm` and
+ * `audio/x-pcm`, `audio/L16;rate=<Hz>;channels=<n>` for big-endian `audio/L16`, `rate` a whole
+ * 8000 to 192000 and `channels` 1 or 2 (1 when absent). Undefined for any other type, raw PCM
+ * without a rate or with any other parameter included: Hue plays raw PCM only in a format its
+ * type declares.
+ */
+export function pcmMediaType(mediaType) {
+    if (mediaType.length > 255)
+        return undefined;
+    const endian = pcmEndian.get(mediaType.split(";", 1)[0].trim().toLowerCase());
+    if (!endian)
+        return undefined;
+    const parameters = new Map();
+    const start = mediaType.indexOf(";");
+    if (start !== -1) {
+        pcmParameter.lastIndex = start + 1;
+        for (;;) {
+            const match = pcmParameter.exec(mediaType);
+            if (!match)
+                return undefined;
+            if (match[1] !== undefined) {
+                const name = match[1].toLowerCase();
+                if (parameters.has(name))
+                    return undefined;
+                const value = match[2];
+                parameters.set(name, value.startsWith('"') ? value.slice(1, -1).replace(/\\(.)/g, "$1") : value);
+            }
+            if (match[3] === "")
+                break;
+        }
+    }
+    for (const name of parameters.keys())
+        if (name !== "rate" && name !== "channels")
+            return undefined;
+    const rate = wholeIn(parameters.get("rate"), 8_000, 192_000);
+    const channels = parameters.has("channels") ? wholeIn(parameters.get("channels"), 1, 2) : 1;
+    if (rate === undefined || channels === undefined)
+        return undefined;
+    return `${endian === "big" ? "audio/L16" : "audio/pcm"};rate=${rate};channels=${channels}`;
+}
+/** The media type a `data:` URL's header (between `data:` and its comma) gives its file: raw PCM
+ * whose parameters declare its format as its canonical type (`pcmMediaType`), any other type
+ * without its parameters. Empty when the header names no type. */
+export function headerMediaType(header) {
+    const type = header.split(";", 1)[0].trim();
+    if (!type)
+        return type;
+    const declared = header.endsWith(";base64") ? header.slice(0, -";base64".length) : header;
+    return pcmMediaType(declared) ?? type;
+}
 /** RFC 2397 data without `;base64`: percent-escaped octets, other characters as UTF-8. Undefined
  * when a `%` does not start an escape. */
 function percentDecoded(payload) {
@@ -135,7 +203,7 @@ export function inlineFileBytes(content) {
             ? Buffer.from(payload, "base64")
             : undefined;
     const header = url?.[1];
-    const mediaType = header === undefined ? undefined : header.split(";")[0].trim();
+    const mediaType = header === undefined ? undefined : headerMediaType(header);
     return {
         bytes: decoded ?? Buffer.from(content, "utf8"),
         decoded: decoded !== undefined,
@@ -143,6 +211,8 @@ export function inlineFileBytes(content) {
         ...(decoded !== undefined && !url ? { bareBase64: true } : {}),
     };
 }
+/** OpenAI's `pcm16` audio: raw 16-bit little-endian PCM, 24 kHz mono, as Hue's reader types it. */
+const PCM16 = "audio/pcm;rate=24000;channels=1";
 const audioTypes = {
     wav: "audio/wav",
     mp3: "audio/mpeg",
@@ -152,7 +222,7 @@ const audioTypes = {
     aac: "audio/aac",
     m4a: "audio/mp4",
     webm: "audio/webm",
-    pcm16: "audio/pcm",
+    pcm16: PCM16,
 };
 const documentTypes = {
     pdf: "application/pdf",
@@ -342,16 +412,18 @@ export function contentPath(part, pointer = "") {
 }
 /** A media type as a `data:` URL declares one: `type/subtype`, no parameters. */
 const declaredMediaType = /^[A-Za-z0-9][A-Za-z0-9!#$&^_.+-]*\/[A-Za-z0-9!#$&^_.+-]+$/;
-/** The media type a whole string that is a `data:` URL declares, when it declares one: such a
- * string is a file wherever it sits. A web URL, or any other text, is not. */
+/** The media type of a whole string that is a `data:` URL declaring one (`headerMediaType`): such
+ * a string is a file wherever it sits. A web URL, or any other text, is not. */
 function dataUrlType(text) {
     if (!text.startsWith("data:"))
         return undefined;
     const header = dataUrl.exec(text);
     if (!header)
         return undefined;
-    const type = header[1].split(";")[0].trim();
-    return declaredMediaType.test(type) && isMediaContentType(type) ? type : undefined;
+    const type = header[1].split(";", 1)[0].trim();
+    return declaredMediaType.test(type) && isMediaContentType(type)
+        ? headerMediaType(header[1])
+        : undefined;
 }
 /** The modality a media type implies, as Hue's reader names it. */
 export function modalityOf(mediaType) {
@@ -387,7 +459,7 @@ const audioFormats = {
     m4a: "audio/mp4",
     mp4: "audio/mp4",
     webm: "audio/webm",
-    pcm16: "audio/pcm",
+    pcm16: PCM16,
     pcm: "audio/pcm",
 };
 function audioFormatMediaType(format) {
@@ -654,17 +726,27 @@ export function mediaIn(value, source) {
 }
 /**
  * An attribute's recorded text read for files as Hue's reader reads that attribute: JSON by its
- * convention; metadata as JSON when it reads as an object or array, otherwise as the text itself;
- * an OpenLLMetry content as the parts list it encodes (any other content stays text); an
- * OpenInference image URL as the text itself. Undefined for text that reading finds nothing in.
- * Throws for JSON that does not parse or nests too deep.
+ * convention, text that does not parse as the text itself (a Langfuse SDK records a string input
+ * or output as it is, so a whole `data:` URL is a file); metadata as JSON when it reads as an
+ * object or array, otherwise as the text itself; an OpenLLMetry content as the parts list it
+ * encodes (any other content stays text); an OpenInference image URL as the text itself.
+ * Undefined for text that reading finds nothing in. Throws for metadata or parts JSON that does
+ * not parse.
  */
 export function readMediaText(key, text) {
     /** JSON text read as Hue's reader reads it: text it keeps as text holds no file. */
     const json = (parsed) => (readerParses(parsed) ? mediaIn(parsed, text) : undefined);
     switch (readingOf(key)) {
-        case "json":
-            return json(JSON.parse(text));
+        case "json": {
+            let parsed;
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch {
+                return mediaIn(text);
+            }
+            return json(parsed);
+        }
         case "metadata":
             return /^\s*[[{]/.test(text) ? json(JSON.parse(text)) : mediaIn(text);
         case "parts": {
@@ -729,8 +811,12 @@ export function mediaBytes(file) {
         return { bytes: Buffer.from(file.content, "base64"), decoded: true };
     return inlineFileBytes(file.content);
 }
+/** The type a file is reserved and listed under: the type its part declares, else its `data:`
+ * URL's, raw PCM whose type declares its format in its canonical form (`pcmMediaType`). */
 export function mediaContentType(file, decoded) {
-    return ((isMediaContentType(file.contentType) ? file.contentType : undefined) ??
+    return ((isMediaContentType(file.contentType)
+        ? (pcmMediaType(file.contentType) ?? file.contentType)
+        : undefined) ??
         (isMediaContentType(decoded.urlMediaType) ? decoded.urlMediaType : undefined) ??
         (decoded.decoded ? "application/octet-stream" : "text/plain; charset=utf-8"));
 }

package/dist/large-media.d.ts

@@ -67,7 +67,8 @@ export interface LargeMediaValue extends MediaValue {
  * An attribute's recorded text read for files as `readMediaText` reads it, its long base64 and
  * base64 `data:` URL strings read in place (see {@link skeletonOf}). Undefined for text whose JSON
  * around those strings is over the 8 Mi bound, or that reading finds nothing in. Throws for JSON
- * that does not parse.
+ * that does not parse, except text read by JSON convention that is a `data:` URL, which is read
+ * as the text itself, as `readMediaText` reads it.
  */
 export declare function readLargeMediaText(key: string, text: string, longUnits?: number): Promise<LargeMediaValue | undefined>;
 /**

package/dist/large-media.js

@@ -1,5 +1,5 @@
 import { randomBytes } from "node:crypto";
-import { MAX_INLINE_FILE_TEXT, mediaIn, placedMediaText, readerParses, readingOf, } from "./inline-files.js";
+import { headerMediaType, MAX_INLINE_FILE_TEXT, mediaIn, placedMediaText, readerParses, readingOf, } from "./inline-files.js";
 /**
  * Inline media in a value too long for the media inspection bounds (8 Mi UTF-16 code units for one
  * attribute, 16 Mi for a record), read without parsing the files out of it. A span's own attribute
@@ -218,7 +218,8 @@ async function skeletonOf(text, longUnits, held) {
  * An attribute's recorded text read for files as `readMediaText` reads it, its long base64 and
  * base64 `data:` URL strings read in place (see {@link skeletonOf}). Undefined for text whose JSON
  * around those strings is over the 8 Mi bound, or that reading finds nothing in. Throws for JSON
- * that does not parse.
+ * that does not parse, except text read by JSON convention that is a `data:` URL, which is read
+ * as the text itself, as `readMediaText` reads it.
  */
 export async function readLargeMediaText(key, text, longUnits = LONG_STRING_UNITS) {
     const reading = readingOf(key);
@@ -255,7 +256,9 @@ export async function readLargeMediaText(key, text, longUnits = LONG_STRING_UNIT
     };
     switch (reading) {
         case "json":
-            return json();
+            // No JSON text starts with `data:`: such text is the text itself, as `readMediaText` reads
+            // text that does not parse, and a whole `data:` URL is the file.
+            return text.startsWith("data:") ? whole() : json();
         case "metadata":
             return /^\s*[[{]/.test(text) ? json() : whole();
         case "parts":
@@ -408,7 +411,7 @@ export function longFileBytes(file, long) {
             ...(file.base64 ? {} : { bareBase64: true }),
             source,
         };
-    const mediaType = long.header.split(";")[0].trim();
+    const mediaType = headerMediaType(long.header);
     return {
         size: source.size,
         decoded: true,

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** Package version shared by the instrumentation scope and the export User-Agent. */
-export declare const sdkVersion = "0.19.0";
+export declare const sdkVersion = "0.19.1";

package/dist/version.js

@@ -1,3 +1,3 @@
 // Generated by scripts/write-version.mjs from package.json; do not edit by hand.
 /** Package version shared by the instrumentation scope and the export User-Agent. */
-export const sdkVersion = "0.19.0";
+export const sdkVersion = "0.19.1";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hue-run/sdk",
-  "version": "0.19.0",
+  "version": "0.19.1",
   "private": false,
   "license": "MIT",
   "publishConfig": {