@hue-run/sdk 0.8.1 → 0.10.0

package/dist/evals/verdicts.d.ts

@@ -35,6 +35,11 @@ export interface VerdictResult {
     explanation: string | null;
     /** Scorer failure for `state: "error"`, otherwise `null`. */
     error: TypedError | null;
+    /** Whether Hue recorded that the evaluator does not apply to the case; such a result counts as
+     * neither a pass nor a failure. Absent means false. */
+    notApplicable?: boolean;
+    /** What a not-applicable evaluator needs that the case lacks, such as `outcome_criteria`. */
+    requires?: string;
 }
 /** Outcome of {@link waitForResults}. */
 export interface VerdictResults {
@@ -65,10 +70,15 @@ export interface CaseVerdict {
     externalKey: string;
     /** Subject scored for the case, or `null` before completion. */
     subjectId: string | null;
-    /** `passed` and `failed` are scored verdicts; `error`, `skipped` and `pending` carry no verdict. */
+    /** `passed` and `failed` are scored verdicts; `error`, `skipped` and `pending` carry no verdict.
+     * Only the evaluators that apply to the case decide it; one where none applies is an error. */
     state: "passed" | "failed" | "error" | "skipped" | "pending";
-    /** True only for `state: "passed"`: every scored metric passed and no pin errored or is missing. */
+    /** True only for `state: "passed"`: every scored metric of an applicable pin passed and no
+     * applicable pin errored or is missing. */
     passed: boolean;
+    /** Pinned scorer versions Hue recorded as not applicable to the case; always set by
+     * {@link summarizeVerdicts}. */
+    notApplicable?: string[];
     /** Reported metrics across pinned scorers, in result order. */
     metrics: (Metric & {
         /** Scorer version that reported the metric. */
@@ -97,6 +107,9 @@ export interface VerdictSummary {
         skipped: number;
         /** Cases still missing a result. */
         pending: number;
+        /** Results of evaluators that do not apply to their case, a case can have several; always
+         * set by {@link summarizeVerdicts}. */
+        notApplicable?: number;
     };
 }
 /** Whether one reported metric counts as passing: an explicit `passed`, else a true boolean. */

package/dist/evals/verdicts.js

@@ -66,6 +66,10 @@ export async function waitForResults(client, options) {
                     if (!id)
                         continue;
                     const stored = await client.getResult(id);
+                    // Only Hue's own flag on a skipped result marks it not applicable; the evidence alone
+                    // never does, and a scored or errored result keeps its verdict whatever it carries.
+                    const notApplicable = stored.state === "skipped" && stored.notApplicable === true;
+                    const evidence = stored.evidence;
                     results.push({
                         id: stored.id,
                         itemId: stored.itemId,
@@ -75,6 +79,10 @@ export async function waitForResults(client, options) {
                         metrics: stored.state === "scored" ? stored.metrics : [],
                         explanation: stored.explanation ?? null,
                         error: stored.error ?? null,
+                        notApplicable,
+                        ...(notApplicable && typeof evidence?.requires === "string"
+                            ? { requires: evidence.requires }
+                            : {}),
                     });
                 }
             return { complete, items, results };
@@ -105,11 +113,16 @@ export function summarizeVerdicts(results, options) {
         const subjectId = subjectByCase.get(item.id) ?? null;
         const own = subjectId ? results.results.filter((result) => result.subjectId === subjectId) : [];
         const metrics = own.flatMap((result) => result.metrics.map((metric) => ({ ...metric, scorerVersionId: result.scorerVersionId })));
-        const errors = own.filter((result) => result.state === "error");
-        const scored = own.filter((result) => result.state === "scored");
+        // An evaluator that does not apply to the case neither passes nor fails it.
+        const skippedAsInapplicable = (result) => result.state === "skipped" && result.notApplicable === true;
+        const inapplicable = own.filter(skippedAsInapplicable);
+        const applicable = own.filter((result) => !skippedAsInapplicable(result));
+        const errors = applicable.filter((result) => result.state === "error");
+        const scored = applicable.filter((result) => result.state === "scored");
         const failing = scored.filter((result) => !result.metrics.every(metricPassed));
         const missing = [...pins].some((pin) => !own.some((result) => result.scorerVersionId === pin));
-        const state = errors.length
+        const noneApplies = !missing && own.length > 0 && !applicable.length;
+        const state = errors.length || noneApplies
             ? "error"
             : failing.length
                 ? "failed"
@@ -118,23 +131,44 @@ export function summarizeVerdicts(results, options) {
                     : scored.length
                         ? "passed"
                         : "skipped";
+        const requires = [
+            ...new Set(inapplicable.flatMap((result) => (result.requires ? [result.requires] : []))),
+        ];
         return {
             caseId: item.id,
             externalKey: item.externalKey,
             subjectId,
             state,
             passed: state === "passed",
+            notApplicable: inapplicable.map((result) => result.scorerVersionId),
             metrics,
-            explanations: own
-                .filter((result) => result.state !== "scored" || failing.includes(result))
-                .map((result) => result.explanation)
-                .filter((explanation) => !!explanation),
+            explanations: [
+                ...(noneApplies
+                    ? [
+                        `No pinned evaluator applies to this case${requires.length ? ` (they need ${requires.join(" or ")})` : ""}; pin one that grades it`,
+                    ]
+                    : []),
+                ...applicable
+                    .filter((result) => result.state !== "scored" || failing.includes(result))
+                    .map((result) => result.explanation)
+                    .filter((explanation) => !!explanation),
+            ],
             errors: errors.map((result) => result.error?.type ?? "ScorerError"),
         };
     });
-    const totals = { cases: cases.length, passed: 0, failed: 0, error: 0, skipped: 0, pending: 0 };
-    for (const item of cases)
+    const totals = {
+        cases: cases.length,
+        passed: 0,
+        failed: 0,
+        error: 0,
+        skipped: 0,
+        pending: 0,
+        notApplicable: 0,
+    };
+    for (const item of cases) {
         totals[item.state]++;
+        totals.notApplicable += item.notApplicable?.length ?? 0;
+    }
     return { cases, totals };
 }
 /** Diffs the current summary against a baseline by case key. */

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/provider-tools.js

@@ -5,6 +5,30 @@ const MAX_PROVIDER_SERVERS = 512;
 function isItem(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
+/** Only provider-executed tool items contribute to invalid-item diagnostics when a response is
+ * truncated; messages and reasoning are harmless response content. */
+function isProviderToolItem(provider, value) {
+    if (!isItem(value) || typeof value.type !== "string")
+        return false;
+    if (provider === "openai")
+        return (value.type === "mcp_call" ||
+            value.type === "mcp_list_tools" ||
+            value.type === "web_search_call" ||
+            value.type === "file_search_call" ||
+            value.type === "code_interpreter_call");
+    return value.type === "mcp_tool_use" || value.type === "server_tool_use";
+}
+function countProviderToolItems(provider, items, start = 0) {
+    let count = 0;
+    for (const key of Object.keys(items)) {
+        const index = Number(key);
+        if (!Number.isInteger(index) || index < start || index >= items.length || String(index) !== key)
+            continue;
+        if (isProviderToolItem(provider, items[index]))
+            count++;
+    }
+    return count;
+}
 function text(value) {
     return typeof value === "string" &&
         value.trim() !== "" &&
@@ -14,6 +38,9 @@ function text(value) {
         ? value
         : undefined;
 }
+function errorCode(value) {
+    return typeof value === "string" && /^[a-z0-9_]{1,64}$/.test(value) ? value : "error";
+}
 /** MCP arguments arrive as a JSON string; record the structure when it parses, else the text. */
 function jsonArguments(value) {
     if (typeof value !== "string")
@@ -30,7 +57,7 @@ function jsonArguments(value) {
 /** OpenAI Responses `output` items. Built-in tools are named by their kind; MCP calls by tool. */
 function openaiCalls(items, activity) {
     const count = Math.min(items.length, MAX_PROVIDER_ITEMS);
-    activity.skipped += items.length - count;
+    activity.skipped += countProviderToolItems("openai", items, count);
     for (let index = 0; index < count; index++) {
         const item = items[index];
         if (!isItem(item))
@@ -121,7 +148,7 @@ function anthropicCalls(blocks, activity) {
     const results = new Map();
     const count = Math.min(blocks.length, MAX_PROVIDER_ITEMS);
     const truncated = blocks.length > MAX_PROVIDER_ITEMS;
-    activity.skipped += blocks.length - count;
+    activity.skipped += countProviderToolItems("anthropic", blocks, count);
     for (let index = 0; index < count; index++) {
         const block = blocks[index];
         if (isItem(block) &&
@@ -152,7 +179,7 @@ function anthropicCalls(blocks, activity) {
         if (result?.is_error === true)
             errorType = "mcp_error";
         else if (isItem(content) && typeof content.type === "string" && content.type.endsWith("_error"))
-            errorType = text(content.error_code) ?? "error";
+            errorType = errorCode(content.error_code);
         activity.calls.push({
             name,
             callId,

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

package/package.json

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