@adaptic/utils 0.0.1032 → 0.0.1033

package/dist/index.cjs

@@ -62508,13 +62508,18 @@ const DEFAULT_PAGINATION_DELAY_MS = 300;
  */
 const MAX_ORDERS_PER_REQUEST = 500;
 /**
- * Order statuses that are considered "open"
+ * Order statuses that are considered "open".
+ *
+ * `held` is included because a held conditional leg (a bracket's stop-loss,
+ * say) is a working order resting at the broker, returned by Alpaca's own
+ * `status=open` listing and cancelable like any other open order.
  */
 const OPEN_ORDER_STATUSES = [
     "new",
     "accepted",
     "pending_new",
     "accepted_for_bidding",
+    "held",
     "partially_filled",
 ];
 /**
@@ -62522,13 +62527,15 @@ const OPEN_ORDER_STATUSES = [
  */
 const FILLED_ORDER_STATUSES = ["filled"];
 /**
- * Order statuses that can still potentially be filled
+ * Order statuses that can still potentially be filled. A `held` leg fills once
+ * its parent fills or its trigger is met.
  */
 const FILLABLE_ORDER_STATUSES = [
     "new",
     "accepted",
     "pending_new",
     "accepted_for_bidding",
+    "held",
     "partially_filled",
 ];
 /**
@@ -72336,11 +72343,35 @@ class CircuitBreakerRegistry {
      * Register that an attempt is starting, so half-open probes stay bounded.
      *
      * @param routeKey The route's stable key.
-     * @returns void
+     * @returns Whether the attempt took a half-open probe slot. A caller holding
+     *   one must end the attempt with {@link onSuccess}, {@link onFailure} or
+     *   {@link onAttemptAbandoned}, or the slot is never returned.
      */
     onAttemptStart(routeKey) {
         if (this.stateOf(routeKey) === "half-open") {
             this.recordFor(routeKey).probesInFlight += 1;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Return a half-open probe slot whose attempt ended without a verdict.
+     *
+     * A probe that never tested the provider — refused by the client's own
+     * pacing guard, cancelled by its caller, or found to be the wrong leg for the
+     * request — says nothing about whether the route has recovered, so neither a
+     * success nor a failure is recorded. The slot must still come back. Without
+     * it the half-open route admits no further probe, no probe can ever close or
+     * re-open the breaker, and the route stays excluded for the life of the
+     * process while its traffic is quietly served by the next leg.
+     *
+     * @param routeKey The route's stable key.
+     * @returns void
+     */
+    onAttemptAbandoned(routeKey) {
+        const record = this.records.get(routeKey);
+        if (record !== undefined && record.probesInFlight > 0) {
+            record.probesInFlight -= 1;
         }
     }
     /**
@@ -72611,11 +72642,13 @@ var defaults$1 = {
 var providers$1 = {
 	anthropic: {
 		basis: "conservative-default",
+		scope: "model",
+		scope_source: "https://platform.claude.com/docs/en/api/rate-limits",
 		requests_per_minute: 120,
 		max_concurrent: 12,
 		acquire_timeout_ms: 15000,
 		source: null,
-		note: "Raised 2026-09-15 after the 4-concurrent ceiling was measured starving the live equity decision path: the alias chain reported 'exhausted its fallback chain' with every leg skipped by this guard (deepinfra primary+secondary and the anthropic incumbent), 173 of 473 signal-coordination calls failed (36.6%), and decisions were lost outright. Corroborating evidence at the time: ZERO 429s observed on any provider, the engine's own global fan-out gate permits 100 concurrent with 17 active, and 877 signal-analysis calls had been admitted to that gate. Concurrency and RPM are raised TOGETHER because they bind in series - lifting max_concurrent alone would only move the bottleneck to the token bucket. STILL conservative-default, NOT published: no provider console was read for these numbers, so they remain a deliberate under-estimate of an unknown ceiling. Transcribe the real tier limits (W3-07) and set basis to published."
+		note: "The unit is per model: the scope_source states 'Rate limits are applied separately for each model; therefore you can use different models up to their respective limits simultaneously', measured as requests, input tokens and output tokens per minute for each model class, with no concurrency ceiling. Each model therefore gets its own guard, so traffic on one model class (an Opus incumbent serving background aliases) cannot refuse calls to another (the Haiku incumbent of the hot-path alias). The NUMBERS stay conservative-default: the organisation's usage tier sets the real ceilings and is read only from the Claude Console rate-limits page, which has not been transcribed. The lowest standard tier listed at the source allows 1,000 requests per minute per model; organisations with limited history can start on an evaluation tier below that, which is why these values are held well under it. Transcribe the tier's limits (W3-07) and set basis to published."
 	},
 	openai: {
 		basis: "conservative-default",
@@ -72634,12 +72667,14 @@ var providers$1 = {
 		note: "Raised 2026-09-15 after the 4-concurrent ceiling was measured starving the live equity decision path: the alias chain reported 'exhausted its fallback chain' with every leg skipped by this guard (deepinfra primary+secondary and the anthropic incumbent), 173 of 473 signal-coordination calls failed (36.6%), and decisions were lost outright. Corroborating evidence at the time: ZERO 429s observed on any provider, the engine's own global fan-out gate permits 100 concurrent with 17 active, and 877 signal-analysis calls had been admitted to that gate. Concurrency and RPM are raised TOGETHER because they bind in series - lifting max_concurrent alone would only move the bottleneck to the token bucket. STILL conservative-default, NOT published: no provider console was read for these numbers, so they remain a deliberate under-estimate of an unknown ceiling. Transcribe the real tier limits (W3-07) and set basis to published."
 	},
 	deepinfra: {
-		basis: "conservative-default",
+		basis: "published",
+		scope: "model",
 		requests_per_minute: 240,
-		max_concurrent: 24,
+		requests_per_minute_basis: "conservative-default",
+		max_concurrent: 200,
 		acquire_timeout_ms: 15000,
-		source: null,
-		note: "Raised 2026-09-15 after the 4-concurrent ceiling was measured starving the live equity decision path: the alias chain reported 'exhausted its fallback chain' with every leg skipped by this guard (deepinfra primary+secondary and the anthropic incumbent), 173 of 473 signal-coordination calls failed (36.6%), and decisions were lost outright. Corroborating evidence at the time: ZERO 429s observed on any provider, the engine's own global fan-out gate permits 100 concurrent with 17 active, and 877 signal-analysis calls had been admitted to that gate. Concurrency and RPM are raised TOGETHER because they bind in series - lifting max_concurrent alone would only move the bottleneck to the token bucket. STILL conservative-default, NOT published: no provider console was read for these numbers, so they remain a deliberate under-estimate of an unknown ceiling. Transcribe the real tier limits (W3-07) and set basis to published."
+		source: "https://docs.deepinfra.com/account/rate-limits",
+		note: "Transcribed 2026-09-23 from the source, which states 'Every account has a default limit of 200 concurrent requests per model', that two models queried simultaneously allow 400 in total (200 per model), and that 'The rate limit is on concurrent requests, not per-minute volume.' Concurrency is therefore the bound DeepInfra enforces, and it is enforced per MODEL, so each model gets its own guard at 200. One guard shared by the whole account enforced a ceiling DeepInfra does not impose, and because an alias's primary and secondary are both served from this account, it refused the secondary exactly when the primary's queue was full. DeepInfra publishes no per-minute ceiling, so requests_per_minute is the client's own pacing backstop (requests_per_minute_basis: conservative-default), keyed per model like the bound DeepInfra does enforce. Exceeding the ceiling returns HTTP 429, and a very busy model can return 429 below it. The ceiling belongs to the account and this guard to one process, so every process calling the same model through the same account shares the 200."
 	},
 	fireworks: {
 		basis: "conservative-default",
@@ -72689,7 +72724,10 @@ var limitsConfig = {
  * provider's circuit breaker, fail over to a more expensive leg, and keep doing
  * so — converting a self-inflicted pacing problem into a permanent routing
  * change nobody chose. Pacing at the client is what keeps the breaker measuring
- * the provider rather than measuring us.
+ * the provider rather than measuring us. The same reasoning bounds the guard
+ * from the other side: a client held far BELOW the provider's ceiling refuses
+ * calls the provider would have served, and the chain answers those refusals by
+ * failing over — the same unchosen routing change, arrived at by under-driving.
  *
  * Two distinct bounds are applied because they fail differently. The rate bound
  * (requests per minute) protects the provider's published ceiling. The
@@ -72698,8 +72736,18 @@ var limitsConfig = {
  * every one of them blows its latency budget and the fan-out produces a hundred
  * timeouts instead of a queue.
  *
- * Limits live in `provider-limits.json`, not here. A rate limit discovered
- * during an incident should be correctable by config, not by a release.
+ * Each guard is keyed by the unit its provider enforces limits in. A provider
+ * that publishes its ceilings per model gets one independent guard per model.
+ * Sharing one guard across its models would enforce a ceiling the provider does
+ * not impose, and — when a chain's primary and secondary are served by the same
+ * provider — would refuse the secondary at exactly the moment the primary's
+ * queue is full, so the fallback that exists for that moment is never reached.
+ *
+ * Limits live in `provider-limits.json` rather than in code, each beside the
+ * source it was transcribed from, so a published ceiling and a conservative
+ * guess can never be mistaken for one another in review. The file is bundled
+ * at build time: changing a limit is a release of this package, not a runtime
+ * switch.
  *
  * @module llm/rate-guard
  */
@@ -72739,64 +72787,141 @@ class RateGuardTimeoutError extends Error {
     provider;
     /** Which of the two bounds the caller waited on. */
     bound;
+    /** The model whose guard refused the call, when the provider's limits apply per model. */
+    modelId;
+    /** Whether the caller stopped waiting before the guard's own wait budget ran out. */
+    abandoned;
     /**
      * @param provider The provider.
      * @param bound Which bound was binding.
-     * @param waitedMs How long the caller waited.
+     * @param waitedMs How long the caller was prepared to wait.
+     * @param detail The model, and whether the caller left before the budget ran out.
      */
-    constructor(provider, bound, waitedMs) {
-        super(`client-side ${bound} guard for provider "${provider}" did not admit the call within ${waitedMs} ms. ` +
+    constructor(provider, bound, waitedMs, detail = {}) {
+        const guard = detail.modelId === undefined
+            ? `client-side ${bound} guard for provider "${provider}"`
+            : `client-side ${bound} guard for provider "${provider}", model "${detail.modelId}",`;
+        const outcome = detail.abandoned === true
+            ? `was left by its caller before it could admit the call (wait budget ${waitedMs} ms)`
+            : `did not admit the call within ${waitedMs} ms`;
+        super(`${guard} ${outcome}. ` +
             "The provider was never contacted, so this says nothing about its health.");
         this.name = "RateGuardTimeoutError";
         this.provider = provider;
         this.bound = bound;
+        this.modelId = detail.modelId;
+        this.abandoned = detail.abandoned === true;
     }
 }
+/**
+ * The guard a call is held by.
+ *
+ * A call to a per-model provider that names no model shares one provider-wide
+ * guard held at the per-model ceiling. That is never looser than the limit of
+ * any single model it might reach, so the fallback errs toward pacing.
+ *
+ * @param provider The provider key.
+ * @param modelId The model the call is addressed to, if known.
+ * @returns The guard's identity.
+ */
+function guardIdentity(provider, modelId) {
+    const perModel = limitsFor(provider).scope === "model" && modelId !== undefined && modelId.length > 0;
+    return perModel
+        ? { key: `${provider}/${modelId}`, provider, modelId }
+        : { key: provider, provider, modelId: undefined };
+}
 /**
  * A counting semaphore bounding simultaneous in-flight calls.
  *
- * Written here rather than pulled from a dependency because it is fifteen lines
- * and because the waiting behaviour matters: a waiter that times out must be
- * removed from the queue, or a burst of abandoned callers permanently consumes
- * the permits that later callers need.
+ * Written here rather than pulled from a dependency because the waiting
+ * behaviour is the point. A waiter that times out must be removed from the
+ * queue, or a burst of abandoned callers permanently consumes the permits that
+ * later callers need. And a waiter whose caller has stopped waiting must leave
+ * at once: left queued, it holds its caller until the wait budget expires and
+ * is then handed a permit it can only waste.
  */
 class ConcurrencyGate {
     inFlight = 0;
     waiters = [];
     limit;
-    provider;
+    identity;
     /**
-     * @param provider The provider this gate guards.
+     * @param identity The guard this gate implements.
      * @param limit Maximum simultaneous in-flight calls.
      */
-    constructor(provider, limit) {
-        this.provider = provider;
+    constructor(identity, limit) {
+        this.identity = identity;
         this.limit = limit;
     }
     /**
      * Wait for a permit.
      *
      * @param timeoutMs How long the caller is willing to queue.
+     * @param signal The caller's cancellation; firing it takes the caller out of the queue.
      * @returns A release function the caller must invoke exactly once.
+     * @throws {RateGuardTimeoutError} When no permit was granted in time, or the caller stopped waiting.
      */
-    async acquire(timeoutMs) {
+    async acquire(timeoutMs, signal) {
+        if (signal?.aborted === true) {
+            // Nobody is waiting for this answer. Taking a permit for it would spend
+            // capacity a live caller needs on a call that can only be torn down.
+            throw this.refusal(timeoutMs, true);
+        }
         if (this.inFlight < this.limit) {
             this.inFlight += 1;
             return () => this.release();
         }
         await new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                const index = this.waiters.findIndex((waiter) => waiter.timer === timer);
-                if (index !== -1) {
-                    this.waiters.splice(index, 1);
+            /**
+             * Take this waiter out of the queue and refuse it. A waiter that `release`
+             * has already admitted is no longer queued; it now holds a permit, which
+             * its call returns, so there is nothing to undo here.
+             *
+             * @param abandoned Whether the caller left before the wait budget ran out.
+             * @returns void
+             */
+            const leave = (abandoned) => {
+                const index = this.waiters.indexOf(waiter);
+                if (index === -1) {
+                    return;
                 }
-                reject(new RateGuardTimeoutError(this.provider, "concurrency", timeoutMs));
+                this.waiters.splice(index, 1);
+                clearTimeout(timer);
+                signal?.removeEventListener("abort", onAbort);
+                reject(this.refusal(timeoutMs, abandoned));
+            };
+            const onAbort = () => {
+                leave(true);
+            };
+            const timer = setTimeout(() => {
+                leave(false);
             }, timeoutMs);
-            this.waiters.push({ resolve, reject, timer });
+            const waiter = {
+                admit: () => {
+                    clearTimeout(timer);
+                    signal?.removeEventListener("abort", onAbort);
+                    resolve();
+                },
+            };
+            this.waiters.push(waiter);
+            signal?.addEventListener("abort", onAbort, { once: true });
         });
         this.inFlight += 1;
         return () => this.release();
     }
+    /**
+     * Build the refusal for a caller this gate did not admit.
+     *
+     * @param timeoutMs The wait budget the caller had.
+     * @param abandoned Whether the caller left before the budget ran out.
+     * @returns The error to raise.
+     */
+    refusal(timeoutMs, abandoned) {
+        return new RateGuardTimeoutError(this.identity.provider, "concurrency", timeoutMs, {
+            modelId: this.identity.modelId,
+            abandoned,
+        });
+    }
     /**
      * Return a permit and admit the next waiter.
      *
@@ -72806,8 +72931,7 @@ class ConcurrencyGate {
         this.inFlight -= 1;
         const next = this.waiters.shift();
         if (next !== undefined) {
-            clearTimeout(next.timer);
-            next.resolve();
+            next.admit();
         }
     }
     /**
@@ -72823,44 +72947,47 @@ class ConcurrencyGate {
         return this.waiters.length;
     }
 }
-/** Per-provider guards, created on first use and shared process-wide. */
+/** Guards, created on first use and shared process-wide, keyed by {@link GuardIdentity.key}. */
 const rateLimiters = new Map();
 const concurrencyGates = new Map();
+const guardIdentities = new Map();
 /**
- * The rate limiter for a provider.
+ * The rate limiter for a guard.
  *
  * Shared process-wide rather than per-call-site, because the provider's ceiling
  * applies to the process as a whole. Per-call-site limiters would each stay
  * under the ceiling while their sum sailed past it.
  *
- * @param provider The provider key.
+ * @param identity The guard.
  * @returns Its limiter.
  */
-function rateLimiterFor(provider) {
-    let limiter = rateLimiters.get(provider);
+function rateLimiterFor(identity) {
+    let limiter = rateLimiters.get(identity.key);
     if (limiter === undefined) {
-        const limits = limitsFor(provider);
+        const limits = limitsFor(identity.provider);
         limiter = new TokenBucketRateLimiter({
             maxTokens: limits.requests_per_minute,
             refillRate: limits.requests_per_minute / SECONDS_PER_MINUTE,
-            label: `llm:${provider}`,
+            label: `llm:${identity.key}`,
             timeoutMs: limits.acquire_timeout_ms,
         });
-        rateLimiters.set(provider, limiter);
+        rateLimiters.set(identity.key, limiter);
+        guardIdentities.set(identity.key, identity);
     }
     return limiter;
 }
 /**
- * The concurrency gate for a provider.
+ * The concurrency gate for a guard.
  *
- * @param provider The provider key.
+ * @param identity The guard.
  * @returns Its gate.
  */
-function concurrencyGateFor(provider) {
-    let gate = concurrencyGates.get(provider);
+function concurrencyGateFor(identity) {
+    let gate = concurrencyGates.get(identity.key);
     if (gate === undefined) {
-        gate = new ConcurrencyGate(provider, limitsFor(provider).max_concurrent);
-        concurrencyGates.set(provider, gate);
+        gate = new ConcurrencyGate(identity, limitsFor(identity.provider).max_concurrent);
+        concurrencyGates.set(identity.key, gate);
+        guardIdentities.set(identity.key, identity);
     }
     return gate;
 }
@@ -72882,21 +73009,26 @@ function concurrencyGateFor(provider) {
  * @param provider The provider key.
  * @param call The work to run once admitted.
  * @param maxWaitMs Ceiling on queue time; the configured guard timeout applies when lower.
+ * @param scope The model the call addresses, and the caller's cancellation.
  * @returns The call's result.
- * @throws {RateGuardTimeoutError} When neither bound admitted the call in time.
+ * @throws {RateGuardTimeoutError} When neither bound admitted the call in time,
+ *   or the caller stopped waiting first.
  */
-async function withProviderGuards(provider, call, maxWaitMs) {
+async function withProviderGuards(provider, call, maxWaitMs, scope = {}) {
     const limits = limitsFor(provider);
+    const identity = guardIdentity(provider, scope.modelId);
     const waitBudgetMs = maxWaitMs === undefined
         ? limits.acquire_timeout_ms
         : Math.min(maxWaitMs, limits.acquire_timeout_ms);
     try {
-        await rateLimiterFor(provider).acquire();
+        await rateLimiterFor(identity).acquire();
     }
     catch {
-        throw new RateGuardTimeoutError(provider, "rate", waitBudgetMs);
+        throw new RateGuardTimeoutError(provider, "rate", waitBudgetMs, {
+            modelId: identity.modelId,
+        });
     }
-    const release = await concurrencyGateFor(provider).acquire(waitBudgetMs);
+    const release = await concurrencyGateFor(identity).acquire(waitBudgetMs, scope.signal);
     try {
         return await call();
     }
@@ -72910,16 +73042,20 @@ async function withProviderGuards(provider, call, maxWaitMs) {
 /**
  * Inspect the guards currently in use.
  *
- * @returns A snapshot per provider that has been used, sorted by provider.
+ * @returns A snapshot per guard that has been used, sorted by guard key.
  */
 function guardSnapshots() {
-    const providers = new Set([...rateLimiters.keys(), ...concurrencyGates.keys()]);
-    return [...providers].sort().map((provider) => {
-        const limits = limitsFor(provider);
-        const limiter = rateLimiters.get(provider);
-        const gate = concurrencyGates.get(provider);
+    return [...guardIdentities.values()]
+        .sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0))
+        .map((identity) => {
+        const limits = limitsFor(identity.provider);
+        const limiter = rateLimiters.get(identity.key);
+        const gate = concurrencyGates.get(identity.key);
         return {
-            provider,
+            key: identity.key,
+            provider: identity.provider,
+            modelId: identity.modelId,
+            scope: limits.scope ?? "provider",
             basis: limits.basis,
             requestsPerMinute: limits.requests_per_minute,
             maxConcurrent: limits.max_concurrent,
@@ -72944,6 +73080,105 @@ function resetProviderGuards() {
     }
     rateLimiters.clear();
     concurrencyGates.clear();
+    guardIdentities.clear();
+}
+
+/**
+ * Interpretation of a model's answer to a structured (JSON) request.
+ *
+ * A JSON request is a promise about the answer's SHAPE, and providers keep it
+ * in different ways. An OpenAI-compatible host given `json_object` constrains
+ * its decoder, so its answer is bare JSON. A provider with no schema-less JSON
+ * mode — Anthropic, reached through the gateway, supports structured output
+ * only against a caller-supplied schema — receives nothing but the prompt's
+ * instructions for a `json` request, and a model following them commonly
+ * returns the object inside one markdown code fence. The fence is presentation,
+ * not content: the object inside it is the answer the model gave.
+ *
+ * So exactly ONE enclosing fence is removed before parsing, and nothing else is
+ * forgiven. Prose before or after the fence, two fenced blocks, a fence that
+ * never closes (a truncated answer), and a fence declaring another language all
+ * still fail. Each of those is an answer whose meaning a parser would have to
+ * guess, and a guessed object is a decision made on data no model produced.
+ *
+ * Content that is not fenced is parsed exactly as it always was: JSON cannot
+ * begin with a backtick, so every answer that parsed before this unwrapping
+ * existed takes the same path and yields the same value.
+ *
+ * @module llm/structured-content
+ */
+/**
+ * One markdown fence enclosing the whole answer: an opening line of three
+ * backticks, optionally labelled `json`, then the body, then three closing
+ * backticks, with nothing but whitespace outside them. The body is anchored at
+ * both ends, so an answer holding two fenced blocks captures the text between
+ * them and fails to parse instead of yielding either block.
+ */
+const SINGLE_ENCLOSING_JSON_FENCE = /^\s*```(?:json)?[ \t]*\r?\n([\s\S]*?)\r?\n?[ \t]*```\s*$/i;
+/**
+ * Thrown when a provider answered a structured request with content that does
+ * not parse.
+ *
+ * Carries the usage the provider billed for that answer. The tokens were spent
+ * whether or not the content parsed, and a chain that dropped them would report
+ * a failed attempt as free — understating spend by exactly the calls that went
+ * wrong.
+ */
+class LlmResponseFormatError extends Error {
+    /** The format the caller asked for. */
+    responseFormat;
+    /** What the provider billed for the answer that did not parse. */
+    usage;
+    /** Whether the answer sat inside one enclosing fence that was removed before parsing. */
+    fenced;
+    /**
+     * @param responseFormat The format the caller asked for.
+     * @param usage What the provider billed for the answer.
+     * @param fenced Whether one enclosing fence was removed before parsing.
+     * @param cause The parser's own complaint.
+     */
+    constructor(responseFormat, usage, fenced, cause) {
+        super(`LLM returned content that is not valid JSON for a ${responseFormat} request` +
+            (fenced ? " (inside one enclosing markdown fence)" : "") +
+            `: ${cause instanceof Error ? cause.message : String(cause)}`);
+        this.name = "LlmResponseFormatError";
+        this.responseFormat = responseFormat;
+        this.usage = usage;
+        this.fenced = fenced;
+    }
+}
+/**
+ * The body of the one markdown fence that encloses an answer, if exactly one does.
+ *
+ * @param text The model's answer.
+ * @returns The fenced body, or null when the answer is not wholly one fenced block.
+ */
+function unwrapSingleJsonFence(text) {
+    const match = SINGLE_ENCLOSING_JSON_FENCE.exec(text);
+    return match === null ? null : match[1];
+}
+/**
+ * Parse a model's answer to a structured request.
+ *
+ * A JSON format that does not parse is an error, not an empty object. Returning
+ * a default here would hand the caller a well-typed value that means nothing,
+ * and the failure would surface much later as a decision made on absent data.
+ *
+ * @param content The raw content of the model's message.
+ * @param responseFormat The structured format the caller asked for.
+ * @param usage What the provider billed for this answer, carried on failure.
+ * @returns The parsed value.
+ * @throws {LlmResponseFormatError} When the content is not JSON, fenced or not.
+ */
+function parseStructuredContent(content, responseFormat, usage) {
+    const text = typeof content === "string" ? content : "";
+    const fencedBody = unwrapSingleJsonFence(text);
+    try {
+        return JSON.parse(fencedBody ?? text);
+    }
+    catch (error) {
+        throw new LlmResponseFormatError(typeof responseFormat === "string" ? responseFormat : "json_schema", usage, fencedBody !== null, error);
+    }
 }
 
 /**
@@ -73080,7 +73315,9 @@ async function runLeg(leg, params, execution) {
         // The guards wrap the transport rather than the whole leg, so the per-leg
         // timeout above still bounds the total wait: a caller queued behind the
         // rate limiter is spending its budget just as surely as one waiting on the
-        // provider, and only one clock should govern both.
+        // provider, and only one clock should govern both. The leg's own signal is
+        // handed to the guard as well, so a leg whose budget or caller is gone
+        // leaves the queue at once instead of holding its place in it.
         return await withProviderGuards(leg.route.providerName, () => leg.transport.execute({
             route: leg.route,
             content: execution.content,
@@ -73090,7 +73327,7 @@ async function runLeg(leg, params, execution) {
             context: execution.context,
             signal: controller.signal,
             correlationId: execution.correlationId,
-        }), budgetMs);
+        }), budgetMs, { modelId: leg.route.modelId, signal: controller.signal });
     }
     finally {
         clearTimeout(timer);
@@ -73202,7 +73439,7 @@ async function executeChain(alias, execution) {
             continue;
         }
         const startedAt = now();
-        execution.breakers.onAttemptStart(route.routeKey);
+        const holdsProbe = execution.breakers.onAttemptStart(route.routeKey);
         try {
             const response = await runLeg(leg, leg.params, execution);
             execution.breakers.onSuccess(route.routeKey);
@@ -73225,6 +73462,15 @@ async function executeChain(alias, execution) {
             if (countsAgainstHealth) {
                 execution.breakers.onFailure(route.routeKey);
             }
+            else if (holdsProbe) {
+                // No verdict on the route's health, but the probe slot this attempt
+                // took must come back, or a half-open route admits no probe ever again.
+                execution.breakers.onAttemptAbandoned(route.routeKey);
+            }
+            // A provider that answered with unparseable content still billed for the
+            // answer; the spend belongs in the total whether or not a later leg serves.
+            const billed = error instanceof LlmResponseFormatError ? error.usage : undefined;
+            totalUsage = sumUsage(totalUsage, billed);
             const record = {
                 routeKey: route.routeKey,
                 role: route.role,
@@ -73233,6 +73479,7 @@ async function executeChain(alias, execution) {
                 outcome,
                 durationMs: now() - startedAt,
                 reason,
+                ...(billed === undefined ? {} : { usage: billed }),
             };
             attempts.push(record);
             execution.onAttempt?.(record);
@@ -74526,9 +74773,13 @@ function createGatewayTransport(config) {
             const payload = (await response.json());
             const choices = payload.choices;
             const message = choices?.[0]?.message;
+            // Usage is read before the content is interpreted. The provider billed for
+            // this answer whether or not it parses, and a parse failure that dropped
+            // the count would report the attempt as free.
+            const usage = readUsage(payload, request);
             return {
-                response: parseContent(message?.content, request.responseFormat),
-                usage: readUsage(payload, request),
+                response: interpretContent(message?.content, request.responseFormat, usage),
+                usage,
                 tool_calls: Array.isArray(message?.tool_calls)
                     ? message.tool_calls
                     : undefined,
@@ -74563,25 +74814,22 @@ function buildMessages(request) {
 /**
  * Interpret the model's content according to the requested format.
  *
- * A JSON format that does not parse is an error, not an empty object. Returning
- * a default here would hand the caller a well-typed value that means nothing,
- * and the failure would surface much later as a decision made on absent data.
+ * Text is returned as sent. A structured format is parsed under the strict
+ * single-fence rule of {@link parseStructuredContent}; a structured answer that
+ * does not parse is an error carrying what the provider billed for it, never an
+ * empty object.
  *
  * @param content The raw content.
  * @param responseFormat The format the caller asked for.
- * @returns The parsed value.
+ * @param usage What the provider billed for this answer.
+ * @returns The interpreted value.
+ * @throws {LlmResponseFormatError} When a structured answer does not parse.
  */
-function parseContent(content, responseFormat) {
-    const text = typeof content === "string" ? content : "";
+function interpretContent(content, responseFormat, usage) {
     if (responseFormat === "text") {
-        return text;
-    }
-    try {
-        return JSON.parse(text);
-    }
-    catch (error) {
-        throw new Error(`LLM returned content that is not valid JSON for a ${typeof responseFormat === "string" ? responseFormat : "json_schema"} request: ${error instanceof Error ? error.message : String(error)}`);
+        return (typeof content === "string" ? content : "");
     }
+    return parseStructuredContent(content, responseFormat, usage);
 }
 
 /**
@@ -78676,6 +78924,7 @@ const OrderStatusSchema = enumType([
     "accepted",
     "pending_new",
     "accepted_for_bidding",
+    "held",
     "stopped",
     "rejected",
     "suspended",
@@ -80332,6 +80581,7 @@ exports.GatewayUnreachableError = GatewayUnreachableError;
 exports.HttpClientError = HttpClientError;
 exports.HttpServerError = HttpServerError;
 exports.KEEP_ALIVE_DEFAULTS = KEEP_ALIVE_DEFAULTS;
+exports.LlmResponseFormatError = LlmResponseFormatError;
 exports.MARKET_DATA_API = MARKET_DATA_API;
 exports.MassiveAggregatesResponseSchema = MassiveAggregatesResponseSchema;
 exports.MassiveApiError = MassiveApiError;