@hue-run/sdk 0.9.0 → 0.10.0

package/dist/evals.d.ts

@@ -1,9 +1,10 @@
-export { createEvaluationClient, EvaluationClient, HueApiError } from "./evals/client.js";
+export { ArtifactSizeError, createEvaluationClient, EvaluationClient, HueApiError, } from "./evals/client.js";
 export type { EvaluationClientOptions } from "./evals/client.js";
 export { runExperiment, rescore, UncertainExecutionError, OutcomeSerializationError, TargetCancelledError, TargetOutcomeUncertainError, } from "./evals/runner.js";
-export type { RunExperimentOptions, RunExperimentTargetContext, RescoreOptions, RunnerReport, } from "./evals/runner.js";
+export type { RunExperimentOptions, RunExperimentTargetContext, RescoreOptions, RunnerReport, TelemetryIssueCount, TelemetryNotAccepted, } from "./evals/runner.js";
 export { TargetResult, withFiles } from "./evals/types.js";
-export { outputContentTypes, outputFileLimits, OutputFileError, safeFilename, targetFileRoles, } from "./evals/files.js";
+export { CaseFileError, outputContentTypes, outputFileLimits, OutputFileError, safeFilename, targetFileRoles, } from "./evals/files.js";
+export type { CaseFileErrorCode } from "./evals/files.js";
 export { runSimulation } from "./evals/simulation.js";
 export type { RepositorySimulationCase, RepositorySimulationScorer, RunSimulationOptions, SimulationDefinition, SimulationProgress, SimulationReport, SimulationScenario, SimulationTargetContext, } from "./evals/simulation.js";
 export { actualAgentManifestV2, agentManifestDigestV2, attemptBaselineV2, attemptBindingRead, attemptConnectionBundleV2, attemptIdentityV2, dependencyManifestV2, dependencyProviderV2, expectedAgentManifestV2, executionManifestDigestV2, parityEvidenceV2, preflightFindingV2, preflightReportV2, prepareAttemptInputV2, projectMcpConnectionV2, secretFreeBindingV2, surfaceBindingV2, } from "./evals/attempt.js";

package/dist/evals.js

@@ -1,7 +1,7 @@
-export { createEvaluationClient, EvaluationClient, HueApiError } from "./evals/client.js";
+export { ArtifactSizeError, createEvaluationClient, EvaluationClient, HueApiError, } from "./evals/client.js";
 export { runExperiment, rescore, UncertainExecutionError, OutcomeSerializationError, TargetCancelledError, TargetOutcomeUncertainError, } from "./evals/runner.js";
 export { TargetResult, withFiles } from "./evals/types.js";
-export { outputContentTypes, outputFileLimits, OutputFileError, safeFilename, targetFileRoles, } from "./evals/files.js";
+export { CaseFileError, outputContentTypes, outputFileLimits, OutputFileError, safeFilename, targetFileRoles, } from "./evals/files.js";
 export { runSimulation } from "./evals/simulation.js";
 export { actualAgentManifestV2, agentManifestDigestV2, attemptBaselineV2, attemptBindingRead, attemptConnectionBundleV2, attemptIdentityV2, dependencyManifestV2, dependencyProviderV2, expectedAgentManifestV2, executionManifestDigestV2, parityEvidenceV2, preflightFindingV2, preflightReportV2, prepareAttemptInputV2, projectMcpConnectionV2, secretFreeBindingV2, surfaceBindingV2, } from "./evals/attempt.js";
 export { builtins, defineLocalScorer, scoreLocally } from "./evals/scorers.js";

package/dist/inline-files.d.ts

@@ -1,5 +1,9 @@
 /** Inline file content larger than this many UTF-8 bytes is exported as its digest instead. */
 export declare const INLINE_FILE_LIMIT: number;
+/** Message text one record inspects for inline files in all, in UTF-16 code units. */
+export declare const INLINE_FILE_TEXT_PER_RECORD: number;
+/** Whether an attribute is one of the recorded message attributes that can inline files. */
+export declare function isMessageKey(key: string): boolean;
 /**
  * Replaces inline files longer than {@link INLINE_FILE_LIMIT} in a recorded message attribute
  * with their SHA-256 and byte size, so a span that inlines a large file exports the file's

package/dist/inline-files.js

@@ -3,32 +3,56 @@ import { MAX_BODY_BYTES } from "./config.js";
 /** Inline file content larger than this many UTF-8 bytes is exported as its digest instead. */
 export const INLINE_FILE_LIMIT = 64 * 1024;
 const MAX_INLINE_FILE_TEXT = 8 * MAX_BODY_BYTES;
+/** Message text one record inspects for inline files in all, in UTF-16 code units. */
+export const INLINE_FILE_TEXT_PER_RECORD = 2 * MAX_INLINE_FILE_TEXT;
 /** Message attributes whose JSON can inline files: GenAI blob parts and AI SDK 6 file parts. */
 const messageKeys = new Set([
     "gen_ai.input.messages",
     "gen_ai.output.messages",
     "ai.prompt.messages",
 ]);
+/** Whether an attribute is one of the recorded message attributes that can inline files. */
+export function isMessageKey(key) {
+    return messageKeys.has(key);
+}
 /** Strict base64: alphabet characters only, padded to a multiple of four. */
 const base64 = /^[A-Za-z0-9+/]*={0,2}$/;
-const base64DataUrl = /^data:[^,]*;base64,/;
-function binaryMimeType(value) {
-    return (typeof value === "string" &&
-        !/^text\//i.test(value) &&
-        value.toLowerCase() !== "application/json");
+/** An RFC 2397 `data:` URL's media type and parameters, up to the comma before its data. */
+const dataUrl = /^data:([^;,]*)((?:;[^;,]*)*),/;
+const hexPair = /^[0-9A-Fa-f]{2}$/;
+/** RFC 2397 data without `;base64`: percent-escaped octets, other characters as UTF-8. Undefined
+ * when a `%` does not start an escape. */
+function percentDecoded(payload) {
+    // Escapes only shrink the text, so its UTF-8 length bounds the bytes.
+    const bytes = Buffer.alloc(Buffer.byteLength(payload, "utf8"));
+    let length = 0;
+    let start = 0;
+    for (let index = payload.indexOf("%"); index !== -1; index = payload.indexOf("%", start)) {
+        const hex = payload.slice(index + 1, index + 3);
+        if (!hexPair.test(hex))
+            return undefined;
+        length += bytes.write(payload.slice(start, index), length, "utf8");
+        bytes[length++] = Number.parseInt(hex, 16);
+        start = index + 3;
+    }
+    length += bytes.write(payload.slice(start), length, "utf8");
+    return bytes.subarray(0, length);
 }
 /**
- * The bytes an inline file part carries: base64 (plain or as a `data:` URL) is decoded, and
- * anything else, such as a text file's content, is taken as UTF-8.
+ * The bytes an inline file part carries, the file's own bytes whatever its media type: a `data:`
+ * URL decoded by its own encoding (base64 with `;base64`, percent-escapes otherwise), content in
+ * the base64 alphabet decoded, and anything else, such as a text file's own text, as UTF-8. A
+ * `data:` URL whose data does not decode is taken as UTF-8 too.
  */
-function fileBytes(content, mimeType) {
-    const prefix = base64DataUrl.exec(content)?.[0].length ?? 0;
-    const payload = content.slice(prefix);
-    return (prefix > 0 || binaryMimeType(mimeType)) &&
-        payload.length % 4 === 0 &&
-        base64.test(payload)
-        ? Buffer.from(payload, "base64")
-        : Buffer.from(content, "utf8");
+function fileBytes(content) {
+    const url = dataUrl.exec(content);
+    const payload = url ? content.slice(url[0].length) : content;
+    const decoded = url && !url[2].split(";").includes("base64")
+        ? percentDecoded(payload)
+        : payload.length % 4 === 0 && base64.test(payload)
+            ? Buffer.from(payload, "base64")
+            : undefined;
+    return decoded ?? Buffer.from(content, "utf8");
 }
 /** The key holding a part's inline content: GenAI `blob` parts and AI SDK 6 `file` parts. */
 function contentKey(part) {
@@ -44,9 +68,8 @@ function hashNode(value, state, depth) {
     const part = value;
     const key = contentKey(part);
     const inline = key === undefined ? undefined : part[key];
-    const mimeType = part.mime_type ?? part.mediaType;
     if (key !== undefined && typeof inline === "string") {
-        const bytes = fileBytes(inline, mimeType);
+        const bytes = fileBytes(inline);
         if (bytes.byteLength > INLINE_FILE_LIMIT) {
             const { [key]: _omitted, ...rest } = part;
             state.changed = true;

package/dist/snapshot.d.ts

@@ -1,11 +1,11 @@
 import type { ReadableSpan } from "@opentelemetry/sdk-trace";
 import type { ReadableLogRecord, ReadWriteLogRecord } from "@opentelemetry/sdk-logs";
-export declare function snapshotSpan(source: ReadableSpan, limit: number): {
+export declare function snapshotSpan(source: ReadableSpan, limit: number, captureContent?: boolean): {
     record: ReadableSpan;
     bytes: number;
     unresolvedResource: boolean;
 };
-export declare function snapshotLog(source: ReadableLogRecord, limit: number): {
+export declare function snapshotLog(source: ReadableLogRecord, limit: number, captureContent?: boolean): {
     record: ReadWriteLogRecord;
     bytes: number;
     unresolvedResource: boolean;

package/dist/snapshot.js

@@ -1,6 +1,7 @@
 import { createTraceState } from "@opentelemetry/api";
 import { types as utilTypes } from "node:util";
 import { resourceFromAttributes } from "@opentelemetry/resources";
+import { hashInlineFiles, INLINE_FILE_LIMIT, INLINE_FILE_TEXT_PER_RECORD, isMessageKey, } from "./inline-files.js";
 // Intrinsic accessors are captured once and invoked with an explicit receiver so a
 // hostile object cannot override them; the unbound reference is the point.
 // eslint-disable-next-line @typescript-eslint/unbound-method
@@ -10,20 +11,52 @@ const typedArraySet = Uint8Array.prototype.set;
 /** Copies only exported data, with the same finite budget used for admission. */
 class Snapshot {
     limit;
+    captureContent;
     bytes = 512;
     unresolvedResource = false;
     nodes = 0;
     ancestors = new Set();
     copied = new Map();
-    constructor(limit) {
+    hashed = new Map();
+    inspected = 0;
+    /** In metadata-only mode the recorded messages, which export strips, are not copied at all. */
+    constructor(limit, captureContent = true) {
         this.limit = limit;
+        this.captureContent = captureContent;
     }
     charge(bytes) {
         this.bytes += bytes;
         if (this.bytes > this.limit)
             throw new RangeError("Telemetry byte budget exceeded");
     }
-    copy(value, depth = 0) {
+    /**
+     * An attribute map. A large inline file in a message attribute shrinks to its digest before it
+     * is charged: export replaces it anyway, and charging the file could drop the whole record.
+     */
+    attributes(value) {
+        return this.copy(value, 1, "attributes");
+    }
+    /** A message attribute with its large inline files hashed. The same text is hashed once per
+     * record, and a record inspects at most {@link INLINE_FILE_TEXT_PER_RECORD} of it in all;
+     * beyond that, messages are charged as recorded. */
+    inlineFiles(key, value) {
+        // A UTF-16 unit is at most three UTF-8 bytes, so shorter text cannot hold a file to hash.
+        if (typeof value !== "string" || !isMessageKey(key) || value.length * 3 <= INLINE_FILE_LIMIT)
+            return value;
+        if (this.hashed.has(value))
+            return this.hashed.get(value);
+        if (this.inspected + value.length > INLINE_FILE_TEXT_PER_RECORD)
+            return value;
+        this.inspected += value.length;
+        const result = hashInlineFiles(key, value);
+        this.hashed.set(value, result);
+        return result;
+    }
+    /** Span events, whose attributes are attribute maps. */
+    events(value) {
+        return this.copy(value, 1, "events");
+    }
+    copy(value, depth = 0, shape = "value") {
         if (++this.nodes > 16384 || depth > 32)
             throw new RangeError("Telemetry complexity limit exceeded");
         this.charge(16);
@@ -69,7 +102,7 @@ class Snapshot {
                 const descriptor = Object.getOwnPropertyDescriptor(value, index);
                 if (descriptor && !("value" in descriptor))
                     throw new TypeError("Telemetry accessors are unsupported");
-                copy.push(this.copy(descriptor?.value, depth + 1));
+                copy.push(this.copy(descriptor?.value, depth + 1, shape === "events" ? "event" : "value"));
             }
         }
         else {
@@ -79,8 +112,10 @@ class Snapshot {
                 const descriptor = Object.getOwnPropertyDescriptor(value, key);
                 if (!descriptor || !("value" in descriptor))
                     throw new TypeError("Telemetry accessors are unsupported");
+                if (shape === "attributes" && !this.captureContent && isMessageKey(key))
+                    continue;
                 this.charge(key.length * 2 + 16);
-                copy[key] = this.copy(descriptor.value, depth + 1);
+                copy[key] = this.copy(shape === "attributes" ? this.inlineFiles(key, descriptor.value) : descriptor.value, depth + 1, shape === "event" && key === "attributes" ? "attributes" : "value");
             }
         }
         this.ancestors.delete(value);
@@ -126,14 +161,14 @@ class Snapshot {
 function contextReader(context) {
     return () => context;
 }
-export function snapshotSpan(source, limit) {
-    const snapshot = new Snapshot(limit);
+export function snapshotSpan(source, limit, captureContent = true) {
+    const snapshot = new Snapshot(limit, captureContent);
     const context = snapshot.context(source.spanContext());
     if (source.links.length > 16384)
         throw new RangeError("Link complexity limit exceeded");
     const links = source.links.map((link) => ({
         context: snapshot.context(link.context),
-        attributes: snapshot.copy(link.attributes),
+        attributes: snapshot.attributes(link.attributes),
         droppedAttributesCount: snapshot.copy(link.droppedAttributesCount),
     }));
     const record = {
@@ -145,13 +180,13 @@ export function snapshotSpan(source, limit) {
             duration: source.duration,
             ended: source.ended,
             status: source.status,
-            attributes: source.attributes,
-            events: source.events,
             instrumentationScope: source.instrumentationScope,
             droppedAttributesCount: source.droppedAttributesCount,
             droppedEventsCount: source.droppedEventsCount,
             droppedLinksCount: source.droppedLinksCount,
         }),
+        attributes: snapshot.attributes(source.attributes),
+        events: snapshot.events(source.events),
         spanContext: contextReader(context),
         parentSpanContext: snapshot.context(source.parentSpanContext),
         links,
@@ -159,8 +194,8 @@ export function snapshotSpan(source, limit) {
     };
     return { record, bytes: snapshot.bytes, unresolvedResource: snapshot.unresolvedResource };
 }
-export function snapshotLog(source, limit) {
-    const snapshot = new Snapshot(limit);
+export function snapshotLog(source, limit, captureContent = true) {
+    const snapshot = new Snapshot(limit, captureContent);
     // Only our batching processor sees this copy. Its writer methods deliberately
     // cannot mutate the admitted snapshot or invalidate its charged byte count.
     const record = {
@@ -171,10 +206,10 @@ export function snapshotLog(source, limit) {
             severityNumber: source.severityNumber,
             eventName: source.eventName,
             body: source.body,
-            attributes: source.attributes,
             instrumentationScope: source.instrumentationScope,
             droppedAttributesCount: source.droppedAttributesCount,
         }),
+        attributes: snapshot.attributes(source.attributes),
         spanContext: snapshot.context(source.spanContext),
         resource: snapshot.resource(source.resource),
         setAttribute() {

package/dist/transport.js

@@ -191,8 +191,8 @@ export class HueTransport {
             const remaining = (advisory ? this.options.maxQueueBytes / 4 : this.options.maxQueueBytes) -
                 this.pendingBytes;
             const snapshot = signal === "traces"
-                ? snapshotSpan(record, remaining)
-                : snapshotLog(record, remaining);
+                ? snapshotSpan(record, remaining, this.options.captureContent)
+                : snapshotLog(record, remaining, this.options.captureContent);
             this.pendingBytes += snapshot.bytes;
             if (signal === "traces")
                 this.spans.set(snapshot.record, snapshot.bytes);

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.9.0";
+export declare const sdkVersion = "0.10.0";

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.9.0";
+export const sdkVersion = "0.10.0";

package/package.json

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