refactor: simplify context injection to use tool parts universally

Remove model-specific branching (DeepSeek/Kimi check) and unused helper
functions. Now all non-user-message injections use synthetic tool parts
appended to the last message, eliminating ~100 lines of code.

Author: Tarquinen

lib/messages/inject.ts

@@ -8,10 +8,7 @@ import {
     buildToolIdList,
     createSyntheticTextPart,
     createSyntheticToolPart,
-    createSyntheticAssistantMessage,
-    createSyntheticAssistantMessageWithToolPart,
     isIgnoredUserMessage,
-    isDeepSeekOrKimi,
 } from "./utils"
 import { getFilePathFromParameters, isProtectedFilePath } from "../protected-file-patterns"
 import { getLastUserMessage, isMessageCompacted } from "../shared-utils"
@@ -195,37 +192,16 @@ export const insertPruneToolContext = (
         return
     }
 
-    // It's not safe to inject assistant role messages following a user message as models such
-    // as Claude expect the assistant "turn" to start with reasoning parts. Reasoning parts in many
-    // cases also cannot be faked as they may be encrypted by the model.
-    // Gemini only accepts synth reasoning text if it is "skip_thought_signature_validator"
+    // When following a user message, append a synthetic text part since models like Claude
+    // expect assistant turns to start with reasoning parts which cannot be easily faked.
+    // For all other cases, append a synthetic tool part to the last message which works
+    // across all models without disrupting their behavior.
     if (lastNonIgnoredMessage.info.role === "user") {
         const textPart = createSyntheticTextPart(lastNonIgnoredMessage, combinedContent)
         lastNonIgnoredMessage.parts.push(textPart)
     } else {
-        // For non-user message case: push a new synthetic assistant message or append tool part
-        // for DeepSeek/Kimi. DeepSeek and Kimi don't output reasoning parts following an
-        // assistant injection containing text parts. Tool parts appended to the last assistant
-        // message are the safest way to inject context without disrupting model behavior.
-        const providerID = userInfo.model?.providerID || ""
         const modelID = userInfo.model?.modelID || ""
-
-        if (isDeepSeekOrKimi(providerID, modelID)) {
-            const toolPart = createSyntheticToolPart(
-                lastNonIgnoredMessage,
-                combinedContent,
-                modelID,
-            )
-            lastNonIgnoredMessage.parts.push(toolPart)
-        } else {
-            messages.push(
-                createSyntheticAssistantMessageWithToolPart(
-                    lastUserMessage,
-                    combinedContent,
-                    modelID,
-                    variant,
-                ),
-            )
-        }
+        const toolPart = createSyntheticToolPart(lastNonIgnoredMessage, combinedContent, modelID)
+        lastNonIgnoredMessage.parts.push(toolPart)
     }
 }

lib/messages/utils.ts

@@ -13,17 +13,6 @@ const isGeminiModel = (modelID: string): boolean => {
     return lowerModelID.includes("gemini")
 }
 
-export const isDeepSeekOrKimi = (providerID: string, modelID: string): boolean => {
-    const lowerProviderID = providerID.toLowerCase()
-    const lowerModelID = modelID.toLowerCase()
-    return (
-        lowerProviderID.includes("deepseek") ||
-        lowerProviderID.includes("kimi") ||
-        lowerModelID.includes("deepseek") ||
-        lowerModelID.includes("kimi")
-    )
-}
-
 export const createSyntheticUserMessage = (
     baseMessage: WithParts,
     content: string,
@@ -56,104 +45,6 @@ export const createSyntheticUserMessage = (
     }
 }
 
-export const createSyntheticAssistantMessage = (
-    baseMessage: WithParts,
-    content: string,
-    variant?: string,
-): WithParts => {
-    const userInfo = baseMessage.info as UserMessage
-    const now = Date.now()
-    const messageId = generateUniqueId("msg")
-    const partId = generateUniqueId("prt")
-
-    return {
-        info: {
-            id: messageId,
-            sessionID: userInfo.sessionID,
-            role: "assistant" as const,
-            agent: userInfo.agent || "code",
-            parentID: userInfo.id,
-            modelID: userInfo.model.modelID,
-            providerID: userInfo.model.providerID,
-            mode: "default",
-            path: {
-                cwd: "/",
-                root: "/",
-            },
-            time: { created: now, completed: now },
-            cost: 0,
-            tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-            ...(variant !== undefined && { variant }),
-        },
-        parts: [
-            {
-                id: partId,
-                sessionID: userInfo.sessionID,
-                messageID: messageId,
-                type: "text" as const,
-                text: content,
-            },
-        ],
-    }
-}
-
-export const createSyntheticAssistantMessageWithToolPart = (
-    baseMessage: WithParts,
-    content: string,
-    modelID: string,
-    variant?: string,
-): WithParts => {
-    const userInfo = baseMessage.info as UserMessage
-    const now = Date.now()
-    const messageId = generateUniqueId("msg")
-    const partId = generateUniqueId("prt")
-    const callId = generateUniqueId("call")
-
-    // Gemini requires thoughtSignature bypass to accept synthetic tool parts
-    const toolPartMetadata = isGeminiModel(modelID)
-        ? { google: { thoughtSignature: "skip_thought_signature_validator" } }
-        : {}
-
-    return {
-        info: {
-            id: messageId,
-            sessionID: userInfo.sessionID,
-            role: "assistant" as const,
-            agent: userInfo.agent || "code",
-            parentID: userInfo.id,
-            modelID: userInfo.model.modelID,
-            providerID: userInfo.model.providerID,
-            mode: "default",
-            path: {
-                cwd: "/",
-                root: "/",
-            },
-            time: { created: now, completed: now },
-            cost: 0,
-            tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
-            ...(variant !== undefined && { variant }),
-        },
-        parts: [
-            {
-                id: partId,
-                sessionID: userInfo.sessionID,
-                messageID: messageId,
-                type: "tool" as const,
-                callID: callId,
-                tool: "context_info",
-                state: {
-                    status: "completed" as const,
-                    input: {},
-                    output: content,
-                    title: "Context Info",
-                    metadata: toolPartMetadata,
-                    time: { start: now, end: now },
-                },
-            },
-        ],
-    }
-}
-
 export const createSyntheticTextPart = (baseMessage: WithParts, content: string) => {
     const userInfo = baseMessage.info as UserMessage
     const partId = generateUniqueId("prt")