dyadic 1.8.0 → 1.8.2

package/dist/blackbox.js

@@ -26,8 +26,9 @@ const TELEMETRY = new Set(["note", "span.started", "span.ended", "stream.summary
 export const LIMITATIONS = [
     "A hash chain shows recorded events were not altered, removed or reordered afterwards; it cannot show that activity the recorder never observed did not happen.",
     "Events with basis 'reported' are what a producer outside the platform said happened; the platform did not see them.",
-    "A signature shows the holder of the signing key issued the checkpoint. Anyone holding the key (or a compromised signing service) could sign a different history; compare key ids with keys published independently.",
+    "A signature shows the holder of the signing key issued the checkpoint. Anyone holding the key (or a compromised signing service) could sign a different history; compare key ids with keys published independently. An anchor (an RFC 3161 timestamp from an outside authority) fixes the account's checkpoint log in time; a run's checkpoint is compared with that log when the bundle carries it, so one signed again later shows as a mismatch. A bundle without the log, or a log no anchor covers, can't rule a later re-signing out.",
     "Events after the last checkpoint are chained but not signed.",
+    "Whether the run had events after the bundle's last one is checked against the run's recorded head and the account's log in the bundle; both come from the same server. Ask the platform for the run's current head to be sure.",
     "Timestamps come from the clock named in each event; clocks can be wrong or skewed.",
     "Analysis in the bundle (graph, findings) is not covered by any signature and is interpretation, not evidence.",
 ];
@@ -163,6 +164,18 @@ function canonicalText(text) {
         return null;
     }
 }
+/** A whole number from a bundle field, or `fallback` when it isn't one: a damaged or hostile bundle never crashes a check. */
+function whole(value, fallback = 0) {
+    if (typeof value === "boolean")
+        return fallback;
+    const n = Number(value);
+    return Number.isInteger(n) ? n : fallback;
+}
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+function after(later, earlier) {
+    const a = Date.parse(String(later ?? "")), b = Date.parse(String(earlier ?? ""));
+    return Number.isFinite(a) && Number.isFinite(b) && a > b;
+}
 /** The same checks as the service's and the Python SDK's verifier. `trustedKeys` maps key ids to base64 public keys. */
 export async function verifyBundle(bundle, trustedKeys) {
     const checks = [], errors = [], warnings = [];
@@ -175,11 +188,11 @@ export async function verifyBundle(bundle, trustedKeys) {
         return report(0, 0);
     }
     const runId = String(bundle.run?.id ?? ""), tenant = String(bundle.run?.tenant_ref ?? "");
-    const events = [...(bundle.events ?? [])].sort((a, b) => Number(a.seq) - Number(b.seq));
+    const events = (Array.isArray(bundle.events) ? bundle.events : []).filter(isRecord).sort((a, b) => whole(a.seq) - whole(b.seq));
     let previous = await genesis(runId), expected = 1, broken = 0;
     const envelopes = [];
     for (const item of events) {
-        const seq = Number(item.seq);
+        const seq = whole(item.seq);
         if (seq !== expected) {
             check(`event ${expected}`, false, `missing: the chain jumps from ${expected - 1} to ${seq}`);
             broken++;
@@ -213,16 +226,23 @@ export async function verifyBundle(bundle, trustedKeys) {
     }
     if (!broken)
         check("chain", true, `${envelopes.length} events, unbroken from the genesis value`);
-    const bundled = {};
-    for (const key of bundle.keys ?? [])
-        if (key?.key_id && key?.public_key)
-            bundled[key.key_id] = key.public_key;
+    const bundled = {}, retired = {};
+    for (const key of Array.isArray(bundle.keys) ? bundle.keys : []) {
+        if (!isRecord(key) || !key.key_id || typeof key.public_key !== "string")
+            continue;
+        bundled[key.key_id] = key.public_key;
+        if (key.retired_at)
+            retired[key.key_id] = String(key.retired_at);
+    }
     const keys = trustedKeys ?? bundled;
     if (!trustedKeys)
         warnings.push("No keys were given: the bundle's own keys were used, which shows only that it is consistent with itself. Compare its key ids with the keys the platform publishes.");
-    const hashes = new Map(events.map((e) => [Number(e.seq), e.hash]));
+    const hashes = new Map(events.map((e) => [whole(e.seq), e.hash]));
+    const checkpoints = (Array.isArray(bundle.checkpoints) ? bundle.checkpoints : []).filter(isRecord);
+    // The run's checkpoints whose signature verified: compared with the account's log below.
+    const valid = [];
     let sealed = 0;
-    for (const cp of bundle.checkpoints ?? []) {
+    for (const cp of checkpoints) {
         const label = `checkpoint ${cp.tenant_seq ?? "?"}`;
         const payload = canonicalText(cp.payload);
         if (payload === null) {
@@ -247,20 +267,27 @@ export async function verifyBundle(bundle, trustedKeys) {
             check(label, false, "its hash doesn't match its payload");
             continue;
         }
+        const ended = retired[String(cp.key_id)];
+        if (ended && after(payload.issued_at, ended)) {
+            check(label, false, `signed with key '${cp.key_id}' after that key was retired (${ended})`);
+            continue;
+        }
         if (payload.kind === "run" || payload.kind === "erasure") {
             if (payload.run !== runId) {
                 check(label, false, "it is about another run");
                 continue;
             }
-            if (hashes.get(Number(payload.seq)) !== payload.head) {
-                check(label, false, `it signed a different event ${payload.seq} than the bundle holds`);
+            const seq = whole(payload.seq);
+            if (hashes.get(seq) !== payload.head) {
+                check(label, false, `it signed a different event ${seq} than the bundle holds` + (seq > hashes.size ? ` (the bundle ends at event ${hashes.size}: its tail was cut off)` : ""));
                 continue;
             }
-            sealed = Math.max(sealed, Number(payload.seq));
+            sealed = Math.max(sealed, seq);
+            valid.push({ tenantSeq: whole(payload.tenant_seq), text: String(cp.payload) });
         }
         check(label, true, `${payload.kind} checkpoint signed by ${cp.key_id}, covering events 1..${payload.seq}`);
     }
-    const chain = [...(bundle.tenant_chain ?? [])].sort((a, b) => Number(a.tenant_seq) - Number(b.tenant_seq));
+    const chain = (Array.isArray(bundle.tenant_chain) ? bundle.tenant_chain : []).filter(isRecord).sort((a, b) => whole(a.tenant_seq) - whole(b.tenant_seq));
     let prior = null, chainOk = chain.length > 0;
     for (const entry of chain) {
         const payload = canonicalText(entry.payload);
@@ -271,22 +298,61 @@ export async function verifyBundle(bundle, trustedKeys) {
             chainOk = false;
             break;
         }
-        if (prior && (Number(payload.tenant_seq) !== prior.seq + 1 || payload.prev !== prior.hash)) {
+        if (prior && (whole(payload.tenant_seq) !== prior.seq + 1 || payload.prev !== prior.hash)) {
             check("tenant chain", false, `the account's checkpoint log breaks before ${payload.tenant_seq}`);
             chainOk = false;
             break;
         }
-        prior = { seq: Number(payload.tenant_seq), hash: await sha256Hex(entry.payload) };
+        prior = { seq: whole(payload.tenant_seq), hash: await sha256Hex(entry.payload) };
     }
     if (chainOk)
         check("tenant chain", true, `${chain.length} of the account's checkpoints link without a gap`);
+    // Whole, as far as anything in the bundle says: the run's recorded head, the account's log's entries about this run, and
+    // each valid checkpoint against the log's entry of its number (the same checks as the Python verifier's verify_completeness).
+    const total = events.length, last = hashes.get(total);
+    const head = isRecord(bundle.manifest) && isRecord(bundle.manifest.head) ? bundle.manifest.head : null;
+    if (head && head.seq !== undefined && head.seq !== null) {
+        const seq = whole(head.seq), digest = String(head.hash ?? "");
+        if (seq !== total || digest !== (last ?? "")) {
+            check("head", false, `the bundle says the run has ${seq} events ending in ${digest.slice(0, 12)}…; it holds ${total}` + (seq > total ? " (events after its last were cut off, or it was exported before the run ended)" : ""));
+        }
+        else
+            check("head", true, "the run's recorded head is the bundle's last event");
+    }
+    const bySeq = new Map();
+    for (const entry of chain) {
+        const payload = canonicalText(entry.payload);
+        if (payload === null)
+            continue;
+        bySeq.set(whole(payload.tenant_seq, -1), entry);
+        if (payload.run === runId && (payload.kind === "run" || payload.kind === "erasure")) {
+            const seq = whole(payload.seq);
+            if (seq > total)
+                check("tail", false, `the account's checkpoint log signed event ${seq} of this run; the bundle ends at event ${total}, so the events after it were cut off`);
+            else if (hashes.get(seq) !== payload.head)
+                check("tail", false, `the account's checkpoint log signed a different event ${seq} than the bundle holds`);
+        }
+    }
+    for (const cp of valid) {
+        const entry = bySeq.get(cp.tenantSeq);
+        if (!entry)
+            continue;
+        if ((await sha256Hex(String(entry.payload))) !== (await sha256Hex(cp.text))) {
+            check(`checkpoint ${cp.tenantSeq} in the account's log`, false, "the run's checkpoint differs from the account's log at the same number: one of them was signed again later");
+        }
+    }
+    if (!chain.length)
+        warnings.push("The account's checkpoint log isn't in the bundle: a checkpoint signed again later couldn't be told from the original, and a cut-off tail only from the run's recorded head.");
+    if (!valid.length)
+        check("signatures", false, "no valid checkpoint covers this run: nothing in the bundle is signed, so it is consistent with itself and nothing more");
     const commits = new Map();
     for (const envelope of envelopes)
         for (const ref of envelope.content ?? [])
             if (ref?.ref)
                 commits.set(ref.ref, ref.commit);
     let bad = 0;
-    for (const item of bundle.content ?? []) {
+    const content = (Array.isArray(bundle.content) ? bundle.content : []).filter(isRecord);
+    for (const item of content) {
         if (!commits.has(item.ref)) {
             check(`content ${item.ref}`, false, "no event refers to it");
             bad++;
@@ -298,13 +364,11 @@ export async function verifyBundle(bundle, trustedKeys) {
             bad++;
         }
     }
-    if ((bundle.content ?? []).length && !bad)
-        check("content", true, `${bundle.content.length} pieces match their commitments`);
-    await verifyAnchors((bundle.anchors ?? []).filter((a) => a && typeof a === "object"), chain, bundle.checkpoints ?? [], tenant, check, warnings);
+    if (content.length && !bad)
+        check("content", true, `${content.length} pieces match their commitments`);
+    await verifyAnchors((Array.isArray(bundle.anchors) ? bundle.anchors : []).filter(isRecord), chain, checkpoints, tenant, check, warnings);
     if (events.length && sealed < events.length)
         warnings.push(`Events ${sealed + 1}..${events.length} are after the last valid checkpoint: chained, not signed.`);
-    if (!checks.some((c) => c.name.startsWith("checkpoint") && c.ok))
-        warnings.push("No valid checkpoint: nothing in the bundle is signed.");
     return report(events.length, sealed);
 }
 // -- anchors: RFC 3161 timestamps over a Merkle root of checkpoint heads ------------------------------------
@@ -438,8 +502,8 @@ async function verifyAnchors(anchors, chain, checkpoints, tenant, check, warning
     const logged = new Map();
     for (const entry of chain)
         if (typeof entry?.payload === "string")
-            logged.set(Number(entry.tenant_seq ?? 0), await sha256Hex(entry.payload));
-    const sealedAt = Math.max(0, ...checkpoints.filter((c) => c && typeof c === "object").map((c) => Number(c.tenant_seq ?? 0) || 0));
+            logged.set(whole(entry.tenant_seq), await sha256Hex(entry.payload));
+    const sealedAt = Math.max(0, ...checkpoints.filter((c) => c && typeof c === "object").map((c) => whole(c.tenant_seq)));
     for (const anchor of anchors) {
         const name = `anchor at checkpoint ${anchor.tenant_seq}`;
         let seq, top, token;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export declare const VERSION = "1.8.0";
+export declare const VERSION = "1.8.2";
 export declare const DEFAULT_BASE_URL = "https://dyadic.app/api/openai/v1";
 /** The Anthropic API version the `anthropic` calls speak (sent as anthropic-version, as Anthropic's SDKs do). */
 export declare const ANTHROPIC_VERSION = "2023-06-01";
@@ -446,6 +446,8 @@ export interface RunParams {
     /** As the API names them (the same as planMode and planId). */
     plan_mode?: boolean;
     plan_id?: string;
+    /** How hard the model reasons on each step: low (the default), medium, high or max. */
+    effort?: "low" | "medium" | "high" | "max";
 }
 export interface Run {
     object: "run";
@@ -465,6 +467,8 @@ export interface Run {
         title?: string;
         url: string;
     }[];
+    /** Speech the run made (audio.generated), when any. */
+    audio?: Record<string, unknown>[];
     tools: string[];
     model: string;
     models: string[];
@@ -477,6 +481,13 @@ export interface Run {
     seconds: number;
     log_id?: string;
     followups?: string[];
+    /** Where this run is recorded: read it with blackbox.runs.retrieve(blackbox.run_id). The API run_id is the request's. */
+    blackbox?: {
+        run_id: string;
+        trace_id: string;
+    };
+    /** "content_filter" when the answer was replaced by a refusal; absent otherwise. */
+    finish_reason?: "content_filter";
     /** The plans this run made or moved, as it left them (only when it touched any). */
     plans?: {
         id: string;
@@ -520,7 +531,7 @@ export interface PlanEvent {
     id: number;
     object: "plan.event";
     plan_id: string;
-    kind: "created" | "revised" | "edited" | "approved" | "started" | "resumed" | "step" | "interrupted" | "completed" | "cancelled";
+    kind: "created" | "revised" | "edited" | "approved" | "started" | "resumed" | "step" | "interrupted" | "completed" | "cancelled" | "patched";
     type: string;
     step: string | null;
     status: string | null;
@@ -945,11 +956,13 @@ export interface BlackBoxStreamEvent<T = any> {
     id: string | null;
     data: T;
 }
+export declare const STREAM_TRUNCATED = "The stream ended before the answer finished: the connection closed with no final event.";
 /** A streamed completion: `for await (const chunk of stream)`. `text` and `usage` fill in as it goes. */
 export declare class Stream<T, U = Usage> implements AsyncIterable<T> {
     private http;
     readonly controller: AbortController;
     private onDone;
+    private idleMs;
     text: string;
     usage: U | undefined;
     /** Responses streams: the final Response once response.completed arrives. */
@@ -957,7 +970,8 @@ export declare class Stream<T, U = Usage> implements AsyncIterable<T> {
     /** Run streams: the completed run once run.completed arrives. */
     run: Run | undefined;
     readonly requestId: string;
-    constructor(http: Response, controller: AbortController, onDone?: () => void);
+    /** `idleMs`: abort the stream once nothing arrived for that long (the service sends a keep-alive every 15 s); 0 never. */
+    constructor(http: Response, controller: AbortController, onDone?: () => void, idleMs?: number);
     [Symbol.asyncIterator](): AsyncIterator<T>;
     /** Read to the end and return the whole text. */
     finalText(): Promise<string>;
@@ -1547,15 +1561,20 @@ export declare class Dyadic {
         /** OTLP/HTTP traces: an object is sent as OTLP/JSON, bytes as OTLP protobuf (application/x-protobuf; the answer is then
          * the protobuf ExportTraceServiceResponse, as Binary). */
         sendOtlp: (request: Record<string, unknown> | Uint8Array | ArrayBuffer) => Promise<Record<string, unknown>> | Promise<Binary>;
-        /** Counts for this key's runs: by status and outcome, open findings, recording gaps. */
-        overview: () => Promise<Record<string, unknown>>;
+        /** Counts for this key's runs of the last `days` (7 or 30): by status and outcome, open findings, recording gaps. Each
+         * count is what `runs.list` gives with the same filter and range. */
+        overview: (days?: 7 | 30) => Promise<Record<string, unknown>>;
         /** What the account keeps (recording, capture by kind) and for how long. */
         settings: () => Promise<Record<string, unknown>>;
         runs: {
+            /** Newest first. Filters: q, status, outcome, agent, model, tool, environment, source, since, until, severity, gaps ("1":
+             * runs whose record has a gap), cursor, limit; `next` in the result pages on. */
             list: (query?: Record<string, string | number | undefined>) => Promise<{
                 runs: BlackBoxRunSummary[];
                 next: string | null;
             }>;
+            /** The values `list` filters take for this key's runs (statuses, outcomes, agents, environments, sources). */
+            options: () => Promise<Record<string, unknown>>;
             retrieve: (id: string) => Promise<BlackBoxRunSummary>;
             /** The run's events in chain order; `types` keeps only those types (up to 20). */
             events: (id: string, query?: {
@@ -1702,6 +1721,8 @@ export declare class Dyadic {
             }[];
         }>;
         verify: (bundle: Record<string, unknown>) => Promise<VerifyReport>;
+        /** The platform API's OpenAPI description (/api/v1: runs, plans, the Black Box); `openapi()` is the OpenAI-compatible API's. */
+        openapi: () => Promise<Record<string, unknown>>;
         /** This key's runs live (server-sent events): `ready` on each connection, then a `run` event (`data`: the run's summary)
          * whenever one starts, changes status or grows. It connects again by itself and never ends on its own: leave the loop
          * or abort `signal`. */

package/dist/index.js

@@ -1,7 +1,7 @@
 // The official TypeScript SDK for the Dyadic API: Iris
 // through the OpenAI-compatible endpoints at https://dyadic.app/api/openai/v1, and beside them the Anthropic API
 // (/api/anthropic/v1) and OpenRouter's API through the AI gateway (/api/openrouter/v1).
-export const VERSION = "1.8.0";
+export const VERSION = "1.8.2";
 export const DEFAULT_BASE_URL = "https://dyadic.app/api/openai/v1";
 /** The Anthropic API version the `anthropic` calls speak (sent as anthropic-version, as Anthropic's SDKs do). */
 export const ANTHROPIC_VERSION = "2023-06-01";
@@ -78,24 +78,44 @@ export class RunDeletedError extends DyadicError {
         return found && typeof found === "object" ? found : null;
     }
 }
+const TERMINAL_EVENTS = new Set(["run.completed", "response.completed", "response.incomplete", "message_stop"]);
+export const STREAM_TRUNCATED = "The stream ended before the answer finished: the connection closed with no final event.";
 /** A streamed completion: `for await (const chunk of stream)`. `text` and `usage` fill in as it goes. */
 export class Stream {
-    constructor(http, controller, onDone = () => { }) {
+    /** `idleMs`: abort the stream once nothing arrived for that long (the service sends a keep-alive every 15 s); 0 never. */
+    constructor(http, controller, onDone = () => { }, idleMs = 0) {
         this.http = http;
         this.controller = controller;
         this.onDone = onDone;
+        this.idleMs = idleMs;
         this.text = "";
         this.requestId = http.headers.get("x-request-id") ?? "";
     }
     async *[Symbol.asyncIterator]() {
         const reader = this.http.body.getReader();
         const decoder = new TextDecoder();
-        let buffer = "", finished = false;
+        let buffer = "", finished = false, whole = false, idle = null;
+        const watch = () => { if (!this.idleMs)
+            return; clearTimeout(idle); idle = setTimeout(() => this.controller.abort(), this.idleMs); idle?.unref?.(); };
         try {
+            watch();
             for (;;) {
-                const { value, done } = await reader.read();
+                let value, done;
+                try {
+                    ({ value, done } = await reader.read());
+                }
+                catch (error) {
+                    if (error instanceof DyadicError)
+                        throw error;
+                    throw new DyadicError(`The stream dropped: ${error?.message ?? error}`, { status: 0 });
+                }
+                watch();
                 if (done) {
                     finished = true;
+                    // A stream that closes before its final event ([DONE], run.completed, response.completed/incomplete, message_stop)
+                    // was cut off: never returned as a whole answer with the text so far.
+                    if (!whole)
+                        throw new DyadicError(STREAM_TRUNCATED, { status: 0 });
                     return;
                 }
                 buffer += decoder.decode(value, { stream: true });
@@ -108,9 +128,18 @@ export class Stream {
                         continue;
                     if (data === "[DONE]") {
                         finished = true;
+                        whole = true;
                         return;
                     }
-                    const chunk = JSON.parse(data);
+                    let chunk;
+                    try {
+                        chunk = JSON.parse(data);
+                    }
+                    catch {
+                        throw new DyadicError(`The stream sent a frame that isn't JSON: ${data.slice(0, 80)}`, { status: 0 });
+                    }
+                    if (TERMINAL_EVENTS.has(chunk?.type))
+                        whole = true;
                     if (chunk.error)
                         throw new DyadicError(chunk.error.message, { status: 200, type: chunk.error.type, code: chunk.error.code, body: chunk });
                     if (chunk.type === "response.failed") {
@@ -142,6 +171,7 @@ export class Stream {
             }
         }
         finally {
+            clearTimeout(idle);
             // Leaving early (break, return, a throw) must end the request too: releasing the reader alone leaves the
             // response, and the completion it is paying for, running.
             if (!finished) {
@@ -560,12 +590,17 @@ export class Dyadic {
                 ? this.request("POST", this.platformURL("/blackbox/otlp/v1/traces"), undefined, false, { idempotent: true, content: request,
                     headers: { "Content-Type": "application/x-protobuf", Accept: "application/x-protobuf" } })
                 : this.request("POST", this.platformURL("/blackbox/otlp/v1/traces"), request, false, { idempotent: true }),
-            /** Counts for this key's runs: by status and outcome, open findings, recording gaps. */
-            overview: () => this.request("GET", this.platformURL("/blackbox/overview")),
+            /** Counts for this key's runs of the last `days` (7 or 30): by status and outcome, open findings, recording gaps. Each
+             * count is what `runs.list` gives with the same filter and range. */
+            overview: (days = 7) => this.request("GET", this.platformURL("/blackbox/overview"), undefined, false, { query: { days } }),
             /** What the account keeps (recording, capture by kind) and for how long. */
             settings: () => this.request("GET", this.platformURL("/blackbox/settings")),
             runs: {
+                /** Newest first. Filters: q, status, outcome, agent, model, tool, environment, source, since, until, severity, gaps ("1":
+                 * runs whose record has a gap), cursor, limit; `next` in the result pages on. */
                 list: (query = {}) => this.request("GET", this.platformURL("/blackbox/runs"), undefined, false, { query }),
+                /** The values `list` filters take for this key's runs (statuses, outcomes, agents, environments, sources). */
+                options: () => this.request("GET", this.platformURL("/blackbox/runs/options")),
                 retrieve: (id) => this.request("GET", this.platformURL(`/blackbox/runs/${id}`)),
                 /** The run's events in chain order; `types` keeps only those types (up to 20). */
                 events: (id, query = {}) => this.request("GET", this.platformURL(`/blackbox/runs/${id}/events`), undefined, false, { query: { after: query.after, limit: query.limit, types: Array.isArray(query.types) ? query.types.join(",") || undefined : query.types } }),
@@ -628,6 +663,8 @@ export class Dyadic {
             diff: (a, b) => this.request("GET", this.platformURL("/blackbox/diff"), undefined, false, { query: { a, b } }),
             keys: () => this.request("GET", this.platformURL("/blackbox/keys")),
             verify: (bundle) => this.request("POST", this.platformURL("/blackbox/verify"), bundle, false, { idempotent: true }),
+            /** The platform API's OpenAPI description (/api/v1: runs, plans, the Black Box); `openapi()` is the OpenAI-compatible API's. */
+            openapi: () => this.request("GET", this.platformURL("/openapi.json")),
             /** This key's runs live (server-sent events): `ready` on each connection, then a `run` event (`data`: the run's summary)
              * whenever one starts, changes status or grows. It connects again by itself and never ends on its own: leave the loop
              * or abort `signal`. */
@@ -708,8 +745,10 @@ export class Dyadic {
      * are retried on busy or failing servers; anything else only if it provably never started, unless `options.idempotent`. */
     async request(method, path, body, stream = false, options = {}) {
         const { response, controller, release } = await this.open(method, path, body, stream, options);
+        // A stream outlives a request's deadline (its headers came within it); from then on it is held to silence: the
+        // service's keep-alives (every 15 s) show it is alive. Before, a streamed run was aborted at timeoutMs whatever it did.
         if (stream)
-            return new Stream(response, controller, release);
+            return new Stream(response, controller, release, this.timeoutMs);
         try {
             const kind = (response.headers.get("content-type") ?? "").split(";")[0].trim().toLowerCase();
             if (!options.raw && (kind === "application/json" || kind.endsWith("+json")))
@@ -777,8 +816,7 @@ export class Dyadic {
                 release();
                 throw new DyadicError(`The API answered with a redirect (HTTP ${response.status}); not following it with your key.`, { status: response.status });
             }
-            if (!stream)
-                clearTimeout(timer);
+            clearTimeout(timer); // the headers arrived within the deadline; a stream's silence is watched by Stream itself
             if (response.ok)
                 return { response, controller, release };
             release();

package/package.json

@@ -1,15 +1,15 @@
-{
-  "name": "dyadic",
-  "version": "1.8.0",
-  "description": "The official TypeScript and JavaScript SDK for the Dyadic API: runs with your own agents and functions, plus the OpenAI-, Anthropic- and OpenRouter-compatible APIs.",
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": { ".": { "types": "./dist/index.d.ts", "import": "./dist/index.js" } },
-  "files": ["dist", "README.md", "CHANGELOG.md", "LICENSE"],
-  "engines": { "node": ">=18" },
-  "license": "MIT",
-  "homepage": "https://dyadic.app/developers/",
-  "scripts": { "build": "tsc", "pretest": "tsc", "test": "node --test test/client.test.js test/transport.test.js test/blackbox.test.js test/otel.test.js test/api.test.js test/live.test.js test/plans.test.js test/compatible.test.js", "test:production": "tsc && node --test live_tests/production.test.js", "prepack": "tsc" },
-  "devDependencies": { "@opentelemetry/api": "1.9.1", "@opentelemetry/sdk-trace-base": "2.12.0", "typescript": "5.6.3" }
-}
+{
+  "name": "dyadic",
+  "version": "1.8.2",
+  "description": "The official TypeScript and JavaScript SDK for the Dyadic API: runs with your own agents and functions, plus the OpenAI-, Anthropic- and OpenRouter-compatible APIs.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": { ".": { "types": "./dist/index.d.ts", "import": "./dist/index.js" } },
+  "files": ["dist", "README.md", "CHANGELOG.md", "LICENSE"],
+  "engines": { "node": ">=18" },
+  "license": "MIT",
+  "homepage": "https://dyadic.app/developers/",
+  "scripts": { "build": "tsc", "pretest": "tsc", "test": "node --test test/client.test.js test/transport.test.js test/blackbox.test.js test/otel.test.js test/api.test.js test/live.test.js test/plans.test.js test/compatible.test.js", "test:production": "tsc && node --test live_tests/production.test.js", "prepack": "tsc" },
+  "devDependencies": { "@opentelemetry/api": "1.9.1", "@opentelemetry/sdk-trace-base": "2.12.0", "typescript": "5.6.3" }
+}