@hue-run/sdk 0.8.1 → 0.9.0

package/CLI.md

@@ -42,7 +42,7 @@ project manifest are refused because managers can update ancestor locks; Python
 The generated `hue.setup.mjs` or `hue_setup.py` always selects `captureContent: false` /
 `capture_content=False`. For a supported application, setup installs the dependency and adds the
 managed import and middleware registration to the existing entrypoint; an unreferenced helper is
-not a completed integration. TypeScript uses `@hue-run/sdk@0.8.1`, `@opentelemetry/api@1.9.1` and
+not a completed integration. TypeScript uses `@hue-run/sdk@0.9.0`, `@opentelemetry/api@1.9.1` and
 `@opentelemetry/context-async-hooks@2.11.0`; Python setup uses its separately tested package pin.
 Content capture requires an ordinary account-managed key and a later explicit application decision.
 
@@ -305,7 +305,7 @@ node packages/sdk-typescript/scripts/verify-package.mjs --artifacts-dir .artifac
 # Set project to an existing supported fixture; use the same directory on resume.
 project=/absolute/path/to/supported-fixture
 node packages/sdk-typescript/scripts/verify-setup-live.mjs \
-  --archive .artifacts/typescript/hue-run-sdk-0.8.1.tgz \
+  --archive .artifacts/typescript/hue-run-sdk-0.9.0.tgz \
   --origin https://STAGING_ORIGIN \
   --project "$project" --command setup \
   --evidence .context/setup-staging-before-claim.json
@@ -316,7 +316,7 @@ the private local handoff and finish the real browser claim, then reconcile the
 
 ```sh
 node packages/sdk-typescript/scripts/verify-setup-live.mjs \
-  --archive .artifacts/typescript/hue-run-sdk-0.8.1.tgz \
+  --archive .artifacts/typescript/hue-run-sdk-0.9.0.tgz \
   --origin https://STAGING_ORIGIN \
   --project "$project" --command claim \
   --evidence .context/setup-staging-after-claim.json

package/ENVIRONMENTS.md

@@ -126,6 +126,18 @@ Hue canonicalizes valid synthetic-principal UUIDs to lowercase, and repository r
 the same before comparing immutable digests, so casing-only UUID changes reuse the stored
 version without dropping provider bindings.
 
+Each Gmail provider instance names its mailbox carrier in `configuration`
+(`GmailMailboxConfiguration`, narrowed by `kind`). `gmail_mailbox/v1` binds `messagesCollection`
+and `draftsCollection` in the simplified shape Hue's `hue.gmail.*` actions read.
+`gmail_mailbox/v2` adds `labelsCollection` and binds all three in the entity shapes the Gmail
+mirrors serve: messages may also carry `cc`, `bcc`, `htmlBody`, `snippet`, attachment metadata,
+`sizeEstimate`, `historyId` and `raw`, each draft names a `DRAFT`-labelled message, and threads
+are derived from each message's `threadId`. Only the simulation gateway serves it: the pinned
+provider-profile preflight above reports `profile_unavailable` for a `gmail_mailbox/v2`
+instance. Its `mailboxAddress` must be the synthetic owner `owner@example.test` (compared
+case-insensitively) or publication is refused, and a definition whose provider instances all use
+it may publish with `actions: []`.
+
 ```ts
 const definition = {
   kind: "repository" as const,
@@ -230,22 +242,38 @@ try {
   await spawnAgent({ env: child, mcpConfigPath: config.path });
 } finally {
   await config.dispose();
-  await environmentClient.finishRun(run.id, {
+  const finished = await environmentClient.finishRun(run.id, {
     idempotencyKey: `execution:${executionId}:completed`,
     status: "completed",
   });
+  const graceEnd = Date.parse(finished.completingUntil ?? "") || Date.now();
+  await new Promise((resolve) =>
+    setTimeout(resolve, Math.min(10_000, Math.max(0, graceEnd - Date.now()))),
+  );
+  const sealDeadline = Date.now() + 30_000;
+  let sealed = false;
+  while (Date.now() < sealDeadline) {
+    if ((await environmentClient.getRun(run.id)).status !== "open") {
+      sealed = true;
+      break;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+  if (!sealed) throw new Error("World was not sealed after its completion grace");
 }
 ```
 
 `runSimulation`, `runLocalAgent` and `hue eval` do this for you: they create the world with the
 execution, the stable key, the case span's context and the agent revision, pass the handoff as
-`context.world`, and finish before returning so telemetry is flushed and the execution completed
-afterwards. For one compatibility release `context.mcp` is the world's first MCP mirror with the
+`context.world`, and finish and wait for the seal before returning so telemetry is flushed and the
+execution completed afterwards. For one compatibility release `context.mcp` is the world's first MCP mirror with the
 world token, so an adapter that read `HUE_MCP_URL` and `HUE_MCP_TOKEN` keeps working;
 `agentEnvironment` sets those names too unless `legacyMcpVariables: false`. A gateway world binds
 no Hue-native `tools` (Hue refuses them); a world created while the gateway is off keeps its tools
 and the `hue_sim_` capability and emits a one-time `DeprecationWarning`.
 
+A refusal such as 409 `simulation_gateway_required` exposes its validated server code as `HueEnvironmentError.diagnostic`.
+
 `agentEnvironment` removes Hue control-plane credentials from the child by default: `HUE_API_KEY`,
 `HUE_MCP_KEY` and any variable whose value is a `hue_sk_`, `hue_mcp_` or `hue_attempt_`
 credential. Pass `includeHueCredentials: true` only for an agent that must call Hue's own API.
@@ -253,7 +281,9 @@ Nothing in these helpers logs the token; keep it out of your own logs and checkp
 
 Finish answers `lifecycle: "completing"` with `sealedAt: null` for a gateway world: the seal
 follows a 5 s grace so in-flight writes land, and a late finish answers 409, which the helpers
-treat as the seal they can no longer change. `getEvidence(runId, { section, bodies })` reads the
+treat as the seal they can no longer change. Completing an execution while the world is open
+returns 409, so direct clients read the run after the finish response's `completingUntil`
+until it is no longer open; the helper waits through transient failures. `getEvidence(runId, { section, bodies })` reads the
 sealed world's evaluator-only evidence (start and end state, the diff, the call ledger, coverage,
 fingerprint) with the project key; a world token can never read it. The client honors Hue's
 `Retry-After` on 429 and 503.

package/dist/client.js

@@ -40,7 +40,7 @@ function identifier(value) {
         throw new TypeError("Session/user/workspace identifiers must contain 1–4096 valid characters");
     return value;
 }
-/** A usable metadata label: a non-blank string of at most 256 characters. */
+/** A usable metadata label: non-blank, at most 256 UTF-16 code units, with no NUL or unpaired surrogate. */
 function isLabel(value) {
     return (typeof value === "string" &&
         value.trim() !== "" &&
@@ -48,18 +48,6 @@ function isLabel(value) {
         !value.includes("\u0000") &&
         value.isWellFormed());
 }
-/** A source label uses the stricter wire-safe validation without changing existing labels. */
-function isSourceLabel(value) {
-    return (typeof value === "string" &&
-        value.trim() !== "" &&
-        value.length <= 256 &&
-        !value.includes("\u0000") &&
-        value.isWellFormed());
-}
-/** A label that is also free of NUL and unpaired surrogates, which export would reject. */
-function isTextLabel(value) {
-    return isLabel(value) && !value.includes("\u0000") && value.isWellFormed();
-}
 /**
  * Runs `work` exactly once with `active` as OpenTelemetry's current context, so instrumentations
  * that use the global API parent under the Hue span. Without a registered context manager
@@ -330,11 +318,11 @@ export class HueClient {
             "gen_ai.operation.name": "execute_tool",
             "gen_ai.tool.name": name,
         };
-        const stamp = (key, value, valid = isLabel) => {
+        const stamp = (key, value) => {
             if (value === undefined)
                 return;
             // A blank or non-string label is omitted and counted; the tool call itself still runs.
-            if (valid(value))
+            if (isLabel(value))
                 attributes[key] = value;
             else if (this.enabled && !this.closed)
                 this.transport.instrumentationFailure();
@@ -342,8 +330,8 @@ export class HueClient {
         stamp("gen_ai.tool.call.id", options.callId);
         stamp("mcp.server.name", options.mcp?.name);
         stamp("mcp.server.version", options.mcp?.version);
-        stamp("hue.mcp.provider", options.mcp?.provider, isSourceLabel);
-        stamp("hue.mcp.surface", options.mcp?.surface, isSourceLabel);
+        stamp("hue.mcp.provider", options.mcp?.provider);
+        stamp("hue.mcp.surface", options.mcp?.surface);
         return this.withSpan(`execute_tool ${name}`, async ({ span }) => {
             this.setContent(span, "gen_ai.tool.call.arguments", input);
             const result = await execute();
@@ -555,7 +543,9 @@ export class HueClient {
                 const attributes = {};
                 if (label === undefined)
                     return attributes;
-                const info = options.servers?.[label];
+                const info = options.servers && Object.hasOwn(options.servers, label)
+                    ? options.servers[label]
+                    : undefined;
                 for (const [key, value] of [
                     ["mcp.server.name", info?.name ?? label],
                     ["mcp.server.version", info?.version],
@@ -630,7 +620,7 @@ export class HueClient {
             const { role, mediaType, data, name } = file;
             if (role !== "input" && role !== "attachment" && role !== "output")
                 throw new TypeError("Invalid file role");
-            if (!isTextLabel(mediaType))
+            if (!isLabel(mediaType))
                 throw new TypeError("Invalid media type");
             let sha256 = typeof file.sha256 === "string" ? file.sha256.toLowerCase() : file.sha256;
             let byteSize = file.byteSize;
@@ -673,7 +663,7 @@ export class HueClient {
             if (byteSize !== undefined)
                 attributes["hue.file.size"] = byteSize;
             if (this.captureContent && name !== undefined) {
-                if (isTextLabel(name))
+                if (isLabel(name))
                     attributes["hue.file.name"] = name;
                 else
                     this.transport.instrumentationFailure();

package/dist/environment/client.d.ts

@@ -16,12 +16,18 @@ export declare class HueEnvironmentError extends Error {
     readonly status?: number | undefined;
     /** Hue's `Retry-After` in milliseconds, bounded, when a 429 or 503 carried one. */
     readonly retryAfterMs?: number | undefined;
+    /** The server's `X-Hue-Diagnostic` code, when it is a short snake-case value. */
+    readonly diagnostic?: string | undefined;
     constructor(
     /** HTTP status when Hue answered; absent for transport, timeout or parse failure. */
     status?: number | undefined, 
     /** Hue's `Retry-After` in milliseconds, bounded, when a 429 or 503 carried one. */
-    retryAfterMs?: number | undefined);
+    retryAfterMs?: number | undefined, 
+    /** The server's `X-Hue-Diagnostic` code, when it is a short snake-case value. */
+    diagnostic?: string | undefined);
 }
+/** A connection failure or a status the client retries; seal polling continues through these. */
+export declare function isTransientEnvironmentError(error: unknown): boolean;
 /** Typed client for authored environments, isolated runs and immutable journals. */
 export declare class EnvironmentClient {
     /** Validated Hue origin. */
@@ -47,7 +53,9 @@ export declare class EnvironmentClient {
     /** Creates or recovers one fresh isolated world using a stable idempotency key. */
     createRun(input: CreateRunInput): Promise<EnvironmentRun>;
     /** Reads authoritative current or sealed world state. */
-    getRun(runId: string): Promise<{
+    getRun(runId: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<{
         id: string;
         environmentVersionId: string;
         executionId: string | null;

package/dist/environment/client.js

@@ -4,20 +4,35 @@ import { aggregateBounds, json, uuid, valueBounds } from "../evals/json.js";
 export class HueEnvironmentError extends Error {
     status;
     retryAfterMs;
+    diagnostic;
     constructor(
     /** HTTP status when Hue answered; absent for transport, timeout or parse failure. */
     status, 
     /** Hue's `Retry-After` in milliseconds, bounded, when a 429 or 503 carried one. */
-    retryAfterMs) {
+    retryAfterMs, 
+    /** The server's `X-Hue-Diagnostic` code, when it is a short snake-case value. */
+    diagnostic) {
         super(status
-            ? `Hue environment request failed (HTTP ${status})`
+            ? `Hue environment request failed (HTTP ${status}${diagnostic ? `, ${diagnostic}` : ""})`
             : "Hue environment connection or response failed");
         this.status = status;
         this.retryAfterMs = retryAfterMs;
+        this.diagnostic = diagnostic;
         this.name = "HueEnvironmentError";
     }
 }
+const DIAGNOSTIC = /^[a-z_]{1,64}$/;
+/** The response's diagnostic code, or undefined when absent or invalid. */
+function diagnosticOf(response) {
+    const value = response.headers.get("x-hue-diagnostic");
+    return value !== null && DIAGNOSTIC.test(value) ? value : undefined;
+}
 const RETRYABLE = new Set([408, 429, 500, 502, 503, 504]);
+/** A connection failure or a status the client retries; seal polling continues through these. */
+export function isTransientEnvironmentError(error) {
+    return (error instanceof HueEnvironmentError &&
+        (error.status === undefined || RETRYABLE.has(error.status)));
+}
 /** A `Retry-After` longer than this waits this long: Hue asks for a second, never minutes. */
 const MAX_RETRY_AFTER_MS = 10_000;
 const TRACEPARENT = /^00-[0-9a-f]{32}-[0-9a-f]{16}-[0-9a-f]{2}$/;
@@ -64,9 +79,10 @@ export class EnvironmentClient {
             throw new RangeError("maxAttempts must be 1–10");
         this.maxAttempts = attempts;
     }
-    async send(method, path, payload) {
+    async send(method, path, payload, options = {}) {
         let response;
         try {
+            const timeout = AbortSignal.timeout(this.timeoutMillis);
             response = await fetch(`${this.baseUrl}/api/v1${path}`, {
                 method,
                 headers: {
@@ -75,7 +91,7 @@ export class EnvironmentClient {
                 },
                 body: payload,
                 redirect: "error",
-                signal: AbortSignal.timeout(this.timeoutMillis),
+                signal: options.signal ? AbortSignal.any([options.signal, timeout]) : timeout,
             });
         }
         catch {
@@ -83,7 +99,7 @@ export class EnvironmentClient {
         }
         if (!response.ok) {
             await response.body?.cancel();
-            throw new HueEnvironmentError(response.status, response.status === 429 || response.status === 503 ? retryAfterMillis(response) : undefined);
+            throw new HueEnvironmentError(response.status, response.status === 429 || response.status === 503 ? retryAfterMillis(response) : undefined, diagnosticOf(response));
         }
         try {
             const reader = response.body?.getReader();
@@ -111,25 +127,40 @@ export class EnvironmentClient {
             throw new HueEnvironmentError();
         }
     }
-    async request(method, path, body) {
+    async request(method, path, body, options = {}) {
         // Serialize once: a body this client cannot encode is a caller error that no retry fixes.
         const payload = body === undefined
             ? undefined
             : JSON.stringify(json(Object.fromEntries(Object.entries(body).filter(([, value]) => value !== undefined)), REQUEST_BOUNDS));
         for (let attempt = 1;; attempt++) {
             try {
-                return await this.send(method, path, payload);
+                return await this.send(method, path, payload, options);
             }
             catch (error) {
                 if (!(error instanceof HueEnvironmentError))
                     throw error;
-                const recoverable = error.status === undefined || RETRYABLE.has(error.status);
-                if (!recoverable || attempt >= this.maxAttempts)
+                if (options.signal?.aborted)
+                    throw error;
+                if (!isTransientEnvironmentError(error) || attempt >= this.maxAttempts)
                     throw error;
                 // Hue's admission refusals say how long to wait; anything else backs off.
                 const backoff = Math.min(100 * 2 ** (attempt - 1), 2000);
                 const wait = error.retryAfterMs ?? backoff + Math.random() * backoff;
-                await new Promise((resolve) => setTimeout(resolve, wait));
+                await new Promise((resolve, reject) => {
+                    const timer = setTimeout(() => {
+                        options.signal?.removeEventListener("abort", abort);
+                        resolve();
+                    }, wait);
+                    const abort = () => {
+                        clearTimeout(timer);
+                        options.signal?.removeEventListener("abort", abort);
+                        reject(new HueEnvironmentError());
+                    };
+                    if (options.signal?.aborted)
+                        abort();
+                    else
+                        options.signal?.addEventListener("abort", abort, { once: true });
+                });
             }
         }
     }
@@ -194,8 +225,8 @@ export class EnvironmentClient {
         });
     }
     /** Reads authoritative current or sealed world state. */
-    async getRun(runId) {
-        const run = await this.request("GET", `/environment-runs/${uuid(runId)}`);
+    async getRun(runId, options = {}) {
+        const run = await this.request("GET", `/environment-runs/${uuid(runId)}`, undefined, options);
         return { validity: "not_assessed", coverageGap: null, ...run };
     }
     /** Record a known coverage gap with durable identity; retries reuse the exact request. */

package/dist/environment/types.d.ts

@@ -173,6 +173,35 @@ export interface EnvironmentDefinition {
 /** The extendable legacy name remains V1. Publication and runs select their
  * explicit version; provider context is validated by the authoritative server. */
 export type EnvironmentDefinitionV1 = EnvironmentDefinition;
+/** Gmail mailbox carrier holding messages and drafts in the simplified shape Hue's
+ * `hue.gmail.*` actions read. */
+export interface GmailMailboxConfigurationV1 {
+    /** Gmail mailbox configuration discriminator. */
+    kind: "gmail_mailbox/v1";
+    /** Collection containing synthetic messages. */
+    messagesCollection: string;
+    /** Collection containing synthetic drafts. */
+    draftsCollection: string;
+    /** Synthetic mailbox address. */
+    mailboxAddress: string;
+}
+/** Gmail mailbox carrier served by Hue's simulation gateway: messages, drafts and labels in the
+ * entity shapes the Gmail mirrors serve, with threads derived from each message's `threadId`. A
+ * definition whose provider instances all use it may publish with no actions. */
+export interface GmailMailboxConfigurationV2 {
+    /** Gmail mailbox configuration discriminator. */
+    kind: "gmail_mailbox/v2";
+    /** Collection containing synthetic messages. */
+    messagesCollection: string;
+    /** Collection containing synthetic drafts, each naming a `DRAFT`-labelled message. */
+    draftsCollection: string;
+    /** Collection containing synthetic labels. */
+    labelsCollection: string;
+    /** Synthetic mailbox address; Hue accepts only `owner@example.test`, in any letter case. */
+    mailboxAddress: string;
+}
+/** Either Gmail mailbox carrier, discriminated by `kind`; Hue validates both at publication. */
+export type GmailMailboxConfiguration = GmailMailboxConfigurationV1 | GmailMailboxConfigurationV2;
 /** One synthetic Gmail principal and its world-state collection bindings. */
 export interface GmailProviderInstance {
     /** Stable instance key referenced by attempt provider selection. */
@@ -182,16 +211,7 @@ export interface GmailProviderInstance {
     /** Synthetic principal UUID, canonicalized to lowercase by Hue. */
     syntheticPrincipalId: string;
     /** Versioned mapping from Gmail concepts to authored-world collections. */
-    configuration: {
-        /** Gmail mailbox configuration discriminator. */
-        kind: "gmail_mailbox/v1";
-        /** Collection containing synthetic messages. */
-        messagesCollection: string;
-        /** Collection containing synthetic drafts. */
-        draftsCollection: string;
-        /** Synthetic mailbox address. */
-        mailboxAddress: string;
-    };
+    configuration: GmailMailboxConfiguration;
 }
 /** V2 authored world with immutable provider-instance bindings. */
 export interface EnvironmentDefinitionV2 extends Omit<EnvironmentDefinition, "schemaVersion"> {

package/dist/environment.d.ts

@@ -1,4 +1,4 @@
-export { createEnvironmentClient, EnvironmentClient, HueEnvironmentError, } from "./environment/client.js";
+export { createEnvironmentClient, EnvironmentClient, HueEnvironmentError, isTransientEnvironmentError, } from "./environment/client.js";
 export type { EnvironmentClientOptions } from "./environment/client.js";
 export { bindEnvironmentTools } from "./environment/tools.js";
 export type { BindEnvironmentToolsOptions, EnvironmentTool } from "./environment/tools.js";

package/dist/environment.js

@@ -1,3 +1,3 @@
-export { createEnvironmentClient, EnvironmentClient, HueEnvironmentError, } from "./environment/client.js";
+export { createEnvironmentClient, EnvironmentClient, HueEnvironmentError, isTransientEnvironmentError, } from "./environment/client.js";
 export { bindEnvironmentTools } from "./environment/tools.js";
 export { agentEnvironment, HUE_CONTROL_PLANE_VARIABLES, isHueControlPlaneCredential, legacyMcpCapability, stripHueControlPlaneCredentials, worldHandoff, writeMcpConfig, } from "./environment/world.js";

package/dist/evals/environment-target.d.ts

@@ -91,6 +91,11 @@ export interface RunEnvironmentTargetOptions {
     onProgress?(event: EnvironmentTargetProgress): void | Promise<void>;
     target(inputs: JsonValue, context: EnvironmentTargetContext): JsonValue | undefined | Promise<JsonValue | undefined>;
 }
+/** The completion grace is five seconds; cap an unexpectedly distant timestamp and let reads
+ * force the seal after the grace. */
+export declare const MAX_GRACE_WAIT_MS = 10000;
+export declare const SEAL_POLL_MS = 250;
+export declare const SEAL_WAIT_MS = 30000;
 /** The W3C context of the case span, sent on create so the world span parents on it. The
  * flags are the span's own: an unsampled case span is not exported, and the World API must not
  * be told otherwise. */

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/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/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.9.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.9.0";

package/package.json

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