@hue-run/sdk 0.8.0 → 0.9.0

package/dist/evals/environment-target.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { HueEnvironmentError } from "../environment/client.js";
+import { HueEnvironmentError, isTransientEnvironmentError, } from "../environment/client.js";
 import { bindEnvironmentTools } from "../environment/tools.js";
 import { legacyMcpCapability, worldHandoff } from "../environment/world.js";
 import { actualAgentManifestV2, attemptBaselineV2, projectMcpConnectionV2, requestedAttemptProvidersV2, validateAttemptConnectionBundleV2, } from "./attempt.js";
@@ -42,22 +42,73 @@ export function pinRequestedAttemptV2(requested, config) {
     }
     return { ...requested, expectedAgentManifestDigest: baseline.data.expectedAgentManifestDigest };
 }
-/** Confirm a seal from the authoritative run after a lost acknowledgement. */
+/** The completion grace is five seconds; cap an unexpectedly distant timestamp and let reads
+ * force the seal after the grace. */
+export const MAX_GRACE_WAIT_MS = 10_000;
+export const SEAL_POLL_MS = 250;
+export const SEAL_WAIT_MS = 30_000;
+/** Finish, then wait for the authoritative run to leave open. */
 async function seal(client, runId, executionId, status) {
+    let completingUntil;
     try {
-        await client.finishRun(runId, {
+        const finished = await client.finishRun(runId, {
             idempotencyKey: `execution:${executionId}:${status}`,
             status,
         });
+        if (finished.lifecycle === "completing")
+            completingUntil = finished.completingUntil ?? null;
     }
     catch (error) {
-        // A gateway world answers 409 once it is completing, sealed or expired: each is the
-        // outcome the caller wanted or the one it can no longer change.
+        // A gateway world answers 409 once it is completing, sealed or expired.
         const recovered = await client.getRun(runId).catch(() => undefined);
         if (recovered?.status !== status &&
             recovered?.status !== "expired" &&
             !(recovered?.status === "open" && recovered.lifecycle === "completing"))
             throw new TargetOutcomeUncertainError(executionId, { cause: error });
+        if (recovered?.status === "open")
+            completingUntil = recovered.completingUntil ?? null;
+    }
+    if (completingUntil !== undefined) {
+        try {
+            await awaitSeal(client, runId, completingUntil);
+        }
+        catch (error) {
+            throw new TargetOutcomeUncertainError(executionId, { cause: error });
+        }
+    }
+}
+/** Wait out a completing world's grace, then read until the server seals it. */
+async function awaitSeal(client, runId, completingUntil) {
+    const graceEnd = Date.parse(completingUntil ?? "");
+    let wait = Number.isFinite(graceEnd)
+        ? Math.min(Math.max(0, graceEnd - Date.now()), MAX_GRACE_WAIT_MS)
+        : 0;
+    const deadline = performance.now() + wait + SEAL_WAIT_MS;
+    for (;;) {
+        await new Promise((resolve) => setTimeout(resolve, wait));
+        const remaining = deadline - performance.now();
+        if (remaining <= 0)
+            throw new Error(`World ${runId} was not sealed after its completion grace`);
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), remaining);
+        try {
+            if ((await client.getRun(runId, { signal: controller.signal })).status !== "open")
+                return;
+        }
+        catch (error) {
+            if (!isTransientEnvironmentError(error))
+                throw error;
+            if (performance.now() >= deadline)
+                throw new Error(`World ${runId} was not sealed after its completion grace`, {
+                    cause: error,
+                });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        if (performance.now() >= deadline)
+            throw new Error(`World ${runId} was not sealed after its completion grace`);
+        wait = SEAL_POLL_MS;
     }
 }
 const deprecations = new Set();

package/dist/evals/scenarios.d.ts

@@ -10,7 +10,7 @@ export interface ScenarioPins {
     datasetId: string;
     /** Pinned dataset version; frozen only when `saved` is true. */
     datasetVersionId: string;
-    /** Pinned scorer versions; a Scenario pins exactly one. */
+    /** Pinned scorer versions; a Scenario's publication lists them, its outcome scorer first. */
     scorerVersionIds: string[];
     /** Pinned simulated-world version, or `null` when the selection does not pin one. */
     environmentVersionId: string | null;

package/dist/evals/scenarios.js

@@ -74,7 +74,10 @@ async function pinsFromScenario(client, scenario, dataset) {
         name: dataset.name,
         datasetId: scenario.publication.datasetId,
         datasetVersionId: version.id,
-        scorerVersionIds: [scenario.publication.scorerVersionId],
+        // Publications list every pin, the outcome scorer first; older ones carry the single field.
+        scorerVersionIds: scenario.publication.scorerVersionIds?.length
+            ? [...new Set(scenario.publication.scorerVersionIds)]
+            : [scenario.publication.scorerVersionId],
         environmentVersionId: scenario.publication.environmentVersionId,
         saved: version.frozenAt !== null,
         revision: version.revision,

package/dist/evals/types.d.ts

@@ -879,8 +879,13 @@ export interface CaseConversionPublication {
     environmentVersionId: string;
     /** Scorer identity of the published outcome checks. */
     scorerId: string;
-    /** Immutable scorer version pinned by the Scenario. */
+    /** Immutable scorer version pinned by the Scenario for its outcome checks. */
     scorerVersionId: string;
+    /**
+     * Every immutable scorer version the Scenario pins, `scorerVersionId` first. Absent on
+     * Scenarios published before publications listed their pins.
+     */
+    scorerVersionIds?: string[];
 }
 /** A Scenario read by {@link EvaluationClient.getCaseConversion}. Extra server fields are ignored. */
 export interface CaseConversion extends Partial<Omit<CaseConversionSummary, "id" | "status">> {

package/dist/experimental-telemetry.d.ts

@@ -2,7 +2,8 @@ import type { HueClient } from "./client.js";
 import type { ExperimentalTelemetrySettings } from "./types.js";
 /**
  * Per-call telemetry for AI SDK 6: pass as `experimental_telemetry`. Spans are created with Hue's
- * tracer, so they parent under `withSpan` and inherit session/user identifiers, and prompt/response
- * recording follows `captureContent`. AI SDK 7 applications use `hueTelemetry` from `@hue-run/sdk/ai-sdk`.
+ * tracer, so they parent under `withSpan` and inherit session, user and workspace identifiers, and
+ * prompt/response recording follows `captureContent`. AI SDK 7 applications use `hueTelemetry`
+ * from `@hue-run/sdk/ai-sdk`.
  */
 export declare function hueExperimentalTelemetry(hue: HueClient): ExperimentalTelemetrySettings;

package/dist/experimental-telemetry.js

@@ -1,7 +1,8 @@
 /**
  * Per-call telemetry for AI SDK 6: pass as `experimental_telemetry`. Spans are created with Hue's
- * tracer, so they parent under `withSpan` and inherit session/user identifiers, and prompt/response
- * recording follows `captureContent`. AI SDK 7 applications use `hueTelemetry` from `@hue-run/sdk/ai-sdk`.
+ * tracer, so they parent under `withSpan` and inherit session, user and workspace identifiers, and
+ * prompt/response recording follows `captureContent`. AI SDK 7 applications use `hueTelemetry`
+ * from `@hue-run/sdk/ai-sdk`.
  */
 export function hueExperimentalTelemetry(hue) {
     return {

package/dist/inline-files.d.ts

@@ -0,0 +1,10 @@
+/** Inline file content larger than this many UTF-8 bytes is exported as its digest instead. */
+export declare const INLINE_FILE_LIMIT: number;
+/**
+ * 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
+ * identity instead of being rejected for its size. The part keeps its other fields (`type`,
+ * `mime_type`, `modality`, `mediaType`, …). Other attributes, shorter messages and values that
+ * are not JSON are returned unchanged.
+ */
+export declare function hashInlineFiles(key: string, value: unknown): unknown;

package/dist/inline-files.js

@@ -0,0 +1,86 @@
+import { createHash } from "node:crypto";
+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 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",
+]);
+/** 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");
+}
+/**
+ * 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.
+ */
+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");
+}
+/** The key holding a part's inline content: GenAI `blob` parts and AI SDK 6 `file` parts. */
+function contentKey(part) {
+    return part.type === "blob" ? "content" : part.type === "file" ? "data" : undefined;
+}
+function hashNode(value, state, depth) {
+    if (depth > 256)
+        throw new Error("Message exceeds the supported nesting limit");
+    if (Array.isArray(value))
+        return value.map((item) => hashNode(item, state, depth + 1));
+    if (value === null || typeof value !== "object")
+        return value;
+    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);
+        if (bytes.byteLength > INLINE_FILE_LIMIT) {
+            const { [key]: _omitted, ...rest } = part;
+            state.changed = true;
+            return {
+                ...rest,
+                sha256: createHash("sha256").update(bytes).digest("hex"),
+                size: bytes.byteLength,
+            };
+        }
+    }
+    return Object.fromEntries(Object.entries(part).map(([name, item]) => [name, hashNode(item, state, depth + 1)]));
+}
+/**
+ * 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
+ * identity instead of being rejected for its size. The part keeps its other fields (`type`,
+ * `mime_type`, `modality`, `mediaType`, …). Other attributes, shorter messages and values that
+ * are not JSON are returned unchanged.
+ */
+export function hashInlineFiles(key, value) {
+    if (!messageKeys.has(key) ||
+        typeof value !== "string" ||
+        Buffer.byteLength(value, "utf8") <= INLINE_FILE_LIMIT ||
+        Buffer.byteLength(value, "utf8") > MAX_INLINE_FILE_TEXT ||
+        !(value.includes('"blob"') || value.includes('"file"')))
+        return value;
+    try {
+        const parsed = JSON.parse(value);
+        const state = { changed: false };
+        const hashed = hashNode(parsed, state, 0);
+        return state.changed ? JSON.stringify(hashed) : value;
+    }
+    catch {
+        // Not JSON, or nested too deeply to inspect: export decides the value's fate as before.
+        return value;
+    }
+}

package/dist/privacy.js

@@ -1,5 +1,8 @@
+import { SpanStatusCode } from "@opentelemetry/api";
 import { resourceFromAttributes } from "@opentelemetry/resources";
 import { MAX_BODY_BYTES, MAX_CONTENT_BYTES } from "./config.js";
+import { scrubToolCredentials, withToolCatalogSummary } from "./tool-definitions.js";
+import { hashInlineFiles } from "./inline-files.js";
 /** Attribute keys (and their dotted children) removed in metadata-only mode. */
 export const contentPrefixes = [
     "gen_ai.input.messages",
@@ -95,9 +98,16 @@ function redactValue(value, path, options, budget, depth = 0) {
     return value;
 }
 function attributes(source, options, path, budget) {
-    return Object.fromEntries(Object.entries(source).flatMap(([key, value]) => !options.captureContent && isContentKey(key)
+    // Metadata-only export summarizes the tool definitions it removes by name and digest.
+    const summarized = options.captureContent ? source : withToolCatalogSummary(source);
+    return Object.fromEntries(Object.entries(summarized).flatMap(([key, value]) => !options.captureContent && isContentKey(key)
         ? []
-        : [[key, redactValue(value, `${path}.${key}`, options, budget)]]));
+        : [
+            [
+                key,
+                redactValue(scrubToolCredentials(key, hashInlineFiles(key, value)), `${path}.${key}`, options, budget),
+            ],
+        ]));
 }
 function redactResource(resource, options, cache, budget) {
     let result = cache.get(resource);
@@ -107,8 +117,43 @@ function redactResource(resource, options, cache, budget) {
     }
     return result;
 }
+/**
+ * Server identity and failure of an AI SDK 7 provider-executed (`extension`) tool span, read from
+ * its recorded result before content is stripped. OpenAI hosted MCP results carry
+ * `{ type: "call", serverLabel, name, arguments, output?, error? }`; nothing else names the server.
+ */
+function hostedMcpCall(attributes) {
+    const result = attributes["gen_ai.tool.call.result"];
+    if (attributes["gen_ai.tool.type"] !== "extension" || typeof result !== "string")
+        return { failed: false };
+    let parsed;
+    try {
+        parsed = JSON.parse(result);
+    }
+    catch {
+        return { failed: false };
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        return { failed: false };
+    const { type, serverLabel, error } = parsed;
+    if (type !== "call")
+        return { failed: false };
+    const valid = typeof serverLabel === "string" &&
+        serverLabel.trim() !== "" &&
+        serverLabel.length <= 256 &&
+        !serverLabel.includes("\u0000") &&
+        serverLabel.isWellFormed();
+    return { ...(valid ? { serverName: serverLabel } : {}), failed: error != null };
+}
 export function redactSpan(span, options, cache) {
     const budget = { bytes: 0, nodes: 0 };
+    // Derived before metadata-only stripping so the identity survives without the result itself.
+    const hosted = hostedMcpCall(span.attributes);
+    const source = {
+        ...(hosted.serverName === undefined ? {} : { "mcp.server.name": hosted.serverName }),
+        ...(hosted.failed ? { "error.type": "mcp_error" } : {}),
+        ...span.attributes,
+    };
     return {
         name: span.name,
         kind: span.kind,
@@ -119,12 +164,16 @@ export function redactSpan(span, options, cache) {
         duration: span.duration,
         ended: span.ended,
         status: {
-            code: span.status.code,
-            ...(options.captureContent && span.status.message !== undefined
+            code: hosted.failed && span.status.code === SpanStatusCode.UNSET
+                ? SpanStatusCode.ERROR
+                : span.status.code,
+            ...(options.captureContent &&
+                span.status.message !== undefined &&
+                !(hosted.failed && span.status.code === SpanStatusCode.UNSET)
                 ? { message: String(redactValue(span.status.message, "status.message", options, budget)) }
                 : {}),
         },
-        attributes: attributes(span.attributes, options, "attributes", budget),
+        attributes: attributes(source, options, "attributes", budget),
         events: span.events
             .filter((event) => options.captureContent ||
             !/^gen_ai\.(?:system|user|assistant|tool|choice)/.test(event.name))

package/dist/provider-tools.d.ts

@@ -0,0 +1,39 @@
+import type { HostedToolProvider } from "./types.js";
+/** One provider-executed tool call. `arguments` and `result` are content. */
+export interface HostedToolCall {
+    name: string;
+    callId?: string;
+    /** 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;
+}
+/** One `mcp_list_tools` result: the tools a hosted MCP server offered. */
+export interface HostedToolListing {
+    server: string;
+    /** Tool definitions in the OpenTelemetry GenAI shape (`type`, `name`, `description`, `parameters`). */
+    definitions: Record<string, unknown>[];
+    errorType?: string;
+}
+export interface HostedToolActivity {
+    calls: HostedToolCall[];
+    listings: HostedToolListing[];
+    /** Items that looked like hosted calls but could not be read. */
+    skipped: number;
+}
+/**
+ * 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
+ * is taken as those items directly. Anything else yields no calls.
+ */
+export declare function hostedToolActivity(provider: HostedToolProvider, response: unknown): HostedToolActivity;
+/**
+ * The host of each hosted MCP server's URL, by label, read from the request that produced the
+ * response: OpenAI `tools[].server_url` by `server_label`, Anthropic `mcp_servers[].url` by `name`.
+ * Nothing else in the request is read.
+ */
+export declare function hostedServerAddresses(provider: HostedToolProvider, request: unknown): Map<string, string>;
+/** The provider a `model()` call named, when this module can read its responses. */
+export declare function hostedToolProvider(value: unknown): HostedToolProvider | undefined;

package/dist/provider-tools.js

@@ -0,0 +1,249 @@
+import { MAX_CONTENT_BYTES } from "./config.js";
+const MAX_PROVIDER_ITEMS = 128;
+const MAX_PROVIDER_DEFINITIONS = 512;
+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() !== "" &&
+        value.length <= 256 &&
+        !value.includes("\u0000") &&
+        value.isWellFormed()
+        ? 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")
+        return value;
+    if (Buffer.byteLength(value, "utf8") > MAX_CONTENT_BYTES)
+        return undefined;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return 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 += 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" } : {}),
+                });
+                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 tool = item.tools[index];
+                    if (!isItem(tool))
+                        continue;
+                    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 } : {}),
+                    });
+                }
+                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;
+            }
+            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. */
+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 += countProviderToolItems("anthropic", blocks, count);
+    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);
+    }
+    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;
+        }
+        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++;
+            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 } : {}),
+        });
+    }
+}
+/**
+ * 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
+ * is taken as those items directly. Anything else yields no calls.
+ */
+export function hostedToolActivity(provider, response) {
+    const activity = { calls: [], listings: [], skipped: 0 };
+    const items = Array.isArray(response)
+        ? response
+        : isItem(response)
+            ? response[provider === "openai" ? "output" : "content"]
+            : undefined;
+    if (!Array.isArray(items))
+        return activity;
+    if (provider === "openai")
+        openaiCalls(items, activity);
+    else
+        anthropicCalls(items, activity);
+    return activity;
+}
+/**
+ * The host of each hosted MCP server's URL, by label, read from the request that produced the
+ * response: OpenAI `tools[].server_url` by `server_label`, Anthropic `mcp_servers[].url` by `name`.
+ * Nothing else in the request is read.
+ */
+export function hostedServerAddresses(provider, request) {
+    const addresses = new Map();
+    if (!isItem(request))
+        return addresses;
+    const entries = request[provider === "openai" ? "tools" : "mcp_servers"];
+    if (!Array.isArray(entries))
+        return addresses;
+    const count = Math.min(entries.length, MAX_PROVIDER_SERVERS);
+    for (let index = 0; index < count; index++) {
+        const entry = entries[index];
+        if (!isItem(entry))
+            continue;
+        const label = text(provider === "openai" ? entry.server_label : entry.name);
+        const url = provider === "openai" ? entry.server_url : entry.url;
+        if (!label || typeof url !== "string")
+            continue;
+        try {
+            const { hostname } = new URL(url);
+            if (hostname)
+                addresses.set(label, hostname);
+        }
+        catch {
+            // Not a URL; there is no address to record.
+        }
+    }
+    return addresses;
+}
+/** The provider a `model()` call named, when this module can read its responses. */
+export function hostedToolProvider(value) {
+    const provider = typeof value === "string" ? value.toLowerCase() : undefined;
+    return provider === "openai" || provider === "anthropic" ? provider : undefined;
+}

package/dist/tool-definitions.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Removes hosted-tool credentials from an exported attribute value, before the caller's `redact`.
+ * Tool definitions come from OpenTelemetry GenAI (`gen_ai.tool.definitions`), AI SDK 6
+ * (`ai.prompt.tools`, one JSON string per tool) and OpenInference (`llm.tools.{i}.tool.json_schema`,
+ * plus the raw request in `input.value`). Other attributes, and values that are not JSON, are
+ * returned unchanged. Metadata-only export removes all of these attributes anyway.
+ *
+ * @throws Error when a tool definition is nested too deeply to inspect; the record is then
+ * rejected rather than exported with credentials.
+ */
+export declare function scrubToolCredentials(key: string, value: unknown): unknown;
+/**
+ * Metadata-only summary of the tool definitions a record carries, which export then removes:
+ * `hue.tool.names` lists each definition's name in order, and `hue.tool.definitions.sha256` is
+ * the lowercase hex SHA-256 of the RFC 8785 canonical JSON of the credential-scrubbed definition
+ * list, so the same catalog has the same digest in both SDKs and across credential rotation.
+ * Returns the source unchanged when it has no parseable definitions; attributes the source
+ * already sets are kept.
+ */
+export declare function withToolCatalogSummary<T extends Record<string, unknown>>(source: T): T;