fix: handle websocket and tool result cache controls

Author: cuipengfei

src/lib/api-config.ts

@@ -370,6 +370,8 @@ export const copilotWebSocketHeaders = (
     "Copilot-Integration-Id": source("copilot-integration-id", "vscode-chat"),
   })
 
+  setPreparedHeader(headers, "host", preparedHeaders, "host")
+
   setPreparedHeader(
     headers,
     "Copilot-Vision-Request",

src/routes/messages/preprocess.ts

@@ -21,6 +21,7 @@ import type {
   AnthropicMessagesPayload,
   AnthropicTextBlock,
   AnthropicToolResultBlock,
+  AnthropicToolResultContentBlock,
   AnthropicUserContentBlock,
 } from "./anthropic-types"
 
@@ -185,32 +186,112 @@ const mergeContentWithText = (
   tr: AnthropicToolResultBlock,
   textBlock: AnthropicTextBlock,
 ): AnthropicToolResultBlock => {
+  const normalizedToolResult = normalizeToolResultContentCacheControl(tr)
+  const mergedToolResult = mergeToolResultCacheControl(normalizedToolResult, [
+    textBlock,
+  ])
+  const sanitizedTextBlock = stripContentBlockCacheControl(textBlock)
+
   if (typeof tr.content === "string") {
-    return { ...tr, content: `${tr.content}\n\n${textBlock.text}` }
+    return {
+      ...mergedToolResult,
+      content: `${tr.content}\n\n${textBlock.text}`,
+    }
   }
   // Unable to merge, discard other text blocks, wait for the next round of re-request
   if (hasToolRef(tr)) {
     return tr
   }
   return {
-    ...tr,
-    content: [...tr.content, textBlock],
+    ...mergedToolResult,
+    content: [...normalizedToolResult.content, sanitizedTextBlock],
   }
 }
 
 const mergeContentWithTexts = (
   tr: AnthropicToolResultBlock,
   textBlocks: Array<AnthropicTextBlock>,
 ): AnthropicToolResultBlock => {
+  const normalizedToolResult = normalizeToolResultContentCacheControl(tr)
+  const mergedToolResult = mergeToolResultCacheControl(
+    normalizedToolResult,
+    textBlocks,
+  )
+  const sanitizedTextBlocks = textBlocks.map(stripContentBlockCacheControl)
+
   if (typeof tr.content === "string") {
     const appendedTexts = textBlocks.map((tb) => tb.text).join("\n\n")
-    return { ...tr, content: `${tr.content}\n\n${appendedTexts}` }
+    return {
+      ...mergedToolResult,
+      content: `${tr.content}\n\n${appendedTexts}`,
+    }
   }
   // Unable to merge, discard other text blocks, wait for the next round of re-request
   if (hasToolRef(tr)) {
     return tr
   }
-  return { ...tr, content: [...tr.content, ...textBlocks] }
+  return {
+    ...mergedToolResult,
+    content: [...normalizedToolResult.content, ...sanitizedTextBlocks],
+  }
+}
+
+const mergeToolResultCacheControl = (
+  tr: AnthropicToolResultBlock,
+  textBlocks: Array<AnthropicTextBlock>,
+): AnthropicToolResultBlock => {
+  const cacheControl = textBlocks
+    .map((block) => block.cache_control)
+    .findLast(
+      (candidate): candidate is AnthropicCacheControl =>
+        Boolean(candidate) && typeof candidate === "object",
+    )
+
+  if (cacheControl) {
+    return { ...tr, cache_control: { ...cacheControl } }
+  }
+
+  return tr.cache_control ?
+      { ...tr, cache_control: { ...tr.cache_control } }
+    : tr
+}
+
+const stripContentBlockCacheControl = (
+  block: AnthropicTextBlock,
+): AnthropicTextBlock => {
+  if (!block.cache_control) {
+    return block
+  }
+
+  return {
+    text: block.text,
+    type: "text",
+  }
+}
+
+const normalizeToolResultContentCacheControl = (
+  tr: AnthropicToolResultBlock,
+): AnthropicToolResultBlock & {
+  content: Array<AnthropicToolResultContentBlock>
+} => {
+  if (typeof tr.content === "string") {
+    return { ...tr, content: [{ type: "text", text: tr.content }] }
+  }
+
+  let cacheControl = tr.cache_control
+  const content = tr.content.map((block) => {
+    if (!("cache_control" in block) || !block.cache_control) {
+      return block
+    }
+
+    cacheControl = block.cache_control
+    const { cache_control: _cacheControl, ...rest } = block
+    return rest
+  })
+
+  return cacheControl ?
+      { ...tr, cache_control: cacheControl, content }
+    : { ...tr, content }
 }
 
 const mergeContentWithAttachments = (

tests/create-responses.test.ts

@@ -459,6 +459,7 @@ describe("createResponses websocket helpers", () => {
       "Editor-Device-Id": "device-1",
       "Editor-Plugin-Version": "copilot-chat/0.47.1",
       "Editor-Version": "vscode/1.120.0",
+      host: "api.githubcopilot.com",
       "OpenAI-Intent": "conversation-agent",
       "VScode-SessionId": "session-1",
       "VScode-MachineId": "machine-1",

tests/messages-preprocess.test.ts

@@ -251,6 +251,66 @@ describe("mergeToolResultForClaude", () => {
     })
   })
 
+  test("lifts cache_control out of merged array tool_result content", () => {
+    const payload: AnthropicMessagesPayload = {
+      model: "claude-opus-4.6",
+      max_tokens: 128,
+      messages: [
+        {
+          role: "user",
+          content: [
+            {
+              type: "tool_result",
+              tool_use_id: "tool-1",
+              content: [
+                {
+                  type: "text",
+                  text: "tool output",
+                  cache_control: {
+                    type: "ephemeral",
+                    ttl: "1h",
+                  },
+                },
+              ],
+            },
+            {
+              type: "text",
+              text: "cached trailing text",
+              cache_control: {
+                type: "ephemeral",
+              },
+            },
+          ],
+        },
+      ],
+    }
+
+    mergeToolResultForClaude(payload)
+
+    expect(payload.messages[0]).toEqual({
+      role: "user",
+      content: [
+        {
+          type: "tool_result",
+          tool_use_id: "tool-1",
+          content: [
+            {
+              type: "text",
+              text: "tool output",
+            },
+            {
+              type: "text",
+              text: "cached trailing text",
+            },
+          ],
+          cache_control: {
+            type: "ephemeral",
+          },
+        },
+      ],
+    })
+  })
+
   test("appends all text blocks to the last tool_result when counts differ", () => {
     const payload: AnthropicMessagesPayload = {
       model: "claude-opus-4.6",

tests/telemetry.test.ts

@@ -440,8 +440,20 @@ describe("telemetry: request/response wrappers", () => {
     trackPanelRequest({ headerRequestId: "req-panel-001" })
     await flushMicrotasks()
 
-    expect(requestMock).toHaveBeenCalledTimes(1)
-    const call = requestMock.mock.calls[0] as Array<unknown> | undefined
+    const requestCalls = requestMock.mock.calls as Array<Array<unknown>>
+    const call = requestCalls.find((candidate) => {
+      const options = candidate[1]
+      if (typeof options !== "object" || options === null) {
+        return false
+      }
+
+      const body = (options as { body?: unknown }).body
+      if (typeof body !== "string") {
+        return false
+      }
+
+      return body.includes('"headerRequestId":"req-panel-001"')
+    })
     if (!call) {
       throw new TypeError("request call missing")
     }