@vacbo/opencode-anthropic-fix 0.1.3 → 0.1.4

package/src/config.test.ts

@@ -41,6 +41,10 @@ describe("DEFAULT_CONFIG", () => {
     expect(DEFAULT_CONFIG.signature_emulation.prompt_compaction).toBe("minimal");
   });
 
+  it("disables sanitize_system_prompt by default", () => {
+    expect(DEFAULT_CONFIG.signature_emulation.sanitize_system_prompt).toBe(false);
+  });
+
   it("has toast defaults", () => {
     expect(DEFAULT_CONFIG.toasts.quiet).toBe(false);
     expect(DEFAULT_CONFIG.toasts.debounce_seconds).toBe(30);
@@ -391,3 +395,113 @@ describe("loadConfig", () => {
     expect(config.cc_credential_reuse.auto_detect).toBe(false);
   });
 });
+
+describe("loadConfig - sanitize_system_prompt field", () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+    delete process.env.OPENCODE_ANTHROPIC_SANITIZE_SYSTEM_PROMPT;
+  });
+
+  afterEach(() => {
+    delete process.env.OPENCODE_ANTHROPIC_SANITIZE_SYSTEM_PROMPT;
+  });
+
+  it("honors nested signature_emulation.sanitize_system_prompt = true", () => {
+    mockExistsSync.mockReturnValue(true);
+    mockReadFileSync.mockReturnValue(
+      JSON.stringify({
+        signature_emulation: { sanitize_system_prompt: true },
+      }),
+    );
+    const config = loadConfig();
+    expect(config.signature_emulation.sanitize_system_prompt).toBe(true);
+  });
+
+  it("honors nested signature_emulation.sanitize_system_prompt = false", () => {
+    mockExistsSync.mockReturnValue(true);
+    mockReadFileSync.mockReturnValue(
+      JSON.stringify({
+        signature_emulation: { sanitize_system_prompt: false },
+      }),
+    );
+    const config = loadConfig();
+    expect(config.signature_emulation.sanitize_system_prompt).toBe(false);
+  });
+
+  it("honors top-level sanitize_system_prompt alias = true", () => {
+    mockExistsSync.mockReturnValue(true);
+    mockReadFileSync.mockReturnValue(
+      JSON.stringify({
+        sanitize_system_prompt: true,
+      }),
+    );
+    const config = loadConfig();
+    expect(config.signature_emulation.sanitize_system_prompt).toBe(true);
+  });
+
+  it("honors top-level sanitize_system_prompt alias = false (the user's existing config)", () => {
+    mockExistsSync.mockReturnValue(true);
+    mockReadFileSync.mockReturnValue(
+      JSON.stringify({
+        debug: false,
+        sanitize_system_prompt: false,
+      }),
+    );
+    const config = loadConfig();
+    expect(config.signature_emulation.sanitize_system_prompt).toBe(false);
+    expect(config.debug).toBe(false);
+  });
+
+  it("top-level alias takes precedence over nested signature_emulation.sanitize_system_prompt", () => {
+    mockExistsSync.mockReturnValue(true);
+    mockReadFileSync.mockReturnValue(
+      JSON.stringify({
+        signature_emulation: { sanitize_system_prompt: true },
+        sanitize_system_prompt: false,
+      }),
+    );
+    const config = loadConfig();
+    expect(config.signature_emulation.sanitize_system_prompt).toBe(false);
+  });
+
+  it("ignores non-boolean top-level sanitize_system_prompt value", () => {
+    mockExistsSync.mockReturnValue(true);
+    mockReadFileSync.mockReturnValue(
+      JSON.stringify({
+        sanitize_system_prompt: "yes",
+      }),
+    );
+    const config = loadConfig();
+    expect(config.signature_emulation.sanitize_system_prompt).toBe(false);
+  });
+
+  it("OPENCODE_ANTHROPIC_SANITIZE_SYSTEM_PROMPT=1 forces it on", () => {
+    mockExistsSync.mockReturnValue(true);
+    mockReadFileSync.mockReturnValue(JSON.stringify({ sanitize_system_prompt: false }));
+    process.env.OPENCODE_ANTHROPIC_SANITIZE_SYSTEM_PROMPT = "1";
+    const config = loadConfig();
+    expect(config.signature_emulation.sanitize_system_prompt).toBe(true);
+  });
+
+  it("OPENCODE_ANTHROPIC_SANITIZE_SYSTEM_PROMPT=0 forces it off", () => {
+    mockExistsSync.mockReturnValue(true);
+    mockReadFileSync.mockReturnValue(JSON.stringify({ sanitize_system_prompt: true }));
+    process.env.OPENCODE_ANTHROPIC_SANITIZE_SYSTEM_PROMPT = "0";
+    const config = loadConfig();
+    expect(config.signature_emulation.sanitize_system_prompt).toBe(false);
+  });
+
+  it("OPENCODE_ANTHROPIC_SANITIZE_SYSTEM_PROMPT=true forces it on", () => {
+    mockExistsSync.mockReturnValue(false);
+    process.env.OPENCODE_ANTHROPIC_SANITIZE_SYSTEM_PROMPT = "true";
+    const config = loadConfig();
+    expect(config.signature_emulation.sanitize_system_prompt).toBe(true);
+  });
+
+  it("OPENCODE_ANTHROPIC_SANITIZE_SYSTEM_PROMPT=false forces it off", () => {
+    mockExistsSync.mockReturnValue(false);
+    process.env.OPENCODE_ANTHROPIC_SANITIZE_SYSTEM_PROMPT = "false";
+    const config = loadConfig();
+    expect(config.signature_emulation.sanitize_system_prompt).toBe(false);
+  });
+});

package/src/config.ts

@@ -60,6 +60,7 @@ export interface AnthropicAuthConfig {
     enabled: boolean;
     fetch_claude_code_version_on_startup: boolean;
     prompt_compaction: "minimal" | "off";
+    sanitize_system_prompt: boolean;
   };
   override_model_limits: OverrideModelLimitsConfig;
   custom_betas: string[];
@@ -83,6 +84,7 @@ export const DEFAULT_CONFIG: AnthropicAuthConfig = {
     enabled: true,
     fetch_claude_code_version_on_startup: true,
     prompt_compaction: "minimal",
+    sanitize_system_prompt: false,
   },
   override_model_limits: {
     enabled: true,
@@ -193,9 +195,21 @@ function validateConfig(raw: Record<string, unknown>): AnthropicAuthConfig {
         se.prompt_compaction === "off" || se.prompt_compaction === "minimal"
           ? se.prompt_compaction
           : DEFAULT_CONFIG.signature_emulation.prompt_compaction,
+      sanitize_system_prompt:
+        typeof se.sanitize_system_prompt === "boolean"
+          ? se.sanitize_system_prompt
+          : DEFAULT_CONFIG.signature_emulation.sanitize_system_prompt,
     };
   }
 
+  // Top-level alias: `sanitize_system_prompt` is honored as a convenience so
+  // users can flip it on/off without learning the nested signature_emulation
+  // schema. The top-level value, when set, takes precedence over the nested
+  // one because it's the more specific user intent.
+  if (typeof raw.sanitize_system_prompt === "boolean") {
+    config.signature_emulation.sanitize_system_prompt = raw.sanitize_system_prompt;
+  }
+
   if (raw.override_model_limits && typeof raw.override_model_limits === "object") {
     const oml = raw.override_model_limits as Record<string, unknown>;
     config.override_model_limits = {
@@ -368,6 +382,19 @@ function applyEnvOverrides(config: AnthropicAuthConfig): AnthropicAuthConfig {
     config.signature_emulation.prompt_compaction = "minimal";
   }
 
+  if (
+    env.OPENCODE_ANTHROPIC_SANITIZE_SYSTEM_PROMPT === "1" ||
+    env.OPENCODE_ANTHROPIC_SANITIZE_SYSTEM_PROMPT === "true"
+  ) {
+    config.signature_emulation.sanitize_system_prompt = true;
+  }
+  if (
+    env.OPENCODE_ANTHROPIC_SANITIZE_SYSTEM_PROMPT === "0" ||
+    env.OPENCODE_ANTHROPIC_SANITIZE_SYSTEM_PROMPT === "false"
+  ) {
+    config.signature_emulation.sanitize_system_prompt = false;
+  }
+
   if (env.OPENCODE_ANTHROPIC_OVERRIDE_MODEL_LIMITS === "1" || env.OPENCODE_ANTHROPIC_OVERRIDE_MODEL_LIMITS === "true") {
     config.override_model_limits.enabled = true;
   }

package/src/env.ts

@@ -99,19 +99,42 @@ export function logTransformedSystemPrompt(body: string | undefined): void {
     const parsed = JSON.parse(body);
     if (!Object.hasOwn(parsed, "system")) return;
     // Avoid circular import: inline the title-check here
+    const isTitleGeneratorText = (text: unknown): boolean => {
+      if (typeof text !== "string") return false;
+      const lowered = text.trim().toLowerCase();
+      return lowered.includes("you are a title generator") || lowered.includes("generate a brief title");
+    };
+
     const system = parsed.system;
     if (
       Array.isArray(system) &&
-      system.some(
-        (item: { type?: string; text?: string }) =>
-          item.type === "text" &&
-          typeof item.text === "string" &&
-          (item.text.trim().toLowerCase().includes("you are a title generator") ||
-            item.text.trim().toLowerCase().includes("generate a brief title")),
-      )
+      system.some((item: { type?: string; text?: string }) => item.type === "text" && isTitleGeneratorText(item.text))
     ) {
       return;
     }
+
+    // The plugin relocates non-CC system blocks into the first user message
+    // wrapped in <system-instructions>. Check there too so title-generator
+    // requests are still suppressed from the debug log after the relocation
+    // pass runs.
+    const messages = parsed.messages;
+    if (Array.isArray(messages) && messages.length > 0) {
+      const firstMsg = messages[0];
+      if (firstMsg && firstMsg.role === "user") {
+        const content = firstMsg.content;
+        if (typeof content === "string" && isTitleGeneratorText(content)) {
+          return;
+        }
+        if (Array.isArray(content)) {
+          for (const block of content) {
+            if (block && typeof block === "object" && isTitleGeneratorText((block as { text?: unknown }).text)) {
+              return;
+            }
+          }
+        }
+      }
+    }
+
     // eslint-disable-next-line no-console -- explicit debug logger gated by OPENCODE_ANTHROPIC_DEBUG_SYSTEM_PROMPT
     console.error(
       "[opencode-anthropic-auth][system-debug] transformed system:",

package/src/index.ts

@@ -71,6 +71,7 @@ export async function AnthropicAuthPlugin({
   const signatureEmulationEnabled = config.signature_emulation.enabled;
   const promptCompactionMode =
     config.signature_emulation.prompt_compaction === "off" ? ("off" as const) : ("minimal" as const);
+  const signatureSanitizeSystemPrompt = config.signature_emulation.sanitize_system_prompt === true;
   const shouldFetchClaudeCodeVersion =
     signatureEmulationEnabled && config.signature_emulation.fetch_claude_code_version_on_startup;
 
@@ -456,6 +457,7 @@ export async function AnthropicAuthPlugin({
                       enabled: signatureEmulationEnabled,
                       claudeCliVersion,
                       promptCompactionMode,
+                      sanitizeSystemPrompt: signatureSanitizeSystemPrompt,
                     },
                     {
                       persistentUserId: signatureUserId,
@@ -479,6 +481,7 @@ export async function AnthropicAuthPlugin({
                   enabled: signatureEmulationEnabled,
                   claudeCliVersion,
                   promptCompactionMode,
+                  sanitizeSystemPrompt: signatureSanitizeSystemPrompt,
                   customBetas: config.custom_betas,
                   strategy: config.account_selection_strategy,
                 });

package/src/request/body.history.test.ts

@@ -126,13 +126,22 @@ describe("transformRequestBody - body cloning for retries", () => {
       tools: [{ name: "read_file", description: "Read a file" }],
     });
 
-    const result1 = transformRequestBody(originalBody, mockSignature, mockRuntime);
-    const result2 = transformRequestBody(originalBody, mockSignature, mockRuntime);
-
-    // Both calls should produce identical results from same input
-    expect(result1).toBe(result2);
+    // The cch billing hash mixes Date.now() into its input (src/headers/billing.ts)
+    // to mimic CC's per-request attestation. Freeze the clock so the two calls
+    // produce byte-identical output and this test stays about clone-safety, not
+    // about an accidental millisecond collision. Without this, the idempotency
+    // assertion flakes whenever the two calls cross a millisecond boundary under
+    // load (husky pre-push, CI workers, etc.).
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-01-01T00:00:00.000Z"));
+    try {
+      const result1 = transformRequestBody(originalBody, mockSignature, mockRuntime);
+      const result2 = transformRequestBody(originalBody, mockSignature, mockRuntime);
+      expect(result1).toBe(result2);
+    } finally {
+      vi.useRealTimers();
+    }
 
-    // Original should be unchanged
     const parsedOriginal = JSON.parse(originalBody);
     expect(parsedOriginal.tools[0].name).toBe("read_file");
   });
@@ -147,14 +156,22 @@ describe("transformRequestBody - body cloning for retries", () => {
       messages: [{ role: "user", content: "test" }],
     });
 
-    // First attempt
-    const result1 = transformRequestBody(body, mockSignature, mockRuntime);
-    expect(result1).toBeDefined();
-
-    // Retry attempt - should work with same body
-    const result2 = transformRequestBody(body, mockSignature, mockRuntime);
-    expect(result2).toBeDefined();
-    expect(result1).toBe(result2);
+    // Same Date.now()-in-cch flake as the clone-safety test above. Freeze the
+    // clock so two transformRequestBody calls on the same body produce
+    // byte-identical output. See src/headers/billing.ts:59 for why the hash
+    // is time-mixed, and the clone-safety test above for the full rationale.
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-01-01T00:00:00.000Z"));
+    try {
+      const result1 = transformRequestBody(body, mockSignature, mockRuntime);
+      expect(result1).toBeDefined();
+
+      const result2 = transformRequestBody(body, mockSignature, mockRuntime);
+      expect(result2).toBeDefined();
+      expect(result1).toBe(result2);
+    } finally {
+      vi.useRealTimers();
+    }
   });
 });
 
@@ -232,7 +249,14 @@ describe("transformRequestBody - structure preservation", () => {
     expect(parsed.model).toBe("claude-sonnet-4-20250514");
     expect(parsed.max_tokens).toBe(4096);
     expect(parsed.temperature).toBe(0.7);
-    expect(parsed.system.some((block: { text?: string }) => block.text === "You are helpful")).toBe(true);
+    // The original "You are helpful" block was relocated to the first user
+    // message wrapper. parsed.system now only contains billing + identity.
+    expect(parsed.system.some((block: { text?: string }) => block.text === "You are helpful")).toBe(false);
+    const firstUserContent = parsed.messages[0].content;
+    const wrappedText = typeof firstUserContent === "string" ? firstUserContent : firstUserContent[0].text;
+    expect(wrappedText).toContain("<system-instructions>");
+    expect(wrappedText).toContain("You are helpful");
+    // Original messages are preserved alongside the prepended wrapper text.
     expect(parsed.messages).toHaveLength(2);
     expect(parsed.metadata.user_id).toContain('"device_id":"user-123"');
     expect(parsed.metadata.user_id).toContain('"account_uuid":"acc-456"');
@@ -396,3 +420,235 @@ describe("extractToolNamesFromBody", () => {
     expect(() => extractToolNamesFromBody("not json")).toThrow();
   });
 });
+
+describe("transformRequestBody - aggressive system block relocation", () => {
+  it("keeps only billing + identity blocks in parsed.system", () => {
+    const body = JSON.stringify({
+      model: "claude-sonnet-4-20250514",
+      messages: [{ role: "user", content: "hi" }],
+      system: [
+        { type: "text", text: "You are a helpful assistant." },
+        { type: "text", text: "Working dir: /Users/vacbo/Documents/Projects/opencode-anthropic-fix" },
+        { type: "text", text: "Plugin: @vacbo/opencode-anthropic-fix v0.1.3" },
+      ],
+    });
+
+    const result = transformRequestBody(body, mockSignature, mockRuntime);
+    const parsed = JSON.parse(result!);
+
+    // System contains exactly 2 blocks: billing header + identity string.
+    expect(parsed.system).toHaveLength(2);
+    expect(parsed.system[0].text).toMatch(/^x-anthropic-billing-header:/);
+    expect(parsed.system[1].text).toBe("You are Claude Code, Anthropic's official CLI for Claude.");
+
+    // None of the original third-party blocks survived in system.
+    const systemTexts = parsed.system.map((b: { text: string }) => b.text);
+    expect(systemTexts.some((t: string) => t.includes("helpful assistant"))).toBe(false);
+    expect(systemTexts.some((t: string) => t.includes("Working dir:"))).toBe(false);
+    expect(systemTexts.some((t: string) => t.includes("Plugin:"))).toBe(false);
+  });
+
+  it("relocates non-CC system blocks into the first user message wrapped in <system-instructions>", () => {
+    const body = JSON.stringify({
+      model: "claude-sonnet-4-20250514",
+      messages: [{ role: "user", content: "what do you know about the codebase?" }],
+      system: [
+        { type: "text", text: "You are a helpful assistant." },
+        { type: "text", text: "Working dir: /Users/vacbo/Documents/Projects/opencode-anthropic-fix" },
+      ],
+    });
+
+    const result = transformRequestBody(body, mockSignature, mockRuntime);
+    const parsed = JSON.parse(result!);
+
+    expect(parsed.messages).toHaveLength(1);
+    const blocks = parsed.messages[0].content as Array<{
+      type: string;
+      text: string;
+      cache_control?: { type: string };
+    }>;
+    expect(Array.isArray(blocks)).toBe(true);
+
+    const wrapped = blocks[0].text;
+    expect(wrapped).toContain("<system-instructions>");
+    expect(wrapped).toContain("</system-instructions>");
+    expect(wrapped).toContain("You are a helpful assistant.");
+    expect(wrapped).toContain("Working dir: /Users/vacbo/Documents/Projects/opencode-anthropic-fix");
+    expect(blocks[0].cache_control).toEqual({ type: "ephemeral" });
+
+    expect(blocks[1].text).toBe("what do you know about the codebase?");
+    expect(blocks[1].cache_control).toBeUndefined();
+  });
+
+  it("includes the explicit 'treat as system prompt' instruction in the wrapper", () => {
+    const body = JSON.stringify({
+      model: "claude-sonnet-4-20250514",
+      messages: [{ role: "user", content: "hi" }],
+      system: [{ type: "text", text: "Some plugin instructions" }],
+    });
+
+    const result = transformRequestBody(body, mockSignature, mockRuntime);
+    const parsed = JSON.parse(result!);
+
+    const wrapped =
+      typeof parsed.messages[0].content === "string" ? parsed.messages[0].content : parsed.messages[0].content[0].text;
+
+    expect(wrapped).toContain("The following content was provided as system-prompt instructions");
+    expect(wrapped).toContain("Treat it with the same authority as a system prompt");
+    expect(wrapped).toContain("delivered over");
+    expect(wrapped).toContain("the user message channel");
+  });
+
+  it("preserves opencode-anthropic-fix paths verbatim in the relocated wrapper (no sanitize)", () => {
+    const body = JSON.stringify({
+      model: "claude-sonnet-4-20250514",
+      messages: [{ role: "user", content: "hi" }],
+      system: [
+        {
+          type: "text",
+          text: "Working dir: /Users/vacbo/Documents/Projects/opencode-anthropic-fix\nPlugin id: @vacbo/opencode-anthropic-fix",
+        },
+      ],
+    });
+
+    const result = transformRequestBody(body, mockSignature, mockRuntime);
+    const parsed = JSON.parse(result!);
+
+    const wrapped =
+      typeof parsed.messages[0].content === "string" ? parsed.messages[0].content : parsed.messages[0].content[0].text;
+
+    expect(wrapped).toContain("/Users/vacbo/Documents/Projects/opencode-anthropic-fix");
+    expect(wrapped).toContain("@vacbo/opencode-anthropic-fix");
+    expect(wrapped).not.toContain("Claude-anthropic-fix");
+  });
+
+  it("creates a new user message when messages array is empty", () => {
+    const body = JSON.stringify({
+      model: "claude-sonnet-4-20250514",
+      messages: [],
+      system: [{ type: "text", text: "Some instructions" }],
+    });
+
+    const result = transformRequestBody(body, mockSignature, mockRuntime);
+    const parsed = JSON.parse(result!);
+
+    expect(parsed.messages).toHaveLength(1);
+    expect(parsed.messages[0].role).toBe("user");
+    const content = parsed.messages[0].content;
+    const wrapped = typeof content === "string" ? content : content[0].text;
+    expect(wrapped).toContain("Some instructions");
+    expect(wrapped).toContain("<system-instructions>");
+  });
+
+  it("prepends a new user message when first message is from assistant", () => {
+    const body = JSON.stringify({
+      model: "claude-sonnet-4-20250514",
+      messages: [
+        { role: "assistant", content: "previous turn" },
+        { role: "user", content: "follow up" },
+      ],
+      system: [{ type: "text", text: "Plugin instructions" }],
+    });
+
+    const result = transformRequestBody(body, mockSignature, mockRuntime);
+    const parsed = JSON.parse(result!);
+
+    expect(parsed.messages).toHaveLength(3);
+    expect(parsed.messages[0].role).toBe("user");
+    const wrapped =
+      typeof parsed.messages[0].content === "string" ? parsed.messages[0].content : parsed.messages[0].content[0].text;
+    expect(wrapped).toContain("<system-instructions>");
+    expect(wrapped).toContain("Plugin instructions");
+    // Original turns survive in order.
+    expect(parsed.messages[1].role).toBe("assistant");
+    expect(parsed.messages[1].content).toBe("previous turn");
+    expect(parsed.messages[2].role).toBe("user");
+    expect(parsed.messages[2].content).toBe("follow up");
+  });
+
+  it("merges relocated wrapper into the first user message when content is a string", () => {
+    const body = JSON.stringify({
+      model: "claude-sonnet-4-20250514",
+      messages: [{ role: "user", content: "the original user request" }],
+      system: [{ type: "text", text: "Plugin instructions" }],
+    });
+
+    const result = transformRequestBody(body, mockSignature, mockRuntime);
+    const parsed = JSON.parse(result!);
+
+    expect(parsed.messages).toHaveLength(1);
+    expect(Array.isArray(parsed.messages[0].content)).toBe(true);
+    const blocks = parsed.messages[0].content as Array<{
+      type: string;
+      text: string;
+      cache_control?: { type: string };
+    }>;
+    expect(blocks).toHaveLength(2);
+    expect(blocks[0].text).toContain("<system-instructions>");
+    expect(blocks[0].text).toContain("Plugin instructions");
+    expect(blocks[0].cache_control).toEqual({ type: "ephemeral" });
+    expect(blocks[1].text).toBe("the original user request");
+    expect(blocks[1].cache_control).toBeUndefined();
+  });
+
+  it("merges relocated wrapper into the first user message when content is an array", () => {
+    const body = JSON.stringify({
+      model: "claude-sonnet-4-20250514",
+      messages: [
+        {
+          role: "user",
+          content: [{ type: "text", text: "structured user turn" }],
+        },
+      ],
+      system: [{ type: "text", text: "Plugin instructions" }],
+    });
+
+    const result = transformRequestBody(body, mockSignature, mockRuntime);
+    const parsed = JSON.parse(result!);
+
+    expect(parsed.messages).toHaveLength(1);
+    expect(Array.isArray(parsed.messages[0].content)).toBe(true);
+    const blocks = parsed.messages[0].content as Array<{
+      type: string;
+      text: string;
+      cache_control?: { type: string };
+    }>;
+    expect(blocks[0].type).toBe("text");
+    expect(blocks[0].text).toContain("<system-instructions>");
+    expect(blocks[0].text).toContain("Plugin instructions");
+    expect(blocks[0].cache_control).toEqual({ type: "ephemeral" });
+    expect(blocks[1].text).toBe("structured user turn");
+    expect(blocks[1].cache_control).toBeUndefined();
+  });
+
+  it("does not relocate when signature.enabled is false (legacy passthrough)", () => {
+    const body = JSON.stringify({
+      model: "claude-sonnet-4-20250514",
+      messages: [{ role: "user", content: "hi" }],
+      system: [{ type: "text", text: "Plugin instructions" }],
+    });
+
+    const result = transformRequestBody(body, { ...mockSignature, enabled: false }, mockRuntime);
+    const parsed = JSON.parse(result!);
+
+    // Legacy mode: third-party content stays in system, no wrapper added.
+    const systemJoined = parsed.system.map((b: { text: string }) => b.text).join("\n");
+    expect(systemJoined).toContain("Plugin instructions");
+    expect(parsed.messages[0].content).toBe("hi");
+  });
+
+  it("does not relocate when relocateThirdPartyPrompts arg is false", () => {
+    const body = JSON.stringify({
+      model: "claude-sonnet-4-20250514",
+      messages: [{ role: "user", content: "hi" }],
+      system: [{ type: "text", text: "Plugin instructions" }],
+    });
+
+    const result = transformRequestBody(body, mockSignature, mockRuntime, false);
+    const parsed = JSON.parse(result!);
+
+    const systemJoined = parsed.system.map((b: { text: string }) => b.text).join("\n");
+    expect(systemJoined).toContain("Plugin instructions");
+    expect(parsed.messages[0].content).toBe("hi");
+  });
+});