fix(strip-content): preserve thinking parts with no thinking or text fields

Defense-in-depth layer on top of PR #9 (Tom's fix that removed
redacted_thinking from CLEARED_REASONING_TYPES).

The predicate inside stripClearedReasoning treated any thinking/reasoning
part where both `thinking` and `text` fields were undefined as a cleared
shell and dropped it. That's correct for legitimate cleared shells (which
have both fields explicitly set to "[cleared]"), but wrong for edge-case
shapes where a provider emits a thinking-type part carrying only
non-standard fields like `data` or `signature`. Dropping such parts from
the latest assistant message causes Anthropic to reject the request with
'thinking or redacted_thinking blocks in the latest assistant message
cannot be modified'.

This adds a 2-line guard: if neither `thinking` nor `text` key is
present on the part, we cannot prove it is cleared, so we preserve it.
Drop-callback-cleared parts are not affected because they set existing
fields to "[cleared]" (keys remain present). No call sites change, no
new state, no watermark, no cache-bust risk.

Refs: #8, #9

Author: ualtinok

packages/plugin/src/hooks/magic-context/strip-content.test.ts

@@ -213,6 +213,33 @@ describe("strip-content", () => {
                 });
             });
         });
+
+        describe("#given a thinking part with no thinking or text fields", () => {
+            describe("#when stripping cleared reasoning", () => {
+                it("#then preserves it defensively — undefined fields are not a cleared shell", () => {
+                    // Edge-case shape: a future provider (or upstream bug) could
+                    // emit a thinking-type part carrying only non-standard fields
+                    // like `data` or `signature`, with neither `thinking` nor
+                    // `text` set. The old predicate treated "both undefined" as
+                    // "drop", which would mutate the latest assistant message and
+                    // break Anthropic replay. The guard must preserve these
+                    // parts because we cannot prove they are cleared shells.
+                    const undefinedFieldsPart = {
+                        type: "thinking",
+                        signature: "opaque-provider-signature",
+                    };
+                    const textPart = { type: "text", text: "latest response" };
+                    const msg = message("m-latest", "assistant", [undefinedFieldsPart, textPart]);
+
+                    const stripped = stripClearedReasoning([msg]);
+
+                    expect(stripped).toBe(0);
+                    expect(msg.parts).toHaveLength(2);
+                    expect(msg.parts[0]).toBe(undefinedFieldsPart);
+                    expect(msg.parts[1]).toBe(textPart);
+                });
+            });
+        });
     });
 
     describe("stripInlineThinking", () => {

packages/plugin/src/hooks/magic-context/strip-content.ts

@@ -290,6 +290,15 @@ export function stripClearedReasoning(messages: MessageLike[]): number {
             if (!isRecord(part)) return true;
             const partType = part.type as string;
             if (!CLEARED_REASONING_TYPES.has(partType)) return true;
+            // Defense-in-depth: if neither `thinking` nor `text` is present on
+            // the part, we cannot tell whether it's a cleared shell — keep it.
+            // This protects edge-case thinking shapes (e.g., future providers
+            // emitting parts with only a `data` or `signature` field) from
+            // being wrongly dropped. Anthropic requires thinking-like blocks in
+            // the latest assistant message to be replayed unchanged, and an
+            // undefined-fields part cannot be known to be cleared, so it is
+            // not safe to strip it.
+            if (!("thinking" in part) && !("text" in part)) return true;
             const thinking = "thinking" in part ? (part.thinking as string | undefined) : undefined;
             const text = "text" in part ? (part.text as string | undefined) : undefined;
             return (