@hue-run/sdk 0.10.0 → 0.11.0

package/dist/evals/types.d.ts

@@ -202,6 +202,33 @@ export type ScorerDefinition = {
     entry: "hue.conversion_outcome.v1";
     /** The seven fixed boolean metrics defined by the entry. */
     metrics: MetricDefinition[];
+} | {
+    /** Scored inside Hue using immutable world evidence; the local runner defers it. */
+    kind: "world_outcome";
+    /** v1's rubric with the destination reported as `recipient`, `thread` and `subject`. */
+    entry: "hue.conversion_outcome.v2";
+    /** The ten fixed boolean metrics defined by the entry. */
+    metrics: MetricDefinition[];
+} | {
+    /** A case's reviewed outcome assertions, scored inside Hue; the local runner defers it. */
+    kind: "world_outcome";
+    /** Pinned Hue-executed assertions evaluator. */
+    entry: "hue.outcome_assertions.v2";
+    /** `task_success` and the fixed assertion counts defined by the entry. */
+    metrics: MetricDefinition[];
+} | {
+    /** The v2 assertions plus the case's calibrated judges, scored inside Hue; the local runner
+     * defers it. */
+    kind: "world_outcome";
+    /** Pinned Hue-executed assertions-and-judges evaluator. */
+    entry: "hue.outcome_assertions.v3";
+    /** `task_success`, the assertion counts and the judge counts defined by the entry. */
+    metrics: MetricDefinition[];
+    /** The judge pin: model, template and sampling policy belong to the version. */
+    config: {
+        /** The judge every case scored by this version uses. */
+        judge: OutcomeJudgeConfig;
+    };
 } | {
     /** Scored by a person in Hue; the local runner defers it. */
     kind: "manual";
@@ -215,6 +242,23 @@ export type ScorerDefinition = {
     /** Metrics the judge reports. */
     metrics: MetricDefinition[];
 };
+/** The judge a `hue.outcome_assertions.v3` version pins. */
+export interface OutcomeJudgeConfig {
+    /** A provider-prefixed model id, such as `anthropic/claude-fable-5.1`. */
+    model: string;
+    /** The model's provider. */
+    provider: string;
+    /** SHA-256 hex digest of the judge template: its fixed instructions and evidence rendering. */
+    template: string;
+    /** Answers sampled per rubric item, 1–9; a majority decides. */
+    samples: number;
+    /** Sampling temperature, 0–2. */
+    temperature: number;
+    /** Output token limit per answer. */
+    maxOutputTokens: number;
+    /** Per-answer timeout in milliseconds. */
+    timeoutMs: number;
+}
 /** Configuration of a hosted judge scorer. */
 export interface JudgeConfig {
     /** Judge model identifier. */

package/dist/evals/verdicts.d.ts

@@ -16,6 +16,10 @@ export interface WaitForResultsOptions {
     pollIntervalMillis?: number;
     /** Stops waiting early; the partial state is returned with `complete: false`. */
     signal?: AbortSignal;
+    /** Pinned versions of Hue's own judges (definition kind `world_judge`), whose results Hue can
+     * mark advisory. Any evaluator can write the same evidence, so no other result is advisory.
+     * {@link collectExperimentVerdicts} reads them from the experiment. */
+    judgeScorerVersionIds?: string[];
 }
 /** One stored result joined to its evaluation item. */
 export interface VerdictResult {
@@ -40,6 +44,10 @@ export interface VerdictResult {
     notApplicable?: boolean;
     /** What a not-applicable evaluator needs that the case lacks, such as `outcome_criteria`. */
     requires?: string;
+    /** Whether Hue recorded the result as advisory, as it does for every judge today: a result of a
+     * pinned Hue judge whose evidence says `advisory: true`, not an error, and whose metrics carry
+     * no `passed`. It is shown with its verdict but never decides a case. Absent means false. */
+    advisory?: boolean;
 }
 /** Outcome of {@link waitForResults}. */
 export interface VerdictResults {
@@ -79,6 +87,9 @@ export interface CaseVerdict {
     /** Pinned scorer versions Hue recorded as not applicable to the case; always set by
      * {@link summarizeVerdicts}. */
     notApplicable?: string[];
+    /** Pinned scorer versions whose results for the case are advisory: their metrics are listed
+     * but never decide the case; always set by {@link summarizeVerdicts}. */
+    advisory?: string[];
     /** Reported metrics across pinned scorers, in result order. */
     metrics: (Metric & {
         /** Scorer version that reported the metric. */

package/dist/evals/verdicts.js

@@ -42,6 +42,7 @@ export async function waitForResults(client, options) {
         throw new RangeError("timeoutMillis must be ≥ 0");
     if (!Number.isInteger(interval) || interval < 250 || interval > 60_000)
         throw new RangeError("pollIntervalMillis must be 250–60000");
+    const judges = new Set(options.judgeScorerVersionIds ?? []);
     const wanted = options.subjectIds ? new Set(options.subjectIds) : undefined;
     const pins = [...new Set(options.scorerVersionIds)];
     const deadline = Date.now() + timeout;
@@ -70,6 +71,12 @@ export async function waitForResults(client, options) {
                     // 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;
+                    // Any evaluator can write `advisory: true` in its evidence; only Hue's own judges'
+                    // results are advisory, never as an error or with a metric that says it passed.
+                    const advisory = judges.has(stored.scorerVersionId) &&
+                        stored.state !== "error" &&
+                        evidence?.advisory === true &&
+                        !(stored.state === "scored" && stored.metrics.some((metric) => "passed" in metric));
                     results.push({
                         id: stored.id,
                         itemId: stored.itemId,
@@ -80,6 +87,7 @@ export async function waitForResults(client, options) {
                         explanation: stored.explanation ?? null,
                         error: stored.error ?? null,
                         notApplicable,
+                        advisory,
                         ...(notApplicable && typeof evidence?.requires === "string"
                             ? { requires: evidence.requires }
                             : {}),
@@ -115,14 +123,21 @@ export function summarizeVerdicts(results, options) {
         const metrics = own.flatMap((result) => result.metrics.map((metric) => ({ ...metric, scorerVersionId: result.scorerVersionId })));
         // An evaluator that does not apply to the case neither passes nor fails it.
         const skippedAsInapplicable = (result) => result.state === "skipped" && result.notApplicable === true;
+        const isAdvisory = (result) => result.advisory === true &&
+            result.state !== "error" &&
+            result.metrics.every((metric) => metric.passed === undefined);
         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");
+        // An advisory result, such as a judge's, is shown but never decides the case, as in Hue.
+        const advisory = applicable.filter(isAdvisory);
+        const deciding = applicable.filter((result) => !isAdvisory(result));
+        const errors = deciding.filter((result) => result.state === "error");
+        const scored = deciding.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 noneApplies = !missing && own.length > 0 && !applicable.length;
-        const state = errors.length || noneApplies
+        const noneDecides = !missing && applicable.length > 0 && !deciding.length;
+        const state = errors.length || noneApplies || noneDecides
             ? "error"
             : failing.length
                 ? "failed"
@@ -141,6 +156,7 @@ export function summarizeVerdicts(results, options) {
             state,
             passed: state === "passed",
             notApplicable: inapplicable.map((result) => result.scorerVersionId),
+            advisory: advisory.map((result) => result.scorerVersionId),
             metrics,
             explanations: [
                 ...(noneApplies
@@ -148,7 +164,15 @@ export function summarizeVerdicts(results, options) {
                         `No pinned evaluator applies to this case${requires.length ? ` (they need ${requires.join(" or ")})` : ""}; pin one that grades it`,
                     ]
                     : []),
-                ...applicable
+                ...(noneDecides
+                    ? [
+                        "Only advisory evaluators ran for this case, and they never decide it; pin one that grades it",
+                        ...advisory
+                            .filter((result) => result.state === "skipped")
+                            .map((result) => `An advisory evaluator skipped the case: ${result.explanation ?? "no reason given"}`),
+                    ]
+                    : []),
+                ...deciding
                     .filter((result) => result.state !== "scored" || failing.includes(result))
                     .map((result) => result.explanation)
                     .filter((explanation) => !!explanation),
@@ -203,10 +227,15 @@ export async function collectExperimentVerdicts(client, options) {
     const experiment = await client.getExperiment(options.experimentId);
     const scorerVersionIds = experiment.evaluation.scorerVersions.map((version) => version.id);
     const { experimentId: _experimentId, ...wait } = options;
+    // Hue's own judges, the only evaluators whose results can be advisory.
+    const judgeScorerVersionIds = experiment.evaluation.scorerVersions
+        .filter((version) => version.definition?.kind === "world_judge")
+        .map((version) => version.id);
     const results = await waitForResults(client, {
         ...wait,
         runId: experiment.evaluation.id,
         scorerVersionIds,
+        judgeScorerVersionIds,
     });
     const experimentItems = await allPages((after) => client.listExperimentItems(experiment.id, { after }));
     const linked = new Set(experimentItems.map((item) => item.execution?.subjectId).filter((id) => !!id));

package/dist/inline-files.js

@@ -17,8 +17,16 @@ export function isMessageKey(key) {
 }
 /** Strict base64: alphabet characters only, padded to a multiple of four. */
 const base64 = /^[A-Za-z0-9+/]*={0,2}$/;
-/** An RFC 2397 `data:` URL's media type and parameters, up to the comma before its data. */
-const dataUrl = /^data:([^;,]*)((?:;[^;,]*)*),/;
+/** An RFC 2397 `data:` URL's header, up to the comma before its data. Its `;` parameters are read
+ * in code: a pattern repeated per parameter fails on a pathological count (Node's stack overflows,
+ * Bun stops matching). */
+const dataUrl = /^data:([^,]*),/;
+/** Whether a `data:` URL header's parameters, after its media type, include `base64`. */
+function base64Header(header) {
+    const semicolon = header.indexOf(";");
+    // One `;`-separated parameter is exactly `base64`, without splitting them all.
+    return semicolon !== -1 && `${header.slice(semicolon)};`.includes(";base64;");
+}
 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. */
@@ -47,7 +55,7 @@ function percentDecoded(payload) {
 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")
+    const decoded = url && !base64Header(url[1])
         ? percentDecoded(payload)
         : payload.length % 4 === 0 && base64.test(payload)
             ? Buffer.from(payload, "base64")

package/dist/provider-tools.d.ts

@@ -1,14 +1,19 @@
 import type { HostedToolProvider } from "./types.js";
-/** One provider-executed tool call. `arguments` and `result` are content. */
+/** One provider-executed tool call. `arguments`, `result` and `errorText` are content. */
 export interface HostedToolCall {
     name: string;
     callId?: string;
+    /** 0-based position of the call's item in the response: the OpenAI `output` index or the
+     * Anthropic `content` block index. */
+    position: number;
     /** The provider's label (OpenAI `server_label`) or name (Anthropic `server_name`) for the MCP server. */
     server?: string;
     arguments?: unknown;
     result?: unknown;
     /** Low-cardinality failure marker for `error.type`; absent when the call succeeded. */
     errorType?: string;
+    /** The provider's own error text for a failed OpenAI MCP call, unscrubbed and unbounded. */
+    errorText?: string;
 }
 /** One `mcp_list_tools` result: the tools a hosted MCP server offered. */
 export interface HostedToolListing {
@@ -23,6 +28,12 @@ export interface HostedToolActivity {
     /** Items that looked like hosted calls but could not be read. */
     skipped: number;
 }
+/**
+ * A provider's error text as a failed call exports it under content capture: credentials
+ * scrubbed first, then at most 1,024 code points with `…` marking a cut, lone surrogates
+ * replaced and NUL removed. The Python SDK produces the same text.
+ */
+export declare function providerErrorDescription(value: string): string;
 /**
  * Reads the hosted tool calls out of a provider response: the `output` items of an OpenAI
  * Responses API response, or the `content` blocks of an Anthropic Messages API response. An array

package/dist/provider-tools.js

@@ -1,4 +1,5 @@
 import { MAX_CONTENT_BYTES } from "./config.js";
+import { scrubCredentialText } from "./tool-definitions.js";
 const MAX_PROVIDER_ITEMS = 128;
 const MAX_PROVIDER_DEFINITIONS = 512;
 const MAX_PROVIDER_SERVERS = 512;
@@ -19,13 +20,28 @@ function isProviderToolItem(provider, value) {
     return value.type === "mcp_tool_use" || value.type === "server_tool_use";
 }
 function countProviderToolItems(provider, items, start = 0) {
+    let keys;
+    try {
+        keys = Object.keys(items);
+    }
+    catch {
+        // A tail that cannot be listed still holds at least one item nothing could read.
+        return 1;
+    }
     let count = 0;
-    for (const key of Object.keys(items)) {
+    for (const key of keys) {
         const index = Number(key);
         if (!Number.isInteger(index) || index < start || index >= items.length || String(index) !== key)
             continue;
-        if (isProviderToolItem(provider, items[index]))
+        try {
+            if (isProviderToolItem(provider, items[index]))
+                count++;
+        }
+        catch {
+            // A tail item whose `type` cannot be read counts as skipped; the bounded prefix is still
+            // recorded, as the Python SDK does.
             count++;
+        }
     }
     return count;
 }
@@ -41,6 +57,42 @@ function text(value) {
 function errorCode(value) {
     return typeof value === "string" && /^[a-z0-9_]{1,64}$/.test(value) ? value : "error";
 }
+/** The most of a provider's error text scrubbed, and the most exported, in code points. */
+const MAX_ERROR_SCAN = 16_384;
+const MAX_ERROR_TEXT = 1_024;
+/** The first `count` code points of `text`. */
+function codePoints(text, count) {
+    let kept = "";
+    let seen = 0;
+    for (const character of text) {
+        if (seen++ === count)
+            return { text: kept, cut: true };
+        kept += character;
+    }
+    return { text: kept, cut: false };
+}
+/**
+ * A provider's error text as a failed call exports it under content capture: credentials
+ * scrubbed first, then at most 1,024 code points with `…` marking a cut, lone surrogates
+ * replaced and NUL removed. The Python SDK produces the same text.
+ */
+export function providerErrorDescription(value) {
+    const scanned = codePoints(value.toWellFormed().replaceAll("\u0000", ""), MAX_ERROR_SCAN);
+    const bounded = codePoints(scrubCredentialText(scanned.text), MAX_ERROR_TEXT);
+    return bounded.cut || scanned.cut ? `${bounded.text}…` : bounded.text;
+}
+/** An OpenAI MCP call's `error`: its text, or an error object's string `message`. */
+function errorText(value) {
+    let message;
+    try {
+        message = isItem(value) ? value.message : value;
+    }
+    catch {
+        // An error whose message cannot be read still fails its call; only the text is lost.
+        return undefined;
+    }
+    return typeof message === "string" && message.trim() !== "" ? message : undefined;
+}
 /** MCP arguments arrive as a JSON string; record the structure when it parses, else the text. */
 function jsonArguments(value) {
     if (typeof value !== "string")
@@ -59,88 +111,105 @@ function openaiCalls(items, activity) {
     const count = Math.min(items.length, MAX_PROVIDER_ITEMS);
     activity.skipped += countProviderToolItems("openai", items, count);
     for (let index = 0; index < count; index++) {
-        const item = items[index];
-        if (!isItem(item))
-            continue;
-        const callId = text(item.id);
-        switch (item.type) {
-            case "mcp_call": {
-                const name = text(item.name);
-                if (!name) {
-                    activity.skipped++;
-                    break;
-                }
-                activity.calls.push({
-                    name,
-                    callId,
-                    server: text(item.server_label),
-                    arguments: jsonArguments(item.arguments),
-                    ...(item.output !== undefined && item.output !== null ? { result: item.output } : {}),
-                    ...(item.error !== undefined && item.error !== null ? { errorType: "mcp_error" } : {}),
-                });
+        try {
+            openaiItem(items[index], index, activity);
+        }
+        catch {
+            // An item that cannot be read is skipped; the others are still recorded.
+            activity.skipped++;
+        }
+    }
+}
+function openaiItem(item, position, activity) {
+    if (!isItem(item))
+        return;
+    const callId = text(item.id);
+    switch (item.type) {
+        case "mcp_call": {
+            const name = text(item.name);
+            if (!name) {
+                activity.skipped++;
                 break;
             }
-            case "mcp_list_tools": {
-                const server = text(item.server_label);
-                if (!server || !Array.isArray(item.tools)) {
-                    activity.skipped++;
-                    break;
-                }
-                const definitions = [];
-                const definitionCount = Math.min(item.tools.length, MAX_PROVIDER_DEFINITIONS);
-                activity.skipped += item.tools.length - definitionCount;
-                for (let index = 0; index < definitionCount; index++) {
+            const failed = item.error !== undefined && item.error !== null;
+            const detail = failed ? errorText(item.error) : undefined;
+            activity.calls.push({
+                name,
+                callId,
+                position,
+                server: text(item.server_label),
+                arguments: jsonArguments(item.arguments),
+                ...(item.output !== undefined && item.output !== null ? { result: item.output } : {}),
+                ...(failed ? { errorType: "mcp_error" } : {}),
+                ...(detail !== undefined ? { errorText: detail } : {}),
+            });
+            break;
+        }
+        case "mcp_list_tools": {
+            const server = text(item.server_label);
+            if (!server || !Array.isArray(item.tools)) {
+                activity.skipped++;
+                break;
+            }
+            const definitions = [];
+            const definitionCount = Math.min(item.tools.length, MAX_PROVIDER_DEFINITIONS);
+            activity.skipped += item.tools.length - definitionCount;
+            for (let index = 0; index < definitionCount; index++) {
+                try {
                     const tool = item.tools[index];
                     if (!isItem(tool))
                         continue;
+                    // A null field is left out, as absent, so both SDKs digest the same definition.
                     definitions.push({
                         type: "function",
-                        ...(tool.name !== undefined ? { name: tool.name } : {}),
-                        ...(tool.description !== undefined ? { description: tool.description } : {}),
-                        ...(tool.input_schema !== undefined ? { parameters: tool.input_schema } : {}),
-                        ...(tool.annotations !== undefined ? { annotations: tool.annotations } : {}),
+                        ...(tool.name != null ? { name: tool.name } : {}),
+                        ...(tool.description != null ? { description: tool.description } : {}),
+                        ...(tool.input_schema != null ? { parameters: tool.input_schema } : {}),
+                        ...(tool.annotations != null ? { annotations: tool.annotations } : {}),
                     });
                 }
-                activity.listings.push({
-                    server,
-                    definitions,
-                    ...(item.error !== undefined && item.error !== null ? { errorType: "mcp_error" } : {}),
-                });
-                break;
-            }
-            case "web_search_call":
-            case "file_search_call":
-            case "code_interpreter_call": {
-                const name = item.type.slice(0, -"_call".length);
-                const failed = item.status === "failed" ? { errorType: "failed" } : {};
-                if (item.type === "web_search_call")
-                    activity.calls.push({ name, callId, arguments: item.action, ...failed });
-                else if (item.type === "file_search_call")
-                    activity.calls.push({
-                        name,
-                        callId,
-                        arguments: { queries: item.queries },
-                        ...(item.results !== undefined && item.results !== null
-                            ? { result: item.results }
-                            : {}),
-                        ...failed,
-                    });
-                else
-                    activity.calls.push({
-                        name,
-                        callId,
-                        arguments: { code: item.code, container_id: item.container_id },
-                        ...(item.outputs !== undefined && item.outputs !== null
-                            ? { result: item.outputs }
-                            : {}),
-                        ...failed,
-                    });
-                break;
+                catch {
+                    // A definition that cannot be read is skipped; the rest of the listing is kept.
+                    activity.skipped++;
+                }
             }
-            default:
-                // Messages, reasoning, approval requests and other items are not executed tools.
-                break;
+            activity.listings.push({
+                server,
+                definitions,
+                ...(item.error !== undefined && item.error !== null ? { errorType: "mcp_error" } : {}),
+            });
+            break;
         }
+        case "web_search_call":
+        case "file_search_call":
+        case "code_interpreter_call": {
+            const name = item.type.slice(0, -"_call".length);
+            const failed = item.status === "failed" ? { errorType: "failed" } : {};
+            if (item.type === "web_search_call")
+                activity.calls.push({ name, callId, position, arguments: item.action, ...failed });
+            else if (item.type === "file_search_call")
+                activity.calls.push({
+                    name,
+                    callId,
+                    position,
+                    arguments: { queries: item.queries },
+                    ...(item.results !== undefined && item.results !== null ? { result: item.results } : {}),
+                    ...failed,
+                });
+            else
+                activity.calls.push({
+                    name,
+                    callId,
+                    position,
+                    arguments: { code: item.code, container_id: item.container_id },
+                    ...(item.outputs !== undefined && item.outputs !== null ? { result: item.outputs } : {}),
+                    ...failed,
+                });
+            break;
+        }
+        default:
+            // Messages, reasoning, approval requests and other items are not executed tools.
+            break;
     }
 }
 /** Anthropic Messages `content` blocks: a use block paired with the result block that names it. */
@@ -149,47 +218,64 @@ function anthropicCalls(blocks, activity) {
     const count = Math.min(blocks.length, MAX_PROVIDER_ITEMS);
     const truncated = blocks.length > MAX_PROVIDER_ITEMS;
     activity.skipped += countProviderToolItems("anthropic", blocks, count);
+    // Each block is read once; one that cannot be read is skipped and the rest still recorded.
+    const readable = [];
     for (let index = 0; index < count; index++) {
-        const block = blocks[index];
-        if (isItem(block) &&
-            typeof block.type === "string" &&
-            block.type.endsWith("_tool_result") &&
-            typeof block.tool_use_id === "string")
-            results.set(block.tool_use_id, block);
+        try {
+            const block = blocks[index];
+            if (isItem(block) &&
+                typeof block.type === "string" &&
+                block.type.endsWith("_tool_result") &&
+                typeof block.tool_use_id === "string")
+                results.set(block.tool_use_id, block);
+            readable.push(block);
+        }
+        catch {
+            activity.skipped++;
+            readable.push(undefined);
+        }
     }
     for (let index = 0; index < count; index++) {
-        const block = blocks[index];
-        if (!isItem(block) || (block.type !== "mcp_tool_use" && block.type !== "server_tool_use"))
-            continue;
-        const name = text(block.name);
-        const callId = text(block.id);
-        if (!name) {
-            activity.skipped++;
-            continue;
+        try {
+            anthropicBlock(readable[index], index, results, truncated, activity);
         }
-        const result = callId === undefined ? undefined : results.get(callId);
-        // When the response was truncated, an unmatched use block may have its result outside the
-        // bounded prefix. Do not export it as a successful call with a missing result.
-        if (truncated && result === undefined) {
+        catch {
             activity.skipped++;
-            continue;
         }
-        const content = result?.content;
-        let errorType;
-        if (result?.is_error === true)
-            errorType = "mcp_error";
-        else if (isItem(content) && typeof content.type === "string" && content.type.endsWith("_error"))
-            errorType = errorCode(content.error_code);
-        activity.calls.push({
-            name,
-            callId,
-            ...(block.type === "mcp_tool_use" ? { server: text(block.server_name) } : {}),
-            arguments: block.input,
-            ...(content !== undefined ? { result: content } : {}),
-            ...(errorType ? { errorType } : {}),
-        });
     }
 }
+function anthropicBlock(block, position, results, truncated, activity) {
+    if (!isItem(block) || (block.type !== "mcp_tool_use" && block.type !== "server_tool_use"))
+        return;
+    const name = text(block.name);
+    const callId = text(block.id);
+    if (!name) {
+        activity.skipped++;
+        return;
+    }
+    const result = callId === undefined ? undefined : results.get(callId);
+    // When the response was truncated, an unmatched use block may have its result outside the
+    // bounded prefix. Do not export it as a successful call with a missing result.
+    if (truncated && result === undefined) {
+        activity.skipped++;
+        return;
+    }
+    const content = result?.content;
+    let errorType;
+    if (result?.is_error === true)
+        errorType = "mcp_error";
+    else if (isItem(content) && typeof content.type === "string" && content.type.endsWith("_error"))
+        errorType = errorCode(content.error_code);
+    activity.calls.push({
+        name,
+        callId,
+        position,
+        ...(block.type === "mcp_tool_use" ? { server: text(block.server_name) } : {}),
+        arguments: block.input,
+        ...(content !== undefined ? { result: content } : {}),
+        ...(errorType ? { errorType } : {}),
+    });
+}
 /**
  * Reads the hosted tool calls out of a provider response: the `output` items of an OpenAI
  * Responses API response, or the `content` blocks of an Anthropic Messages API response. An array

package/dist/safety.d.ts

@@ -1,7 +1,13 @@
 import { type Span } from "@opentelemetry/api";
 export declare function noopSpan(): Span;
 export declare function safeSpan(source: Span, failed: () => void): Span;
+/** The bounds `encodeContent` enforces while it copies a value. */
+export interface EncodeLimits {
+    bytes: number;
+    nodes: number;
+    depth: number;
+}
 /** Validate a bounded data tree without invoking toJSON or property getters. */
-export declare function encodeContent(value: unknown): string;
+export declare function encodeContent(value: unknown, limits?: EncodeLimits): string;
 /** Bounded conservative accounting for the record data retained by our queue, not total process RSS. */
 export declare function estimateRecordBytes(value: unknown, limit: number): number;