@selesai/code 0.10.2 → 0.12.0

package/dist/extensions/pi-tool-display/tests/thinking-label-edge.test.ts

@@ -0,0 +1,904 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { registerThinkingLabeling } from "../src/thinking-label.ts";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+type CapturedHandler = (
+  event: unknown,
+  ctx?: unknown,
+) => Promise<void> | void;
+
+function captureThinkingHandlers(): Map<string, CapturedHandler> {
+  const handlers = new Map<string, CapturedHandler>();
+  registerThinkingLabeling({
+    on(eventName: string, handler: CapturedHandler): void {
+      handlers.set(eventName, handler);
+    },
+  } as never);
+  return handlers;
+}
+
+const PASSTHROUGH_THEME = {
+  fg: (_color: string, text: string) => text,
+};
+
+const ANSI_THEME = {
+  fg: (color: string, text: string) => `\x1b[38;2;100;200;255m[${color}]${text}\x1b[0m`,
+};
+
+// ---------------------------------------------------------------------------
+// message_update / message_end thinking-label formatting edge cases
+// ---------------------------------------------------------------------------
+
+test("message_update duplicates: single 'Thinking:' prefix is normalized away", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: [{ type: "thinking", thinking: "Thinking: reasoning about X" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.equal(event.message.content[0].thinking, "Thinking: reasoning about X");
+});
+
+test("message_update duplicates: lowercase 'thinking:' prefix is normalized away", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: [{ type: "thinking", thinking: "thinking: checking paths" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.equal(event.message.content[0].thinking, "Thinking: checking paths");
+});
+
+test("message_update duplicates: uppercase 'THINKING:' prefix is normalized away", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: [{ type: "thinking", thinking: "THINKING: uppercased reasoning" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.equal(event.message.content[0].thinking, "Thinking: uppercased reasoning");
+});
+
+test("message_update duplicates: repeated 'Thinking: Thinking:' prefix is fully stripped", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: [{ type: "thinking", thinking: "Thinking:  Thinking: double label content" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.equal(event.message.content[0].thinking, "Thinking: double label content");
+});
+
+test("message_update duplicates: interleaved case 'thinking: Thinking:' is fully stripped", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: [{ type: "thinking", thinking: "thinking: Thinking: mixed case double" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.equal(event.message.content[0].thinking, "Thinking: mixed case double");
+});
+
+test("message_update duplicates: triple label 'thinking: thinking: Thinking:' is fully stripped", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: [{ type: "thinking", thinking: "thinking: thinking: Thinking: triple" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.equal(event.message.content[0].thinking, "Thinking: triple");
+});
+
+test("message_update duplicates: indented label '  Thinking: content' is handled", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: [{ type: "thinking", thinking: "  Thinking: indented content" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.equal(event.message.content[0].thinking, "Thinking: indented content");
+});
+
+// ---------------------------------------------------------------------------
+// ANSI fragments interleaved with labels
+// ---------------------------------------------------------------------------
+
+test("message_update ANSI: SGR code before thinking label is stripped", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: [{ type: "thinking", thinking: "\x1b[31mThinking: red-tinted reasoning" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.equal(event.message.content[0].thinking, "Thinking: red-tinted reasoning");
+});
+
+test("message_update ANSI: multiple SGR codes before label are all stripped", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: [{ type: "thinking", thinking: "\x1b[1m\x1b[32mThinking: bold green label\x1b[0m" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  // stripAnsi inside stripThinkingPresentationArtifacts removes ALL ANSI codes
+  assert.equal(event.message.content[0].thinking, "Thinking: bold green label");
+});
+
+test("message_update ANSI: fragment starting with semicolon is stripped as leading artifact", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: [{ type: "thinking", thinking: ";1;31mThinking: fragment artifact content" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.equal(event.message.content[0].thinking, "Thinking: fragment artifact content");
+});
+
+test("message_update ANSI: striped background code before label is removed", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: [{ type: "thinking", thinking: "\x1b[48;5;24mThinking: bg colored reasoning" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.equal(event.message.content[0].thinking, "Thinking: bg colored reasoning");
+});
+
+test("message_update ANSI: exposed fragment after removing first label reveals second label", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: [{ type: "thinking", thinking: "\x1b[31mThinking: \x1b[0mThinking: double with ANSI between" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  // After stripping ANSI: "Thinking: Thinking: double with ANSI between"
+  // After stripping first label: "Thinking: double with ANSI between"
+  // After stripping second label: "double with ANSI between"
+  // So result should have single "Thinking: " prefix
+  assert.equal(event.message.content[0].thinking, "Thinking: double with ANSI between");
+});
+
+// ---------------------------------------------------------------------------
+// Provider API name handling
+// ---------------------------------------------------------------------------
+
+test("message_update API: anthropic-messages gets thinking prefix", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: [{ type: "thinking", thinking: "raw reasoning" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.equal(event.message.content[0].thinking, "Thinking: raw reasoning");
+});
+
+test("message_update API: openai-completions gets thinking prefix", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "openai-completions",
+      content: [{ type: "thinking", thinking: "raw reasoning" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.equal(event.message.content[0].thinking, "Thinking: raw reasoning");
+});
+
+test("message_update API: openai-responses gets thinking prefix", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "openai-responses",
+      content: [{ type: "thinking", thinking: "raw reasoning" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.equal(event.message.content[0].thinking, "Thinking: raw reasoning");
+});
+
+test("message_update API: openai-codex-responses gets thinking prefix", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "openai-codex-responses",
+      content: [{ type: "thinking", thinking: "raw reasoning" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.equal(event.message.content[0].thinking, "Thinking: raw reasoning");
+});
+
+test("message_update API: openai-chat does NOT get thinking prefix", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "openai-chat",
+      content: [{ type: "thinking", thinking: "raw reasoning" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.strictEqual(event.message.content[0].thinking, "raw reasoning");
+});
+
+test("message_update API: openai-unknown-future does NOT get thinking prefix", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "openai-unknown-future",
+      content: [{ type: "thinking", thinking: "raw reasoning" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.strictEqual(event.message.content[0].thinking, "raw reasoning");
+});
+
+test("message_update API: undefined API gets thinking prefix (default)", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      content: [{ type: "thinking", thinking: "raw reasoning" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.equal(event.message.content[0].thinking, "Thinking: raw reasoning");
+});
+
+test("message_update API: empty string API gets thinking prefix (default)", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "",
+      content: [{ type: "thinking", thinking: "raw reasoning" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.equal(event.message.content[0].thinking, "Thinking: raw reasoning");
+});
+
+test("message_update API: random non-OpenAI provider gets thinking prefix", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "custom-provider-v1",
+      content: [{ type: "thinking", thinking: "raw reasoning" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.equal(event.message.content[0].thinking, "Thinking: raw reasoning");
+});
+
+test("message_update API: anthropic-responses gets thinking prefix", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-responses",
+      content: [{ type: "thinking", thinking: "raw reasoning" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.equal(event.message.content[0].thinking, "Thinking: raw reasoning");
+});
+
+test("message_update API: anthropic-completions gets thinking prefix", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-completions",
+      content: [{ type: "thinking", thinking: "raw reasoning" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.equal(event.message.content[0].thinking, "Thinking: raw reasoning");
+});
+
+test("message_update API: unknown anthropic- prefix gets thinking prefix", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-experimental-v3",
+      content: [{ type: "thinking", thinking: "raw reasoning" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.equal(event.message.content[0].thinking, "Thinking: raw reasoning");
+});
+
+test("message_update API: case-insensitive normalization of openai-completions", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "OpenAI-Completions",
+      content: [{ type: "thinking", thinking: "raw reasoning" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.equal(event.message.content[0].thinking, "Thinking: raw reasoning");
+});
+
+// ---------------------------------------------------------------------------
+// message_end event behavior (same logic, persists labels)
+// ---------------------------------------------------------------------------
+
+test("message_end: attaches thinking label on final message", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: [{ type: "thinking", thinking: "final reasoning" }],
+    },
+  };
+
+  await handlers.get("message_end")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.equal(event.message.content[0].thinking, "Thinking: final reasoning");
+});
+
+test("message_end: respects openai-* exclusion", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "openai-chat",
+      content: [{ type: "thinking", thinking: "final reasoning" }],
+    },
+  };
+
+  await handlers.get("message_end")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.strictEqual(event.message.content[0].thinking, "final reasoning");
+});
+
+test("message_end: applies theme to label", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: [{ type: "thinking", thinking: "themed reasoning" }],
+    },
+  };
+
+  await handlers.get("message_end")?.(event, { ui: { theme: ANSI_THEME } });
+
+  assert.match(event.message.content[0].thinking, /^\x1b\[38;2;100;200;255m\[accent\]Thinking:/);
+});
+
+// ---------------------------------------------------------------------------
+// context event behavior (sanitization strips labels for LLM context)
+// ---------------------------------------------------------------------------
+
+test("context: strips thinking labels from assistant messages", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    messages: [
+      {
+        role: "assistant",
+        content: [
+          { type: "thinking", thinking: "Thinking: labeled reasoning for model" },
+        ],
+      },
+    ],
+  };
+
+  await handlers.get("context")?.(event, {});
+
+  assert.equal(event.messages[0].content[0].thinking, "labeled reasoning for model");
+});
+
+test("context: strips thinking labels even with ANSI wrapping", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    messages: [
+      {
+        role: "assistant",
+        content: [
+          { type: "thinking", thinking: "\x1b[31mThinking: \x1b[0mansi reasoning" },
+        ],
+      },
+    ],
+  };
+
+  await handlers.get("context")?.(event, {});
+
+  assert.equal(event.messages[0].content[0].thinking, "ansi reasoning");
+});
+
+test("context: preserves non-thinking blocks unchanged", async () => {
+  const handlers = captureThinkingHandlers();
+  const textBlock = { type: "text", text: "hello" };
+  const thinkingBlock = { type: "thinking", thinking: "Thinking: labeled" };
+  const event = {
+    messages: [
+      {
+        role: "assistant",
+        content: [textBlock, thinkingBlock],
+      },
+    ],
+  };
+
+  await handlers.get("context")?.(event, {});
+
+  assert.strictEqual(event.messages[0].content[0], textBlock);
+  assert.equal((event.messages[0].content[1] as { thinking: string }).thinking, "labeled");
+});
+
+test("context: does not modify non-assistant messages", async () => {
+  const handlers = captureThinkingHandlers();
+  const userMessage = { role: "user", content: "hello" };
+  const event = {
+    messages: [userMessage],
+  };
+
+  await handlers.get("context")?.(event, {});
+
+  assert.strictEqual(event.messages[0], userMessage);
+});
+
+test("context: handles events with non-array messages gracefully", async () => {
+  const handlers = captureThinkingHandlers();
+
+  // Should not throw for non-array messages
+  await handlers.get("context")?.({ messages: "not an array" }, {});
+  await handlers.get("context")?.({ messages: null }, {});
+  await handlers.get("context")?.({ messages: undefined }, {});
+  await handlers.get("context")?.({}, {});
+
+  assert.ok(true, "context handler did not throw");
+});
+
+test("context: handles events with missing messages property", async () => {
+  const handlers = captureThinkingHandlers();
+
+  await handlers.get("context")?.({ unrelated: true }, {});
+
+  assert.ok(true, "context handler did not throw on missing messages");
+});
+
+test("context: strips duplicate labels in context", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    messages: [
+      {
+        role: "assistant",
+        content: [
+          { type: "thinking", thinking: "Thinking:  Thinking: double label" },
+        ],
+      },
+    ],
+  };
+
+  await handlers.get("context")?.(event, {});
+
+  assert.equal(event.messages[0].content[0].thinking, "double label");
+});
+
+test("context: strips lowercase thinking: label", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    messages: [
+      {
+        role: "assistant",
+        content: [
+          { type: "thinking", thinking: "thinking: lowercase prefix" },
+        ],
+      },
+    ],
+  };
+
+  await handlers.get("context")?.(event, {});
+
+  assert.equal(event.messages[0].content[0].thinking, "lowercase prefix");
+});
+
+// ---------------------------------------------------------------------------
+// Malformed content arrays – handlers must be resilient
+// ---------------------------------------------------------------------------
+
+test("message_update malformed: null content array item passes through", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: [null, { type: "thinking", thinking: "reasoning" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.strictEqual(event.message.content[0], null);
+  assert.equal(event.message.content[1].thinking, "Thinking: reasoning");
+});
+
+test("message_update malformed: undefined content array item passes through", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: [undefined, { type: "thinking", thinking: "reasoning" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.strictEqual(event.message.content[0], undefined);
+  assert.equal(event.message.content[1].thinking, "Thinking: reasoning");
+});
+
+test("message_update malformed: non-array content passes through unchanged", async () => {
+  const handlers = captureThinkingHandlers();
+  const content = { type: "thinking", thinking: "not in array" };
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content,
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.strictEqual(event.message.content, content);
+});
+
+test("message_update malformed: nested array content passes through unchanged", async () => {
+  const handlers = captureThinkingHandlers();
+  // Content IS an array with a thinking block — it will be processed.
+  const nested = [{ type: "thinking", thinking: "nested reasoning" }];
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: nested,
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  // Since content is an array containing a valid thinking block, the label IS added.
+  assert.equal(event.message.content[0].thinking, "Thinking: nested reasoning");
+});
+
+test("message_update malformed: empty content array is a no-op", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: [],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.deepEqual(event.message.content, []);
+});
+
+test("message_update malformed: non-string thinking field is left untouched", async () => {
+  const handlers = captureThinkingHandlers();
+  const block = { type: "thinking", thinking: 42 as unknown as string };
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: [block],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.strictEqual(event.message.content[0].thinking, 42);
+});
+
+test("message_update malformed: block with null thinking field is left untouched", async () => {
+  const handlers = captureThinkingHandlers();
+  const block = { type: "thinking", thinking: null as unknown as string };
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: [block],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.strictEqual(event.message.content[0].thinking, null);
+});
+
+test("message_update malformed: mixed valid and invalid blocks only processes valid ones", async () => {
+  const handlers = captureThinkingHandlers();
+  const invalid = { type: "other", data: "skip" };
+  const valid = { type: "thinking", thinking: "valid reasoning" };
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: [invalid, valid, null],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.strictEqual(event.message.content[0], invalid);
+  assert.equal((event.message.content[1] as { thinking: string }).thinking, "Thinking: valid reasoning");
+  assert.strictEqual(event.message.content[2], null);
+});
+
+test("message_update malformed: content is a plain string, not array, passes through", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: "just a string, not an array of blocks",
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.equal(event.message.content, "just a string, not an array of blocks");
+});
+
+// ---------------------------------------------------------------------------
+// Non-English / custom thinking label patterns (should pass through)
+// ---------------------------------------------------------------------------
+
+test("message_update non-English: Japanese thinking label gets Thinking: prefix since pattern not matched", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: [{ type: "thinking", thinking: "思考: 日本語の推論" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  // The non-English prefix does not match /^thinking:/i so the original text
+  // is NOT deduplicated, but the standard "Thinking: " prefix IS prepended.
+  assert.equal(event.message.content[0].thinking, "Thinking: 思考: 日本語の推論");
+});
+
+test("message_update non-English: French thinking label gets Thinking: prefix", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: [{ type: "thinking", thinking: "Réflexion: raisonnement en français" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.equal(event.message.content[0].thinking, "Thinking: Réflexion: raisonnement en français");
+});
+
+test("message_update custom: 'Analyzing:' prefix gets Thinking: prefix (not matched by pattern)", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: [{ type: "thinking", thinking: "Analyzing: code structure" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.equal(event.message.content[0].thinking, "Thinking: Analyzing: code structure");
+});
+
+test("message_update custom: 'Note:' prefix gets Thinking: prefix", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: [{ type: "thinking", thinking: "Note: additional context" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.equal(event.message.content[0].thinking, "Thinking: Note: additional context");
+});
+
+// ---------------------------------------------------------------------------
+// Non-assistant role in event – should be skipped
+// ---------------------------------------------------------------------------
+
+test("message_update: non-assistant role messages are skipped", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "user",
+      api: "anthropic-messages",
+      content: [{ type: "thinking", thinking: "user thinking" }],
+    },
+  };
+
+  // Should not throw and should not modify content
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.ok(true, "non-assistant message update did not throw");
+});
+
+test("message_end: non-assistant role messages are skipped", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "user",
+      api: "anthropic-messages",
+      content: [{ type: "thinking", thinking: "user thinking end" }],
+    },
+  };
+
+  await handlers.get("message_end")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  assert.ok(true, "non-assistant message end did not throw");
+});
+
+// ---------------------------------------------------------------------------
+// No-theme fallback (plain "Thinking: " prefix)
+// ---------------------------------------------------------------------------
+
+test("message_update: no theme falls back to plain 'Thinking: ' prefix", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: [{ type: "thinking", thinking: "no theme reasoning" }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: {} });
+
+  assert.equal(event.message.content[0].thinking, "Thinking: no theme reasoning");
+});
+
+test("message_update: no theme and undefined ctx.ui is handled gracefully", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: [{ type: "thinking", thinking: "no ctx at all" }],
+    },
+  };
+
+  // ctx is undefined entirely
+  await handlers.get("message_update")?.(event, undefined);
+
+  assert.ok(true, "handled undefined ctx without throwing");
+});
+
+// ---------------------------------------------------------------------------
+// Edge: content with only whitespace after stripping
+// ---------------------------------------------------------------------------
+
+test("message_update: content that becomes empty after stripping keeps original text", async () => {
+  const handlers = captureThinkingHandlers();
+  const event = {
+    message: {
+      role: "assistant",
+      api: "anthropic-messages",
+      content: [{ type: "thinking", thinking: "Thinking:   " }],
+    },
+  };
+
+  await handlers.get("message_update")?.(event, { ui: { theme: PASSTHROUGH_THEME } });
+
+  // After stripping "Thinking:" the remainder is whitespace → trimmed to empty → keep original
+  assert.equal(event.message.content[0].thinking, "Thinking:   ");
+});