@plurnk/plurnk-providers 1.18.0 → 1.19.1

package/src/AiSdkProvider.ts

@@ -126,7 +126,6 @@ export type AiSdkProviderConfig = {
     // a fixed deployment choice and therefore wins on every request.
     serviceTier?: string;
     streaming?: boolean;                        // SSE transport (default true); false → one non-streamed JSON
-    firstPartyMetadata?: boolean;              // forward per-turn attributions + client as Plurnk-* headers (plurnk only); default false
     apiKeyRejectedMessage?: string;            // friendly hint when a present key is 401/403-rejected (distinct from unset); default undefined
     eosText?: string;                          // server-reported eos_token, stripped from the content tail (--special renders it as text); default undefined
     // Slot affinity wiring is provider-internal, never consumer-facing.
@@ -199,10 +198,6 @@ export type AiSdkProviderConfig = {
     // the standard factory always supplies them. Resolved against contextWindow
     // at read time (getters), so a probe that lands after config assembly still
     // derives correctly.
-    // The plurnk.ai router owns tuning — false suppresses the
-    // client-side temperature/penalty FLOORS on this provider (caller `sampling`
-    // still passes through verbatim). Default true (floors ride).
-    tuningFloors?: boolean;
 };
 
 class ProviderRequestObserverError extends Error {
@@ -296,13 +291,11 @@ export default class AiSdkProvider implements Provider {
     #reasoningResponseProviderOptions: AiSdkProviderOptions | undefined;
     #serviceTier: string | undefined;
     #streaming: boolean;
-    #firstPartyMetadata: boolean;
     #supportsSlotPinning: boolean;
     #slotCount: number | null;
     #retryAttempts: number;
     #errorDetailLimit: number | undefined;
     #topLogprobs: number | null;
-    #tuningFloors: boolean;
     #rawBody: boolean;
     #servedModel: string | undefined;
     #requiresOutputBudget: boolean | undefined;
@@ -418,14 +411,12 @@ export default class AiSdkProvider implements Provider {
         }
         this.#serviceTier = config.serviceTier;
         this.#streaming = config.streaming ?? true;
-        this.#firstPartyMetadata = config.firstPartyMetadata ?? false;
         this.#apiKeyRejectedMessage = config.apiKeyRejectedMessage;
         this.#eosText = config.eosText;
         this.#hasApiKey = "Authorization" in this.#headers;
         this.#supportsSlotPinning = config.supportsSlotPinning ?? false;
         this.#slotCount = config.slotCount ?? null;
         this.#topLogprobs = config.topLogprobs ?? null;
-        this.#tuningFloors = config.tuningFloors ?? true;
         this.#rawBody = config.rawBody ?? false;
         this.#servedModel = config.servedModel;
         this.#requiresOutputBudget = config.requiresOutputBudget;
@@ -477,7 +468,7 @@ export default class AiSdkProvider implements Provider {
                 return tokens;
             };
         }
-        this.#requestBody = new AiSdkRequestBody({ reasoningBudget: this.#reasoningBudget, additiveReasoningProvider: this.#additiveReasoningProvider, reasoning: this.#reasoning, reasoningToggle: this.#reasoningToggle, compatibleAdaptiveReasoning: this.#compatibleAdaptiveReasoning, compatibleOffReasoning: this.#compatibleOffReasoning, adaptiveReasoningProviderOptions: this.#adaptiveReasoningProviderOptions, repeatPenalty: this.#repeatPenalty, frequencyPenalty: this.#frequencyPenalty, dryMultiplier: this.#dryMultiplier, dryBase: this.#dryBase, dryAllowedLength: this.#dryAllowedLength, repeatLastN: this.#repeatLastN, reasoningStyle: this.#reasoningStyle, source: this.#source, grammarStyle: this.#grammarStyle, cacheAffinity: this.#cacheAffinity, reasoningResponseProviderOptions: this.#reasoningResponseProviderOptions, firstPartyMetadata: this.#firstPartyMetadata, supportsSlotPinning: this.#supportsSlotPinning, slotCount: this.#slotCount });
+        this.#requestBody = new AiSdkRequestBody({ reasoningBudget: this.#reasoningBudget, additiveReasoningProvider: this.#additiveReasoningProvider, reasoning: this.#reasoning, reasoningToggle: this.#reasoningToggle, compatibleAdaptiveReasoning: this.#compatibleAdaptiveReasoning, compatibleOffReasoning: this.#compatibleOffReasoning, adaptiveReasoningProviderOptions: this.#adaptiveReasoningProviderOptions, repeatPenalty: this.#repeatPenalty, frequencyPenalty: this.#frequencyPenalty, dryMultiplier: this.#dryMultiplier, dryBase: this.#dryBase, dryAllowedLength: this.#dryAllowedLength, repeatLastN: this.#repeatLastN, reasoningStyle: this.#reasoningStyle, source: this.#source, grammarStyle: this.#grammarStyle, cacheAffinity: this.#cacheAffinity, reasoningResponseProviderOptions: this.#reasoningResponseProviderOptions, supportsSlotPinning: this.#supportsSlotPinning, slotCount: this.#slotCount });
     }
 
     get contextWindow(): number | null { return this.#contextWindow; }
@@ -613,7 +604,7 @@ export default class AiSdkProvider implements Provider {
         });
     }
 
-    async generate({ messages, workerId, primaryWorkerId, signal, grammar, maxOutputTokens, attributions, client, strikes, workspaceId, loop, turn, sampling, observeRequest, observeReasoning, callKind }: ProviderGenerateArgs): Promise<ProviderResponse> {
+    async generate({ messages, workerId, signal, grammar, maxOutputTokens, sampling, observeRequest, observeReasoning, callKind }: ProviderGenerateArgs): Promise<ProviderResponse> {
         // {§provider-interface} The worker identity is required.
         if (workerId === undefined || workerId.length === 0) throw new Error("generate: workerId is required — the worker's stable, opaque identity");
         if (callKind !== undefined && callKind !== "emission" && callKind !== "bare") {
@@ -655,9 +646,8 @@ export default class AiSdkProvider implements Provider {
         // paths and the name promises every request) < the caller's `sampling`
         // < the managed fields, which always win.
         const body: Record<string, unknown> = {
-            // Floors are suppressed on router-owned-tuning providers (plurnk) —
-            // the router's per-model tuning must not be overridden by client floors.
-            ...(this.#tuningFloors ? { ...(this.#temperature !== null ? { temperature: this.#temperature } : {}), ...this.#requestBody.repetitionPenaltyBody() } : {}),
+            ...(this.#temperature !== null ? { temperature: this.#temperature } : {}),
+            ...this.#requestBody.repetitionPenaltyBody(),
             ...this.#requestBody.samplingBody(sampling),
             ...(this.#serviceTier !== undefined ? { service_tier: this.#serviceTier } : {}),
             ...this.#requestBody.reasoningBody(preserveGrammarSentence, capacity.reasoningBudget),
@@ -672,13 +662,11 @@ export default class AiSdkProvider implements Provider {
                 : {}),
         };
 
-        // Per-request headers = static auth/routing + any first-party telemetry.
-        const metaHeaders = this.#requestBody.metadataHeaders(attributions, client, strikes, workerId, primaryWorkerId, workspaceId, loop, turn, callKind);
+        // Per-request headers = static auth/routing only.
         const headers = new Headers(this.#headers);
         if (this.#cacheAffinity?.target === "header") {
             headers.set(this.#cacheAffinity.name, workerId);
         }
-        for (const [name, value] of Object.entries(metaHeaders)) headers.set(name, value);
         const requestHeaders = Object.fromEntries(headers.entries());
         const accounting: ProviderRequestAccounting[] = [];
         const operationTimeout = this.#operationTimeoutMs > 0
@@ -803,15 +791,13 @@ export default class AiSdkProvider implements Provider {
                         streaming: this.#streaming,
                         captureRawBody: this.#rawBody,
                         ...observers,
-                        temperature: this.#tuningFloors
-                            ? (typeof sampling?.temperature === "number" ? sampling.temperature : this.#temperature ?? undefined)
-                            : typeof sampling?.temperature === "number" ? sampling.temperature : undefined,
+                        temperature: typeof sampling?.temperature === "number" ? sampling.temperature : this.#temperature ?? undefined,
                         topP: typeof sampling?.top_p === "number" ? sampling.top_p : undefined,
                         topK: typeof sampling?.top_k === "number" ? sampling.top_k : undefined,
                         presencePenalty: typeof sampling?.presence_penalty === "number" ? sampling.presence_penalty : undefined,
                         frequencyPenalty: typeof sampling?.frequency_penalty === "number"
                             ? sampling.frequency_penalty
-                            : this.#tuningFloors && this.#frequencyPenalty > 0 ? this.#frequencyPenalty : undefined,
+                            : this.#frequencyPenalty > 0 ? this.#frequencyPenalty : undefined,
                         stopSequences: typeof sampling?.stop === "string"
                             ? [sampling.stop]
                             : Array.isArray(sampling?.stop) && sampling.stop.every((value) => typeof value === "string")
@@ -1007,9 +993,6 @@ export default class AiSdkProvider implements Provider {
         const assistant = {
             content: raw.content,
             reasoning: raw.reasoning.length > 0 ? raw.reasoning : null,
-            ...(raw.reasoningEncrypted.length > 0
-                ? { reasoningEncrypted: raw.reasoningEncrypted }
-                : {}),
             model: raw.model,
             ...(logprobs !== undefined ? { logprobs, meanLogprob } : {}),
         };

package/src/AiSdkRequestBody.ts

@@ -1,5 +1,5 @@
 // The provider-specific request body and headers one generate call sends: reasoning, grammar, sampling, repetition, slots, metadata. Split out of AiSdkProvider; every knob it reads is injected.
-import type { ProviderCallKind, ReasoningPolicy } from "./types.ts";
+import type { ReasoningPolicy } from "./types.ts";
 import type { JSONValue } from "ai";
 import { type Reasoning } from "./env.ts";
 import { fixedEffort } from "./reasoning-effort.ts";
@@ -80,13 +80,12 @@ export default class AiSdkRequestBody {
     readonly #grammarStyle: GrammarStyle;
     readonly #cacheAffinity: CacheAffinity | undefined;
     readonly #reasoningResponseProviderOptions: AiSdkProviderOptions | undefined;
-    readonly #firstPartyMetadata: boolean;
     readonly #supportsSlotPinning: boolean;
     readonly #slotCount: number | null;
     #runSlots = new Map<string, number>();
     #nextSlot = 0;
 
-    constructor({ reasoningBudget, additiveReasoningProvider, reasoning, reasoningToggle, compatibleAdaptiveReasoning, compatibleOffReasoning, adaptiveReasoningProviderOptions, repeatPenalty, frequencyPenalty, dryMultiplier, dryBase, dryAllowedLength, repeatLastN, reasoningStyle, source, grammarStyle, cacheAffinity, reasoningResponseProviderOptions, firstPartyMetadata, supportsSlotPinning, slotCount }: {
+    constructor({ reasoningBudget, additiveReasoningProvider, reasoning, reasoningToggle, compatibleAdaptiveReasoning, compatibleOffReasoning, adaptiveReasoningProviderOptions, repeatPenalty, frequencyPenalty, dryMultiplier, dryBase, dryAllowedLength, repeatLastN, reasoningStyle, source, grammarStyle, cacheAffinity, reasoningResponseProviderOptions, supportsSlotPinning, slotCount }: {
         reasoningBudget: number | null;
         additiveReasoningProvider: "anthropic" | "bedrock" | undefined;
         reasoning: Reasoning;
@@ -105,7 +104,6 @@ export default class AiSdkRequestBody {
         grammarStyle: GrammarStyle;
         cacheAffinity: CacheAffinity | undefined;
         reasoningResponseProviderOptions: AiSdkProviderOptions | undefined;
-        firstPartyMetadata: boolean;
         supportsSlotPinning: boolean;
         slotCount: number | null;
     }) {
@@ -127,7 +125,6 @@ export default class AiSdkRequestBody {
         this.#grammarStyle = grammarStyle;
         this.#cacheAffinity = cacheAffinity;
         this.#reasoningResponseProviderOptions = reasoningResponseProviderOptions;
-        this.#firstPartyMetadata = firstPartyMetadata;
         this.#supportsSlotPinning = supportsSlotPinning;
         this.#slotCount = slotCount;
     }
@@ -294,43 +291,6 @@ export default class AiSdkRequestBody {
     }
 
 
-    // First-party telemetry headers ({§provider-request-authority} {§provider-call-kind}): forwarded only when the spec
-    // opted in (the plurnk endpoint). The gate is here, not at the call site, so
-    // attributions/client/strikes can never reach a third-party backend even if
-    // the consumer passes them to the wrong provider. Empty values emit no header
-    // — EXCEPT strikes, where 0 is a real value (clean streak) distinct from
-    // absent (consumer didn't report); contract {§strikes-first-party-metadata}. Strikes
-    // ride HTTP headers only — the packet never carries them (the model must
-    // never see strike state; engine accounting is not a metric to game).
-    metadataHeaders(attributions: string[] | undefined, client: string | undefined, strikes: number | undefined, workerId: string, primaryWorkerId: string | undefined, workspaceId: string | undefined, loop: number | undefined, turn: number | undefined, callKind: ProviderCallKind | undefined): Record<string, string> {
-        if (!this.#firstPartyMetadata) return {};
-        const h: Record<string, string> = {};
-        if (attributions !== undefined && attributions.length > 0) h["Plurnk-Attribution"] = JSON.stringify(attributions);
-        if (client !== undefined && client.length > 0) h["Plurnk-Client"] = client;
-        if (strikes !== undefined && Number.isInteger(strikes) && strikes >= 0) h["Plurnk-Strikes"] = String(strikes);
-        // Worker identity: the opaque workerId
-        // the consumer already supplies, forwarded so the endpoint can key
-        // per-worker affinity/telemetry — same gate as every first-party signal.
-        h["Plurnk-Worker-Id"] = workerId;
-        // Root worker of the lineage ({§worker-primary}): the no-parent ancestor of this turn's
-        // worker tree. The consumer classifies primary-vs-spawned by equality
-        // (primaryWorkerId == workerId ⇒ the primary/root worker). The provider
-        // EMITS what the consumer supplies and never invents a primary; the
-        // consumer's contract is to stamp it EVERY turn (including the primary's
-        // own, where it equals workerId). Absence is the consumer's violation for
-        // the endpoint to surface, not a provider default.
-        if (primaryWorkerId !== undefined && primaryWorkerId.length > 0) h["Plurnk-Worker-Primary"] = primaryWorkerId;
-        // Turn coordinate ({§lifecycle-terms}): workspace/loop/turn, the
-        // daemon-side sequence the endpoint can never scrape from the wire.
-        // Coordinates are 1-based — 0 is not a real value, so no strikes-style
-        // zero exception; absent/empty/0 emits no header.
-        if (workspaceId !== undefined && workspaceId.length > 0) h["Plurnk-Workspace-Id"] = workspaceId;
-        if (loop !== undefined && Number.isInteger(loop) && loop >= 1) h["Plurnk-Loop"] = String(loop);
-        if (turn !== undefined && Number.isInteger(turn) && turn >= 1) h["Plurnk-Turn"] = String(turn);
-        if (callKind !== undefined) h["Plurnk-Call-Kind"] = callKind;
-        return h;
-    }
-
 
     requestProviderOptions(
         workerId: string,

package/src/Mock.test.ts

@@ -8,10 +8,18 @@ import { ProviderError } from "./errors.ts";
 const build = (responses: MockResponse[] = [{ assistant: { content: "hi", reasoning: null } }]) =>
     new Mock({ contextWindow: 100000, responses });
 
+// The suite runs on this package's own panel, which ships an output budget. "No budget" is therefore
+// something a test states — the panel's explicit empty value — never an ambient absence of the key.
+const withoutOutputBudget = <T>(body: () => T): T => {
+    const panel = process.env.PLURNK_PROVIDERS_OUTPUT_BUDGET;
+    process.env.PLURNK_PROVIDERS_OUTPUT_BUDGET = "";
+    try { return body(); } finally { process.env.PLURNK_PROVIDERS_OUTPUT_BUDGET = panel; }
+};
+
 // — Identity ({§provider-interface}) —
 
 test("Mock: contextWindow and model are stable across reads", () => {
-    const m = build();
+    const m = withoutOutputBudget(() => build());
     assert.equal(m.contextWindow, 100000);
     assert.equal(m.inputCapacity, null);
     assert.equal(m.contextWindow, 100000);
@@ -193,8 +201,8 @@ test("Mock resolves percentage and absolute generation budgets against its windo
     }
 });
 
-test("no generation-budget env leaves a bare Mock unbounded", () => {
-    const m = new Mock({ contextWindow: 49152, responses: [] });
+test("an empty generation budget leaves a bare Mock unbounded", () => {
+    const m = withoutOutputBudget(() => new Mock({ contextWindow: 49152, responses: [] }));
     assert.equal(m.outputBudget, null);
     assert.equal(m.reasoningBudget, null);
     assert.equal(m.inputCapacity, null);

package/src/Mock.ts

@@ -7,7 +7,7 @@
 
 import { chatMessageText } from "./types.ts";
 import type { InputModality } from "./types.ts";
-import type { ChatMessage, FinishReason, GrammarEvidence, PromptTokenMeasurement, Provider, ProviderAssistant, ProviderCost, ProviderEncryptedReasoningItem, ProviderRequestAccounting, ProviderRequestCapacity, ProviderResponse, ProviderUsage } from "./types.ts";
+import type { ChatMessage, FinishReason, GrammarEvidence, PromptTokenMeasurement, Provider, ProviderAssistant, ProviderCost, ProviderRequestAccounting, ProviderRequestCapacity, ProviderResponse, ProviderUsage } from "./types.ts";
 import { resolveGenerationEnvelopeFromEnv } from "./env.ts";
 import { REASONING_POLICIES } from "@plurnk/plurnk-contracts";
 import { validateProviderRequestAccounting } from "./accounting.ts";
@@ -20,7 +20,6 @@ export type MockAssistant = {
     finishReason?: FinishReason;
     model?: string;
     // Provider-normalized encrypted reasoning fixture.
-    reasoningEncrypted?: ReadonlyArray<ProviderEncryptedReasoningItem>;
     // Pre-parsed ops — intg-only escape hatch. Typed `unknown[]` so the
     // framework carries no parser dependency; plurnk-service
     // casts these to PlurnkStatement[] on its side. Production providers never
@@ -41,7 +40,7 @@ export type MockResponse = {
 export type MockReturnedAssistant = ProviderAssistant & { ops?: unknown[] };
 export type MockReturnedResponse = ProviderResponse & { assistant: MockReturnedAssistant };
 
-const DEFAULT_USAGE: ProviderUsage = {
+const MOCK_USAGE: ProviderUsage = {
     inputTokens: 0,
     outputTokens: 0,
     totalTokens: 0,
@@ -154,7 +153,7 @@ export default class Mock implements Provider {
         }
         const a = next.assistant;
         const usage: ProviderUsage = {
-            ...DEFAULT_USAGE,
+            ...MOCK_USAGE,
             ...next.usage,
         };
         const requestAccounting: ProviderRequestAccounting = validateProviderRequestAccounting({
@@ -172,7 +171,6 @@ export default class Mock implements Provider {
         const assistant: MockReturnedAssistant = {
             content: a.content,
             reasoning: a.reasoning,
-            ...(a.reasoningEncrypted !== undefined ? { reasoningEncrypted: a.reasoningEncrypted } : {}),
             finishReason: a.finishReason ?? "stop",
             model: a.model ?? "mock",
             ...(a.ops !== undefined ? { ops: a.ops } : {}),
@@ -196,4 +194,4 @@ export default class Mock implements Provider {
     get remaining(): number { return this.#queue.length; }
 }
 
-export { DEFAULT_USAGE as mockDefaultUsage };
+export { MOCK_USAGE as mockDefaultUsage };

package/src/ProviderRegistry.test.ts

@@ -73,7 +73,6 @@ test("instantiateProvider: a selected plugin composes its static and runtime att
     const context: PluginAttributionContext = {
         workspaceId: "workspace",
         workerId: "worker",
-        primaryWorkerId: "primary",
         loop: 3,
         turn: 2,
         attempt: 1,

package/src/ProviderRegistry.ts

@@ -60,7 +60,7 @@ export const instantiateProvider = async (
     const catalog = catalogProviderFromEnv(name, env, model, baseUrl);
     if (catalog !== null) return catalog;
     if (name === "ollama") return ollamaProviderFromEnv(env, model, baseUrl === undefined ? undefined : { baseUrl });
-    if (name === "openai" || name === "plurnk") return compatibleProviderFromEnv(name, env, model, baseUrl);
+    if (name === "openai") return compatibleProviderFromEnv(env, model, baseUrl);
     const { registry, skipped, packageAttributions = new Map(), grammarStyles = new Map() } = await providerPackages(discoverFn, env);
     const specifier = registry.get(name);
     if (specifier === undefined) {

package/src/accounting.test.ts

@@ -2,7 +2,6 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import {
     aggregateProviderAccounting,
-    plurnkCostNormalizer,
     providerCostNormalizer,
 } from "./accounting.ts";
 
@@ -17,17 +16,6 @@ const evidence = ({ providerMetadata, usage, charge }: {
     response: { id: "response-1" },
 });
 
-test("xAI response ticks normalize to a directly charged request", () => {
-    const normalize = providerCostNormalizer("@ai-sdk/xai");
-    assert.notEqual(normalize, undefined);
-    assert.deepEqual(normalize!(evidence({ usage: { cost_in_usd_ticks: 15_493_500 } })), {
-        kind: "charged",
-        amount: { amount: "15493500", currency: "USDTICK" },
-        usdEquivalent: "0.00154935",
-        source: "xAI response usage.cost_in_usd_ticks",
-    });
-});
-
 test("OpenRouter response cost normalizes without rate reconstruction", () => {
     const normalize = providerCostNormalizer("@openrouter/ai-sdk-provider");
     assert.notEqual(normalize, undefined);
@@ -48,22 +36,12 @@ test("DeepInfra's documented response estimate remains estimated", () => {
     });
 });
 
-test("first-party charged evidence is validated at its adapter boundary", () => {
-    const charged = {
-        kind: "charged",
-        amount: { amount: "0.01", currency: "USD" },
-        source: "plurnk endpoint",
-    } as const;
-    assert.deepEqual(plurnkCostNormalizer(evidence({ charge: charged })), charged);
-    assert.equal(plurnkCostNormalizer(evidence({})), undefined);
-});
-
 test("response cost normalization is an explicit adapter capability", () => {
     assert.equal(providerCostNormalizer("@ai-sdk/anthropic"), undefined);
-    assert.equal(providerCostNormalizer("@ai-sdk/xai")!(evidence({ usage: {} })), undefined);
+    assert.equal(providerCostNormalizer("@ai-sdk/deepinfra")!(evidence({ usage: {} })), undefined);
     assert.throws(
-        () => providerCostNormalizer("@ai-sdk/xai")!(evidence({ usage: { cost_in_usd_ticks: "1" } })),
-        /cost_in_usd_ticks must be numeric/,
+        () => providerCostNormalizer("@ai-sdk/deepinfra")!(evidence({ usage: { estimated_cost: "1" } })),
+        /estimated_cost must be numeric/,
     );
 });
 

package/src/accounting.ts

@@ -1,5 +1,4 @@
 import type {
-    ChargedCost,
     ProviderAccounting,
     ProviderCostNormalizer,
     ProviderRequestAccounting,
@@ -7,7 +6,6 @@ import type {
 } from "./types.ts";
 import {
     sumProviderCostsUsd,
-    validateChargedCost,
     validateProviderCost,
 } from "./cost.ts";
 import { validateProviderUsage } from "./usage.ts";
@@ -33,31 +31,6 @@ const decimalFromNumber = (value: number, subject: string): string => {
     return `${digits.slice(0, point)}.${digits.slice(point)}`;
 };
 
-const usdFromTicks = (ticks: number): string => {
-    if (!Number.isSafeInteger(ticks) || ticks < 0) {
-        throw new TypeError("xAI costInUsdTicks must be a non-negative safe integer");
-    }
-    const digits = String(ticks).padStart(11, "0");
-    const integer = digits.slice(0, -10).replace(/^0+(?=\d)/, "");
-    const fraction = digits.slice(-10).replace(/0+$/, "");
-    return fraction === "" ? integer : `${integer}.${fraction}`;
-};
-
-const xaiCost: ProviderCostNormalizer = ({ usage }) => {
-    const wireUsage = recordOf(usage);
-    if (wireUsage === null || !("cost_in_usd_ticks" in wireUsage)) return undefined;
-    const ticks = wireUsage.cost_in_usd_ticks;
-    if (typeof ticks !== "number") {
-        throw new TypeError("xAI usage.cost_in_usd_ticks must be numeric");
-    }
-    return {
-        kind: "charged",
-        amount: { amount: String(ticks), currency: "USDTICK" },
-        usdEquivalent: usdFromTicks(ticks),
-        source: "xAI response usage.cost_in_usd_ticks",
-    };
-};
-
 const openRouterCost: ProviderCostNormalizer = ({ providerMetadata }) => {
     const usage = recordOf(recordOf(recordOf(providerMetadata)?.openrouter)?.usage);
     if (usage === null || !("cost" in usage)) return undefined;
@@ -82,17 +55,10 @@ const deepInfraCost: ProviderCostNormalizer = ({ usage }) => {
     };
 };
 
-// The first-party endpoint owns the direct charged-cost wire field.
-export const plurnkCostNormalizer: ProviderCostNormalizer = ({ charge }) => {
-    if (charge === undefined) return undefined;
-    return validateChargedCost(charge) as ChargedCost;
-};
-
 export const providerCostNormalizer = (
     sdkPackage: string,
 ): ProviderCostNormalizer | undefined => {
     switch (sdkPackage) {
-        case "@ai-sdk/xai": return xaiCost;
         case "@ai-sdk/deepinfra": return deepInfraCost;
         case "@openrouter/ai-sdk-provider": return openRouterCost;
         default: return undefined;

package/src/aiSdkTransport.test.ts

@@ -19,7 +19,7 @@ const request = {
     captureRawBody: false,
 };
 
-test("the transport performs exactly one physical request", async () => {
+test("{§provider-sdk-boundary} the transport performs exactly one physical request", async () => {
     let calls = 0;
     await assert.rejects(
         executeOpenAICompatible({
@@ -416,3 +416,4 @@ test("inconsistent usage counters refuse normalization without failing the respo
         assert.equal(result.usageRefusal, undefined);
     });
 });
+

package/src/aiSdkTransport.ts

@@ -201,11 +201,6 @@ export type AiSdkTransportResponse = {
     usage?: ProviderUsage;
     usageRefusal?: UsageRefusal;
     metadata: Record<string, unknown>;
-    reasoningEncrypted: Array<{
-        id: string | null;
-        subtype: string;
-        encrypted: Array<{ data: string; format: string | null }>;
-    }>;
     logprobs: TokenLogprob[];
     chargeEvidence: ProviderChargeEvidence;
     rawBody?: unknown;
@@ -413,6 +408,18 @@ const executeModelOnce = async (
             ? { role: "assistant", content: chatMessageText(message) }
             : { role: "system", content: chatMessageText(message) };
     });
+    // {§provider-connectivity} — a streamed attempt's deadline holds only until semantic content
+    // flows; after that, stream-idle catches a stall and the operation deadline bounds the whole.
+    // A healthy stream still producing (long reasoning) is never cut off and its tokens wasted.
+    const attemptDeadline = request.streaming && request.fetchTimeoutMs > 0 ? new AbortController() : null;
+    const attemptTimer = attemptDeadline === null ? null : setTimeout(
+        () => attemptDeadline.abort(new ProviderTimeoutError("attempt", request.fetchTimeoutMs)),
+        request.fetchTimeoutMs,
+    );
+    const liftAttemptDeadline = (): void => { if (attemptTimer !== null) clearTimeout(attemptTimer); };
+    const abortSignal = attemptDeadline === null
+        ? request.signal
+        : request.signal === undefined ? attemptDeadline.signal : AbortSignal.any([request.signal, attemptDeadline.signal]);
     const common = {
         model,
         ...(instructions.length === 0 ? {} : { instructions }),
@@ -422,10 +429,10 @@ const executeModelOnce = async (
         // AiSdkProvider owns retries so every physical request is independently
         // observed and accounted. The SDK transport executes exactly once.
         maxRetries: 0,
-        abortSignal: request.signal,
+        abortSignal,
         headers: request.headers,
         timeout: {
-            ...(request.fetchTimeoutMs > 0 ? { totalMs: request.fetchTimeoutMs } : {}),
+            ...(request.fetchTimeoutMs > 0 && !request.streaming ? { totalMs: request.fetchTimeoutMs } : {}),
             ...(request.streaming
                 && request.firstContentTimeoutMs !== undefined
                 && request.firstContentTimeoutMs > 0
@@ -460,7 +467,6 @@ const executeModelOnce = async (
             ...(rawFinishReason === undefined ? {} : { rawFinishReason }),
             ...settledUsage(values, result.usage),
             metadata: metadataOf(values),
-            reasoningEncrypted: evidence.reasoningEncrypted,
             logprobs: evidence.logprobs,
             chargeEvidence: {
                 ...(wireChargeEvidenceOf(values) === undefined
@@ -490,15 +496,21 @@ const executeModelOnce = async (
     const rawChunks: unknown[] = [];
     let streamError: unknown;
     let outputObserved = false;
+    let answer = "";
     try {
         for await (const part of result.fullStream) {
-            if (part.type === "raw") rawChunks.push(part.rawValue);
+            if (part.type === "raw") {
+                rawChunks.push(part.rawValue);
+            }
             if (part.type === "text-delta" && part.text.length > 0) {
                 outputObserved = true;
+                liftAttemptDeadline();
+                answer += part.text;
                 request.observeText?.(part.text);
             }
             if (part.type === "reasoning-delta" && part.text.length > 0) {
                 outputObserved = true;
+                liftAttemptDeadline();
                 request.observeReasoning?.(part.text);
             }
             if (part.type === "error") streamError ??= part.error;
@@ -506,6 +518,8 @@ const executeModelOnce = async (
     } catch (error) {
         preserveStreamFailure(error, rawChunks, outputObserved);
         throw error;
+    } finally {
+        liftAttemptDeadline();
     }
     if (streamError !== undefined) {
         preserveStreamFailure(streamError, rawChunks, outputObserved);
@@ -530,7 +544,6 @@ const executeModelOnce = async (
         ...(rawFinishReason === undefined ? {} : { rawFinishReason }),
         ...settledUsage(rawChunks, await result.usage),
         metadata: metadataOf(rawChunks),
-        reasoningEncrypted: evidence.reasoningEncrypted,
         logprobs: evidence.logprobs,
         chargeEvidence: {
             ...(wireChargeEvidenceOf(rawChunks) === undefined
@@ -637,16 +650,13 @@ export const transportFailureEvidence = (
 };
 
 const extractEvidence = (values: unknown[]): {
-    reasoningEncrypted: AiSdkTransportResponse["reasoningEncrypted"];
     logprobs: TokenLogprob[];
     reasoning: string;
     reasoningProjected: boolean;
 } => {
-    const encrypted = new Map<string, AiSdkTransportResponse["reasoningEncrypted"][number]>();
     const logprobs: TokenLogprob[] = [];
     let reasoning = "";
     let reasoningProjected = false;
-    let anonymous = 0;
     for (const value of values) {
         const choices = recordOf(value)?.choices;
         if (!Array.isArray(choices)) continue;
@@ -671,42 +681,16 @@ const extractEvidence = (values: unknown[]): {
                     : { token: entry.token, logprob: entry.logprob, top });
             }
         }
-        const message = recordOf(choice.delta) ?? recordOf(choice.message) ?? {};
+        const delta = recordOf(choice.delta);
+        const message = delta ?? recordOf(choice.message) ?? {};
         for (const key of ["reasoning_content", "reasoning", "thinking"]) { // lexicon-allow: backend wire fields
             if (typeof message[key] === "string") {
                 reasoningProjected = true;
                 reasoning += message[key];
             }
         }
-        if (!Array.isArray(message.reasoning_details)) continue;
-        for (const value of message.reasoning_details) {
-            const detail = recordOf(value);
-            if (detail?.type !== "reasoning.encrypted" || typeof detail.data !== "string") continue;
-            const id = typeof detail.id === "string" ? detail.id : null;
-            const key = typeof detail.index === "number"
-                ? `index:${detail.index}`
-                : id === null ? `anonymous:${anonymous++}` : `id:${id}`;
-            const item: AiSdkTransportResponse["reasoningEncrypted"][number] = encrypted.get(key) ?? {
-                id,
-                // {§provider-encrypted-reasoning} The documented wire location
-                // is the assistant message. `id` above still identifies only
-                // this provider detail, never a downstream message entity.
-                subtype: "message",
-                encrypted: [],
-            };
-            const format = typeof detail.format === "string" ? detail.format : null;
-            const prior = item.encrypted.at(-1);
-            if (prior !== undefined) {
-                prior.data += detail.data;
-                if (prior.format === null && format !== null) prior.format = format;
-            } else {
-                item.encrypted.push({ data: detail.data, format });
-            }
-            encrypted.set(key, item);
-        }
     }
     return {
-        reasoningEncrypted: [...encrypted.values()],
         logprobs,
         reasoning,
         reasoningProjected,

package/src/boundaries.test.ts

@@ -64,7 +64,7 @@ test("the OpenAI-compatible entrypoint excludes Node-owned provider machinery",
     ]));
 });
 
-test("the normalized-error entrypoint excludes transport and Node machinery", () => {
+test("{§provider-runtime-neutral-errors} the normalized-error entrypoint excludes transport and Node machinery", () => {
     assertRuntimeNeutralGraph("providerError.ts", new Set([
         "notices.ts",
         "providerError.ts",

package/src/capacity.test.ts

@@ -27,7 +27,7 @@ test("call-specific output tightening also tightens its reasoning subset", () =>
     );
 });
 
-test("capacity applies independent input and combined-context limits", () => {
+test("{§provider-capacity-admission} capacity applies independent input and combined-context limits", () => {
     assert.equal(effectiveInputCapacity({
         contextWindow: 100_000,
         maxInputTokens: 70_000,
@@ -61,7 +61,7 @@ test("a known combined context must leave positive input capacity", () => {
     );
 });
 
-test("only exact overflow rejects before provider I/O", () => {
+test("{§provider-capacity-admission} only exact overflow rejects before provider I/O", () => {
     const base = {
         contextWindow: 100,
         maxInputTokens: null,