feat: add signature and reasoning handling to responses translation and state management

Author: caozhiyuan

src/routes/messages/anthropic-types.ts

@@ -56,6 +56,7 @@ export interface AnthropicToolUseBlock {
 export interface AnthropicThinkingBlock {
   type: "thinking"
   thinking: string
+  signature: string
 }
 
 export type AnthropicUserContentBlock =

src/routes/messages/responses-stream-translation.ts

@@ -15,6 +15,7 @@ export interface ResponsesStreamState {
   initialInputTokens?: number
   functionCallStateByOutputIndex: Map<number, FunctionCallStreamState>
   functionCallOutputIndexByItemId: Map<string, number>
+  summryIndex: number
 }
 
 type FunctionCallStreamState = {
@@ -32,6 +33,7 @@ export const createResponsesStreamState = (): ResponsesStreamState => ({
   blockHasDelta: new Set(),
   functionCallStateByOutputIndex: new Map(),
   functionCallOutputIndexByItemId: new Map(),
+  summryIndex: 0,
 })
 
 export const translateResponsesStreamEvent = (
@@ -49,12 +51,18 @@ export const translateResponsesStreamEvent = (
       return handleResponseCreated(rawEvent, state)
     }
 
-    case "response.reasoning_summary_text.delta":
+    case "response.reasoning_summary_text.delta": {
+      return handleReasoningSummaryTextDelta(rawEvent, state)
+    }
+
     case "response.output_text.delta": {
       return handleOutputTextDelta(rawEvent, state)
     }
 
-    case "response.reasoning_summary_part.done":
+    case "response.reasoning_summary_part.done": {
+      return handleReasoningSummaryPartDone(rawEvent, state)
+    }
+
     case "response.output_text.done": {
       return handleOutputTextDone(rawEvent, state)
     }
@@ -63,6 +71,10 @@ export const translateResponsesStreamEvent = (
       return handleOutputItemAdded(rawEvent, state)
     }
 
+    case "response.output_item.done": {
+      return handleOutputItemDone(rawEvent, state)
+    }
+
     case "response.function_call_arguments.delta": {
       return handleFunctionCallArgumentsDelta(rawEvent, state)
     }
@@ -143,6 +155,51 @@ const handleOutputItemAdded = (
   return events
 }
 
+const handleOutputItemDone = (
+  rawEvent: Record<string, unknown>,
+  state: ResponsesStreamState,
+): Array<AnthropicStreamEventData> => {
+  const events = ensureMessageStart(state)
+
+  const item = isRecord(rawEvent.item) ? rawEvent.item : undefined
+  if (!item) {
+    return events
+  }
+
+  const itemType = typeof item.type === "string" ? item.type : undefined
+  if (itemType !== "reasoning") {
+    return events
+  }
+
+  const outputIndex = toNumber(rawEvent.output_index)
+  const contentIndex = state.summryIndex
+
+  const blockIndex = openThinkingBlockIfNeeded(state, {
+    outputIndex,
+    contentIndex,
+    events,
+  })
+
+  const signature =
+    typeof item.encrypted_content === "string" ? item.encrypted_content : ""
+
+  if (signature) {
+    events.push({
+      type: "content_block_delta",
+      index: blockIndex,
+      delta: {
+        type: "signature_delta",
+        signature,
+      },
+    })
+    state.blockHasDelta.add(blockIndex)
+  }
+
+  closeBlockIfOpen(state, blockIndex, events)
+
+  return events
+}
+
 const handleFunctionCallArgumentsDelta = (
   rawEvent: Record<string, unknown>,
   state: ResponsesStreamState,
@@ -257,6 +314,71 @@ const handleOutputTextDelta = (
   return events
 }
 
+const handleReasoningSummaryTextDelta = (
+  rawEvent: Record<string, unknown>,
+  state: ResponsesStreamState,
+): Array<AnthropicStreamEventData> => {
+  const events = ensureMessageStart(state)
+
+  const outputIndex = toNumber(rawEvent.output_index)
+  const contentIndex = toNumber(rawEvent.summary_index)
+  const deltaText = typeof rawEvent.delta === "string" ? rawEvent.delta : ""
+
+  if (!deltaText) {
+    return events
+  }
+
+  const blockIndex = openThinkingBlockIfNeeded(state, {
+    outputIndex,
+    contentIndex,
+    events,
+  })
+
+  events.push({
+    type: "content_block_delta",
+    index: blockIndex,
+    delta: {
+      type: "thinking_delta",
+      thinking: deltaText,
+    },
+  })
+  state.blockHasDelta.add(blockIndex)
+
+  return events
+}
+
+const handleReasoningSummaryPartDone = (
+  rawEvent: Record<string, unknown>,
+  state: ResponsesStreamState,
+): Array<AnthropicStreamEventData> => {
+  const events = ensureMessageStart(state)
+
+  const outputIndex = toNumber(rawEvent.output_index)
+  const contentIndex = toNumber(rawEvent.summary_index)
+  state.summryIndex = contentIndex
+  const part = isRecord(rawEvent.part) ? rawEvent.part : undefined
+  const text = part && typeof part.text === "string" ? part.text : ""
+
+  const blockIndex = openThinkingBlockIfNeeded(state, {
+    outputIndex,
+    contentIndex,
+    events,
+  })
+
+  if (text && !state.blockHasDelta.has(blockIndex)) {
+    events.push({
+      type: "content_block_delta",
+      index: blockIndex,
+      delta: {
+        type: "thinking_delta",
+        thinking: text,
+      },
+    })
+  }
+
+  return events
+}
+
 const handleOutputTextDone = (
   rawEvent: Record<string, unknown>,
   state: ResponsesStreamState,
@@ -430,6 +552,39 @@ const openTextBlockIfNeeded = (
   return blockIndex
 }
 
+const openThinkingBlockIfNeeded = (
+  state: ResponsesStreamState,
+  params: {
+    outputIndex: number
+    contentIndex: number
+    events: Array<AnthropicStreamEventData>
+  },
+): number => {
+  const { outputIndex, contentIndex, events } = params
+  const key = getBlockKey(outputIndex, contentIndex)
+  let blockIndex = state.blockIndexByKey.get(key)
+
+  if (blockIndex === undefined) {
+    blockIndex = state.nextContentBlockIndex
+    state.nextContentBlockIndex += 1
+    state.blockIndexByKey.set(key, blockIndex)
+  }
+
+  if (!state.openBlocks.has(blockIndex)) {
+    events.push({
+      type: "content_block_start",
+      index: blockIndex,
+      content_block: {
+        type: "thinking",
+        thinking: "",
+      },
+    })
+    state.openBlocks.add(blockIndex)
+  }
+
+  return blockIndex
+}
+
 const closeBlockIfOpen = (
   state: ResponsesStreamState,
   blockIndex: number,

src/routes/messages/responses-translation.ts

@@ -6,6 +6,7 @@ import {
   type ResponseInputImage,
   type ResponseInputItem,
   type ResponseInputMessage,
+  type ResponseInputReasoning,
   type ResponseInputText,
   type ResponsesResult,
   type ResponseOutputContentBlock,
@@ -27,6 +28,7 @@ import {
   type AnthropicMessage,
   type AnthropicMessagesPayload,
   type AnthropicTextBlock,
+  type AnthropicThinkingBlock,
   type AnthropicTool,
   type AnthropicToolResultBlock,
   type AnthropicToolUseBlock,
@@ -137,6 +139,12 @@ const translateAssistantMessage = (
       continue
     }
 
+    if (block.type === "thinking") {
+      flushPendingContent("assistant", pendingContent, items)
+      items.push(createReasoningContent(block))
+      continue
+    }
+
     const converted = translateAssistantContentBlock(block)
     if (converted) {
       pendingContent.push(converted)
@@ -158,9 +166,6 @@ const translateUserContentBlock = (
     case "image": {
       return createImageContent(block)
     }
-    case "tool_result": {
-      return undefined
-    }
     default: {
       return undefined
     }
@@ -174,12 +179,6 @@ const translateAssistantContentBlock = (
     case "text": {
       return createOutPutTextContent(block.text)
     }
-    case "thinking": {
-      return createOutPutTextContent(block.thinking)
-    }
-    case "tool_use": {
-      return undefined
-    }
     default: {
       return undefined
     }
@@ -230,6 +229,19 @@ const createImageContent = (
   image_url: `data:${block.source.media_type};base64,${block.source.data}`,
 })
 
+const createReasoningContent = (
+  block: AnthropicThinkingBlock,
+): ResponseInputReasoning => ({
+  type: "reasoning",
+  summary: [
+    {
+      type: "summary_text",
+      text: block.thinking,
+    },
+  ],
+  encrypted_content: block.signature,
+})
+
 const createFunctionToolCall = (
   block: AnthropicToolUseBlock,
 ): ResponseFunctionToolCallItem => ({
@@ -376,7 +388,11 @@ const mapOutputToAnthropicContent = (
       case "reasoning": {
         const thinkingText = extractReasoningText(item)
         if (thinkingText.length > 0) {
-          contentBlocks.push({ type: "thinking", thinking: thinkingText })
+          contentBlocks.push({
+            type: "thinking",
+            thinking: thinkingText,
+            signature: item.encrypted_content ?? "",
+          })
         }
         break
       }
@@ -456,31 +472,11 @@ const extractReasoningText = (item: ResponseOutputReasoning): string => {
         segments.push(block.text)
         continue
       }
-
-      if (typeof block.thinking === "string") {
-        segments.push(block.thinking)
-        continue
-      }
-
-      const reasoningValue = (block as Record<string, unknown>).reasoning
-      if (typeof reasoningValue === "string") {
-        segments.push(reasoningValue)
-      }
     }
   }
 
-  collectFromBlocks(item.reasoning)
   collectFromBlocks(item.summary)
 
-  if (typeof item.thinking === "string") {
-    segments.push(item.thinking)
-  }
-
-  const textValue = (item as Record<string, unknown>).text
-  if (typeof textValue === "string") {
-    segments.push(textValue)
-  }
-
   return segments.join("").trim()
 }
 

src/routes/responses/utils.ts

@@ -31,16 +31,12 @@ const getPayloadItems = (
 ): Array<ResponseInputItem> => {
   const result: Array<ResponseInputItem> = []
 
-  const { input, instructions } = payload
+  const { input } = payload
 
   if (Array.isArray(input)) {
     result.push(...input)
   }
 
-  if (Array.isArray(instructions)) {
-    result.push(...instructions)
-  }
-
   return result
 }