feat(provider): keep ephemeral injects on the user role

Author: TheGreatAxios

src/provider/anthropic-cache-breakpoint.ts

@@ -23,9 +23,12 @@ type WireMessage = {
 };
 
 function ephemeralSuffixLength(options: ExtendedInferenceOptions): number {
+  // Ephemeral turns are appended as the request suffix (see reactor.ts), so
+  // every entry counts — including system-role turns, which the Anthropic
+  // wire adapter hoists out of the message list rather than leaving in place.
   const turns = options.ephemeralTurns;
   if (turns === undefined) return 0;
-  return turns.filter((turn) => turn.role !== "system").length;
+  return turns.length;
 }
 
 function isWireBlock(block: unknown): block is WireBlock {

src/provider/ephemeral-inject-role.test.ts

@@ -0,0 +1,138 @@
+import { describe, expect, test } from "bun:test";
+import { createBuiltinRegistry } from "@intx/inference/providers";
+import type {
+  ConversationTurn,
+  InferenceOptions,
+  LastCycleSource,
+} from "@intx/types/runtime";
+import {
+  adapterPreservesMidSystem,
+  ephemeralInjectRole,
+  midConversationSystemSupported,
+} from "./ephemeral-inject-role.js";
+
+function sourceFor(provider: string): LastCycleSource {
+  return { sourceId: `test-${provider}`, provider, model: "test-model" };
+}
+
+function userTurn(text: string): ConversationTurn {
+  return {
+    role: "user",
+    timestamp: 0,
+    content: [{ type: "text", text }],
+  };
+}
+
+function assistantTurn(text: string): ConversationTurn {
+  return {
+    role: "assistant",
+    timestamp: 0,
+    content: [{ type: "text", text }],
+  };
+}
+
+function systemTurn(text: string): ConversationTurn {
+  return {
+    role: "system",
+    timestamp: 0,
+    content: [{ type: "text", text }],
+  };
+}
+
+type WireBody = {
+  messages: { role: string; content: { text?: string }[] }[];
+  system?: { text?: string }[];
+};
+
+function wireBody(body: string): WireBody {
+  return JSON.parse(body) as WireBody;
+}
+
+function systemText(body: WireBody): string {
+  return (body.system ?? []).map((block) => block.text ?? "").join("\n\n");
+}
+
+describe("midConversationSystemSupported", () => {
+  const providers = ["anthropic", "zen-messages", "opencode-go-messages"];
+  const models = [
+    "fable",
+    "mythos",
+    "claude-opus-4-8",
+    "claude-opus-4.8",
+    "claude-opus-5",
+  ];
+  for (const provider of providers) {
+    for (const model of models) {
+      test(`supports ${provider} / ${model}`, () => {
+        expect(midConversationSystemSupported(provider, model)).toBe(true);
+      });
+    }
+  }
+
+  test("rejects non-anthropic providers even on new models", () => {
+    expect(midConversationSystemSupported("openai", "fable")).toBe(false);
+    expect(midConversationSystemSupported("openai", "claude-opus-5")).toBe(
+      false,
+    );
+  });
+
+  test("rejects older models on anthropic providers", () => {
+    expect(
+      midConversationSystemSupported("anthropic", "claude-sonnet-4-5"),
+    ).toBe(false);
+    expect(
+      midConversationSystemSupported("zen-messages", "claude-opus-4-6"),
+    ).toBe(false);
+  });
+});
+
+describe("ephemeralInjectRole", () => {
+  test("adapter does not preserve mid-conversation system turns", () => {
+    expect(adapterPreservesMidSystem()).toBe(false);
+  });
+
+  test("never returns system, even where mid-conversation system is supported", () => {
+    for (const provider of [
+      "anthropic",
+      "zen-messages",
+      "opencode-go-messages",
+      "openai",
+    ]) {
+      for (const model of ["fable", "mythos", "claude-opus-4-8", "other"]) {
+        expect(ephemeralInjectRole(provider, model)).toBe("user");
+      }
+    }
+  });
+});
+
+describe("builtin anthropic adapter vs system-role inject (real registry, no stubs)", () => {
+  const persisted = [userTurn("q1"), assistantTurn("a1")];
+  const injectText = "wrap up soon";
+
+  test("mid-conversation system turn is hoisted to the head system block", () => {
+    const request = createBuiltinRegistry()
+      .resolve(sourceFor("anthropic"))
+      .buildRequest(
+        [...persisted, systemTurn(injectText)],
+        "claude-opus-4-8",
+        {},
+      );
+    const body = wireBody(request.body);
+    expect(body.messages.some((m) => m.role === "system")).toBe(false);
+    expect(systemText(body)).toContain(injectText);
+  });
+
+  test("with systemPrompt set, a system-role inject is dropped", () => {
+    const options = { systemPrompt: "STABLE PROMPT" } as InferenceOptions;
+    const request = createBuiltinRegistry()
+      .resolve(sourceFor("anthropic"))
+      .buildRequest(
+        [...persisted, systemTurn(injectText)],
+        "claude-opus-4-8",
+        options,
+      );
+    const body = wireBody(request.body);
+    expect(systemText(body)).toBe("STABLE PROMPT");
+    expect(JSON.stringify(body.messages)).not.toContain(injectText);
+  });
+});

src/provider/ephemeral-inject-role.ts

@@ -0,0 +1,66 @@
+import {
+  OPENCODE_GO_MESSAGES_PROVIDER,
+  ZEN_MESSAGES_PROVIDER,
+} from "./anthropic-session-adapter.js";
+
+const ANTHROPIC_MESSAGES_PROVIDERS: ReadonlySet<string> = new Set([
+  "anthropic",
+  ZEN_MESSAGES_PROVIDER,
+  OPENCODE_GO_MESSAGES_PROVIDER,
+]);
+
+const MID_CONVERSATION_SYSTEM_MODELS: readonly string[] = [
+  "fable",
+  "mythos",
+  "opus-4-8",
+  "opus-5",
+];
+
+function normalizeModel(model: string): string {
+  return model.toLowerCase().replaceAll(".", "-");
+}
+
+/**
+ * True when the provider/model pair is known to accept a system prompt
+ * mid-conversation (past the head of the request). Provider and model must
+ * both match: the Anthropic-messages wire shape on one side, a model new
+ * enough to honor a mid-list system block on the other.
+ */
+export function midConversationSystemSupported(
+  provider: string,
+  model: string,
+): boolean {
+  if (!ANTHROPIC_MESSAGES_PROVIDERS.has(provider)) return false;
+  const normalized = normalizeModel(model);
+  return MID_CONVERSATION_SYSTEM_MODELS.some((fragment) =>
+    normalized.includes(fragment),
+  );
+}
+
+/**
+ * False until a vendor adapter carries a mid-conversation system turn
+ * through to the wire in position. The builtin Anthropic adapter hoists
+ * every system-role turn into the head `system` block — and drops the
+ * turn content entirely when `systemPrompt` is set — so a system-role
+ * inject would either move to the head or vanish.
+ */
+export function adapterPreservesMidSystem(): false {
+  return false;
+}
+
+// mailbox = work, ephemeral = inject: the durable transcript carries the
+// working conversation, while ephemeral turns ride exactly one inference.
+// An inject must never take the system role — the wire would hoist or drop
+// it — so this stays "user" until adapterPreservesMidSystem() flips.
+export function ephemeralInjectRole(
+  provider: string,
+  model: string,
+): "user" | "system" {
+  if (
+    adapterPreservesMidSystem() &&
+    midConversationSystemSupported(provider, model)
+  ) {
+    return "system";
+  }
+  return "user";
+}