@plurnk/plurnk-providers 1.19.0 → 1.19.2

package/src/AiSdkProvider.test.ts

@@ -868,71 +868,6 @@ test("{§provider-connectivity} a wedged transport that ignores the abort still
     );
 });
 
-test("compatible xAI wire usage becomes an exact tick charge without raw-body capture", async () => {
-    const p = testProvider({
-        model: "grok-test",
-        url: "http://x/v1/chat/completions",
-        fetchTimeoutMs: 5_000,
-        temperature: 0.2,
-        repeatPenalty: 1.15,
-        reasoning: { mode: "off", budget: null },
-        retryAttempts: 0,
-        streaming: false,
-        normalizeCost: providerCostNormalizer("@ai-sdk/xai"),
-    });
-    installFetchJson({
-        id: "response-1",
-        model: "grok-test",
-        choices: [{ message: { content: "ok" }, finish_reason: "stop" }],
-        usage: {
-            prompt_tokens: 2,
-            completion_tokens: 1,
-            total_tokens: 3,
-            cost_in_usd_ticks: 15_493_500,
-        },
-    });
-    const response = await p.generate({ workerId: "xai", messages: [] });
-    assert.deepEqual(response.accounting[0]?.cost, {
-        kind: "charged",
-        amount: { amount: "15493500", currency: "USDTICK" },
-        usdEquivalent: "0.00154935",
-        source: "xAI response usage.cost_in_usd_ticks",
-    });
-    assert.equal(response.rawBody, undefined);
-});
-
-test("streamed xAI final usage retains its exact tick charge", async () => {
-    const p = testProvider({
-        model: "grok-test",
-        url: "http://x/v1/chat/completions",
-        fetchTimeoutMs: 5_000,
-        temperature: 0.2,
-        repeatPenalty: 1.15,
-        reasoning: { mode: "off", budget: null },
-        retryAttempts: 0,
-        normalizeCost: providerCostNormalizer("@ai-sdk/xai"),
-    });
-    installFetch([
-        { choices: [{ delta: { content: "ok" }, finish_reason: "stop" }] },
-        {
-            choices: [],
-            usage: {
-                prompt_tokens: 2,
-                completion_tokens: 1,
-                total_tokens: 3,
-                cost_in_usd_ticks: 15_493_500,
-            },
-        },
-    ]);
-    const response = await p.generate({ workerId: "xai", messages: [] });
-    assert.deepEqual(response.accounting[0]?.cost, {
-        kind: "charged",
-        amount: { amount: "15493500", currency: "USDTICK" },
-        usdEquivalent: "0.00154935",
-        source: "xAI response usage.cost_in_usd_ticks",
-    });
-});
-
 test("generate surfaces and normalizes an out-of-set finish_reason", async () => {
     const warnings: Array<{ message: string; code?: string }> = [];
     mock.method(process, "emitWarning", (message: string | Error, options?: string | { code?: string }) => {
@@ -1058,7 +993,6 @@ test("generate aggregates reasoning deltas under multiple field names", async ()
     installFetch([{ choices: [{ delta: { reasoning_content: "be", thinking: "cause" } }] }]);
     const { assistant } = await p.generate({ workerId: "r", messages: [] });
     assert.equal(assistant.reasoning, "because");
-    assert.equal("reasoningEncrypted" in assistant, false); // open reasoning only -> field absent
 });
 
 for (const style of ["think-tags", "template-think", "template-channel"] as const) test(`{§provider-reasoning-observer} ${style} reasoning arrives while the response is still open`, async () => {
@@ -1277,60 +1211,6 @@ test("{§provider-tagged-reasoning} grammar evidence retains the exact pre-proje
     });
 });
 
-test("encrypted reasoning (non-streamed): encrypted entries normalize and text entries stay separate", async () => {
-    // The live o4-mini-via-OpenRouter shape: reasoning null, one encrypted entry.
-    installFetchJson({ model: "m", choices: [{ message: {
-        content: "4", reasoning: null,
-        reasoning_details: [
-            { type: "reasoning.encrypted", data: "gAAAAABqBLOB", format: "openai-responses-v1", id: "rs_1", index: 0 },
-            { type: "reasoning.text", text: "never surfaced here" },
-        ],
-    }, finish_reason: "stop" }], usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 } });
-    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, streaming: false });
-    const { assistant } = await p.generate({ workerId: "r", messages: [] });
-    // Wire detail ID is preserved; the assistant-message location supports the
-    // derived classification but supplies no downstream client entity ID.
-    assert.deepEqual(assistant.reasoningEncrypted, [{ id: "rs_1", subtype: "message", encrypted: [{ data: "gAAAAABqBLOB", format: "openai-responses-v1" }] }]);
-    assert.equal(assistant.reasoning, null); // Encrypted turn: nothing readable.
-    assert.equal(assistant.content, "4");
-});
-
-test("distinct encrypted-reasoning wire ids stay distinct items", async () => {
-    installFetchJson({ model: "m", choices: [{ message: { content: "ok", reasoning: null, reasoning_details: [
-        { type: "reasoning.encrypted", data: "AAA", format: "openai-responses-v1", id: "rs_1" },
-        { type: "reasoning.encrypted", data: "BBB", format: "openai-responses-v1", id: "rs_2" },
-    ] }, finish_reason: "stop" }], usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 } });
-    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, streaming: false });
-    const { assistant } = await p.generate({ workerId: "r", messages: [] });
-    assert.equal(assistant.reasoningEncrypted?.length, 2);
-    assert.deepEqual(assistant.reasoningEncrypted?.map((i) => i.id), ["rs_1", "rs_2"]);
-});
-
-test("assistant-message location classifies encrypted reasoning without inventing a missing detail id", async () => {
-    installFetchJson({ model: "m", choices: [{ message: { content: "ok", reasoning_details: [
-        { type: "reasoning.encrypted", data: "OPAQUE", format: "openai-responses-v1", id: null, index: 0 },
-    ] }, finish_reason: "stop" }], usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 } });
-    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0, streaming: false });
-    const { assistant } = await p.generate({ workerId: "r", messages: [] });
-    assert.deepEqual(assistant.reasoningEncrypted, [{
-        id: null,
-        subtype: "message",
-        encrypted: [{ data: "OPAQUE", format: "openai-responses-v1" }],
-    }]);
-});
-
-test("encrypted reasoning (streamed): chunked blob concatenates per entry index", async () => {
-    const p = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "off", budget: null }, retryAttempts: 0 });
-    installFetch([
-        { choices: [{ delta: { reasoning_details: [{ type: "reasoning.encrypted", data: "gAAAA", format: "openai-responses-v1", id: "rs_1", index: 0 }] } }] },
-        { choices: [{ delta: { reasoning_details: [{ type: "reasoning.encrypted", data: "BqXYZ", id: "rs_1", index: 0 }] } }] },
-        { choices: [{ delta: { content: "4" }, finish_reason: "stop" }] },
-    ]);
-    const { assistant } = await p.generate({ workerId: "r", messages: [] });
-    assert.deepEqual(assistant.reasoningEncrypted, [{ id: "rs_1", subtype: "message", encrypted: [{ data: "gAAAABqXYZ", format: "openai-responses-v1" }] }]);
-    assert.equal(assistant.content, "4");
-});
-
 test("reasoningStyle 'think' follows activation (magnitude is irrelevant to the boolean wire control)", async () => {
     const on = testProvider({ model: "m", url: "http://x/v1/chat/completions", fetchTimeoutMs: 5000, temperature: 0.2, repeatPenalty: 1.15, reasoning: { mode: "adaptive", budget: null }, retryAttempts: 0, reasoningStyle: "think" });
     let calls = installFetch([{ choices: [{ delta: { content: "x" } }] }]);

package/src/AiSdkProvider.ts

@@ -54,7 +54,7 @@ const raceAgainstDeadline = async <T>(work: PromiseLike<T>, signal: AbortSignal)
 
 // Backend wire spellings for the resolved reasoning intent. The switch beside each
 // mapping retains any backend-specific omission/explicit-disable constraint.
-export type ReasoningStyle = "none" | "think" | "include_reasoning" | "effort" | "effort_explicit" | "effort_required" | "thinking_effort" | "thinking_config" | "template" | "anthropic";
+export type ReasoningStyle = "none" | "think" | "include_reasoning" | "effort" | "effort_explicit" | "effort_required" | "thinking_effort" | "template" | "anthropic";
 
 export type NativeReasoningEffort = "minimal" | "low" | "medium" | "high" | "xhigh";
 export type CompatibleReasoningEffort = NativeReasoningEffort | "max";
@@ -993,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

@@ -201,14 +201,6 @@ export default class AiSdkRequestBody {
                     thinking: { type: "enabled" },
                     reasoning_effort: fixedEffort(mode),
                 };
-            // {§google-reasoning-request} — Gemini's OpenAI-compatible extension. Readable
-            // thoughts ride on every reasoning request; Gemini refuses `reasoning_effort` beside a
-            // thinking_config, so the level travels inside it. Gemini cannot turn reasoning off.
-            case "thinking_config": {
-                if (mode === "off") throw new TypeError(`${this.#source}: thinking_config reasoning has no off projection`);
-                const level = mode === "adaptive" ? {} : { thinking_level: fixedEffort(mode) };
-                return { extra_body: { google: { thinking_config: { include_thoughts: true, ...level } } } };
-            }
             // Anthropic-compatible native dynamic or manual budget mode.
             case "anthropic": return mode === "off"
                 ? { thinking: { type: "disabled" } }

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
@@ -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 } : {}),

package/src/accounting.test.ts

@@ -16,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);
@@ -49,10 +38,10 @@ test("DeepInfra's documented response estimate remains estimated", () => {
 
 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

@@ -31,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;
@@ -84,7 +59,6 @@ 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

@@ -417,64 +417,3 @@ test("inconsistent usage counters refuse normalization without failing the respo
     });
 });
 
-test("{§google-thought-response}: Gemini's flagged thought content is reasoning, never emission", async (t) => {
-    const chunk = (delta: Record<string, unknown>, extra: Record<string, unknown> = {}) => ({
-        id: "gemini-1", object: "chat.completion.chunk", created: 1, model: "gemini-3.8-flash",
-        choices: [{ index: 0, delta, finish_reason: null }], ...extra,
-    });
-    const thought = (content: string) => ({ role: "assistant", content, extra_content: { google: { thought: true } } });
-    const sse = (chunks: object[]) => `${chunks.map((c) => `data: ${JSON.stringify(c)}\n\n`).join("")}data: [DONE]\n\n`;
-
-    await t.test("streamed: flagged deltas are observed and settled as reasoning; the answer stays clean", async () => {
-        const reasoning: string[] = [];
-        const text: string[] = [];
-        const result = await executeOpenAICompatible({
-            ...request,
-            streaming: true,
-            observeReasoning: (delta) => reasoning.push(delta),
-            observeText: (delta) => text.push(delta),
-            fetch: async () => new Response(sse([
-                chunk(thought("<thought>**Checking 391**\n\n")),
-                chunk(thought("17 × 23 = 391.")),
-                chunk({ content: "</thought>No. " }),
-                chunk({ content: "391 = 17 × 23.", extra_content: { google: { thought_signature: "c2ln" } } }),
-                { ...chunk({}), choices: [{ index: 0, delta: {}, finish_reason: "stop" }], usage: { prompt_tokens: 5, completion_tokens: 8, total_tokens: 90 } },
-            ]), { headers: { "content-type": "text/event-stream" } }),
-        });
-        assert.equal(result.content, "No. 391 = 17 × 23.");
-        assert.equal(result.reasoning, "**Checking 391**\n\n17 × 23 = 391.");
-        assert.equal(result.reasoningProjected, true);
-        assert.deepEqual(reasoning, ["**Checking 391**\n\n", "17 × 23 = 391."]);
-        assert.deepEqual(text, ["No. ", "391 = 17 × 23."]);
-    });
-
-    await t.test("whole: the flagged message's leading <thought> wrapper is reasoning and the remainder is content", async () => {
-        const result = await executeOpenAICompatible({
-            ...request,
-            fetch: async () => new Response(JSON.stringify({
-                id: "gemini-2", object: "chat.completion", created: 1, model: "gemini-3.8-flash",
-                choices: [{ index: 0, finish_reason: "stop", message: {
-                    role: "assistant",
-                    content: "<thought>**Checking 391**\n17 × 23 = 391.</thought>No. It is divisible by 17 and 23.",
-                    extra_content: { google: { thought: true, thought_signature: "c2ln" } },
-                } }],
-                usage: { prompt_tokens: 5, completion_tokens: 9, total_tokens: 90 },
-            }), { headers: { "content-type": "application/json" } }),
-        });
-        assert.equal(result.content, "No. It is divisible by 17 and 23.");
-        assert.equal(result.reasoning, "**Checking 391**\n17 × 23 = 391.");
-        assert.equal(result.reasoningProjected, true);
-    });
-
-    await t.test("unflagged content is never inspected for the wrapper", async () => {
-        const result = await executeOpenAICompatible({
-            ...request,
-            fetch: async () => new Response(JSON.stringify({
-                id: "plain", object: "chat.completion", created: 1, model: "m",
-                choices: [{ index: 0, finish_reason: "stop", message: { role: "assistant", content: "<thought>literal</thought>tail" } }],
-            }), { headers: { "content-type": "application/json" } }),
-        });
-        assert.equal(result.content, "<thought>literal</thought>tail");
-        assert.equal(result.reasoning, "");
-    });
-});

package/src/aiSdkTransport.ts

@@ -162,38 +162,6 @@ const recordOf = (value: unknown): Record<string, unknown> | null =>
         ? value as Record<string, unknown>
         : null;
 
-// {§google-thought-response} — Gemini behind an OpenAI-compatible endpoint returns its readable
-// thought summary as ordinary `content` wrapped `<thought>…</thought>` and flagged
-// `extra_content.google.thought`. Whole, the flagged message holds wrapper and answer; streamed,
-// the flagged deltas hold `<thought>` and the thought, and the first unflagged delta opens with
-// `</thought>` before the answer.
-const googleThoughtFlagged = (message: Record<string, unknown> | null): boolean =>
-    recordOf(recordOf(message?.extra_content)?.google)?.thought === true;
-
-const THOUGHT_OPEN = "<thought>";
-const THOUGHT_CLOSE = "</thought>";
-const splitGoogleThought = (content: string): { thought: string; answer: string } | null => {
-    if (!content.startsWith(THOUGHT_OPEN)) return null;
-    const close = content.indexOf(THOUGHT_CLOSE);
-    if (close === -1) return null;
-    return { thought: content.slice(THOUGHT_OPEN.length, close), answer: content.slice(close + THOUGHT_CLOSE.length) };
-};
-
-const unwrapThoughtDelta = (text: string): string => {
-    const opened = text.startsWith(THOUGHT_OPEN) ? text.slice(THOUGHT_OPEN.length) : text;
-    return opened.endsWith(THOUGHT_CLOSE) ? opened.slice(0, -THOUGHT_CLOSE.length) : opened;
-};
-
-const rawChunkThought = (value: unknown): boolean => {
-    const choices = recordOf(value)?.choices;
-    return Array.isArray(choices) && googleThoughtFlagged(recordOf(recordOf(choices[0])?.delta));
-};
-
-const wholeResponseThought = (values: readonly unknown[]): boolean => values.some((value) => {
-    const choices = recordOf(value)?.choices;
-    return Array.isArray(choices) && googleThoughtFlagged(recordOf(recordOf(choices[0])?.message));
-});
-
 const metadataOf = (values: readonly unknown[]): Record<string, unknown> => {
     const metadata: Record<string, unknown> = {};
     for (const value of values) {
@@ -233,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;
@@ -495,17 +458,15 @@ const executeModelOnce = async (
         const accountingUsage = wireUsageEvidenceOf(values);
         const reasoningText = evidence.reasoning || result.reasoningText || "";
         const rawFinishReason = result.rawFinishReason;
-        const thought = wholeResponseThought(values) ? splitGoogleThought(result.text) : null;
         return {
             model: result.response.modelId,
-            content: thought === null ? result.text : thought.answer,
+            content: result.text,
             reasoning: reasoningText,
             reasoningProjected: evidence.reasoningProjected,
             finishReason: finishReasonOf(rawFinishReason),
             ...(rawFinishReason === undefined ? {} : { rawFinishReason }),
             ...settledUsage(values, result.usage),
             metadata: metadataOf(values),
-            reasoningEncrypted: evidence.reasoningEncrypted,
             logprobs: evidence.logprobs,
             chargeEvidence: {
                 ...(wireChargeEvidenceOf(values) === undefined
@@ -535,31 +496,17 @@ const executeModelOnce = async (
     const rawChunks: unknown[] = [];
     let streamError: unknown;
     let outputObserved = false;
-    // The SDK enqueues each raw chunk before the deltas it yields, so the latest raw chunk's
-    // thought flag classifies the text deltas that follow ({§google-thought-response}).
-    let thoughtChunk = false;
-    let thoughtSeen = false;
     let answer = "";
     try {
         for await (const part of result.fullStream) {
             if (part.type === "raw") {
                 rawChunks.push(part.rawValue);
-                thoughtChunk = rawChunkThought(part.rawValue);
             }
             if (part.type === "text-delta" && part.text.length > 0) {
                 outputObserved = true;
                 liftAttemptDeadline();
-                if (thoughtChunk) {
-                    thoughtSeen = true;
-                    const thought = unwrapThoughtDelta(part.text);
-                    if (thought.length > 0) request.observeReasoning?.(thought);
-                } else {
-                    const text = thoughtSeen && answer.length === 0 && part.text.startsWith(THOUGHT_CLOSE)
-                        ? part.text.slice(THOUGHT_CLOSE.length)
-                        : part.text;
-                    answer += text;
-                    if (text.length > 0) request.observeText?.(text);
-                }
+                answer += part.text;
+                request.observeText?.(part.text);
             }
             if (part.type === "reasoning-delta" && part.text.length > 0) {
                 outputObserved = true;
@@ -580,7 +527,7 @@ const executeModelOnce = async (
     }
     const evidence = extractEvidence(rawChunks);
     const accountingUsage = wireUsageEvidenceOf(rawChunks);
-    const content = thoughtSeen ? answer : await result.text;
+    const content = await result.text;
     const reasoningText = evidence.reasoning || (await result.reasoningText) || "";
     const rawFinishReason = await result.rawFinishReason;
     const [response, providerMetadata, warnings] = await Promise.all([
@@ -597,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
@@ -704,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;
@@ -746,42 +689,8 @@ const extractEvidence = (values: unknown[]): {
                 reasoning += message[key];
             }
         }
-        if (googleThoughtFlagged(message) && typeof message.content === "string") {
-            const thought = delta !== null ? unwrapThoughtDelta(message.content) : splitGoogleThought(message.content)?.thought;
-            if (thought !== undefined) {
-                reasoningProjected = true;
-                reasoning += thought;
-            }
-        }
-        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,