Add call/response to chat

Author: TDFSE

packages/types/src/message.ts

@@ -170,6 +170,8 @@ export const clineSays = [
 	"user_edit_todos",
 	"too_many_tools_warning",
 	"tool",
+	"use_advisor_tool",
+	"advisor_tool_result",
 ] as const
 
 export const clineSaySchema = z.enum(clineSays)

packages/types/src/vscode-extension-host.ts

@@ -842,6 +842,12 @@ export interface ClineSayTool {
 	skill?: string
 }
 
+export interface ClineAskUseAdvisorTool {
+	toolUseId: string
+	name: string
+	input: string // JSON-serialized input
+}
+
 export interface ClineAskUseMcpServer {
 	serverName: string
 	type: "use_mcp_tool" | "access_mcp_resource"

src/api/providers/__tests__/anthropic.spec.ts

@@ -922,5 +922,151 @@ describe("AnthropicHandler", () => {
 				arguments: '"London"}',
 			})
 		})
+
+		it("should emit advisor_tool_use chunk with id from server_tool_use block", async () => {
+			mockCreate.mockImplementationOnce(async () => ({
+				async *[Symbol.asyncIterator]() {
+					yield {
+						type: "message_start",
+						message: { usage: { input_tokens: 100, output_tokens: 50 } },
+					}
+					yield {
+						type: "content_block_start",
+						index: 0,
+						content_block: {
+							type: "server_tool_use",
+							id: "srvtoolu_abc123",
+							name: "advisor",
+							input: {},
+						},
+					}
+				},
+			}))
+
+			const stream = handler.createMessage("system", [{ role: "user", content: "Hello" }], {
+				taskId: "test-task",
+			})
+
+			const chunks: any[] = []
+			for await (const chunk of stream) {
+				chunks.push(chunk)
+			}
+
+			const advisorUseChunk = chunks.find((c) => c.type === "advisor_tool_use")
+			expect(advisorUseChunk).toBeDefined()
+			expect(advisorUseChunk.id).toBe("srvtoolu_abc123")
+			expect(advisorUseChunk.name).toBe("advisor")
+		})
+
+		it("should emit advisor_tool_result chunk with tool_use_id and text content", async () => {
+			mockCreate.mockImplementationOnce(async () => ({
+				async *[Symbol.asyncIterator]() {
+					yield {
+						type: "message_start",
+						message: { usage: { input_tokens: 100, output_tokens: 50 } },
+					}
+					yield {
+						type: "content_block_start",
+						index: 1,
+						content_block: {
+							type: "advisor_tool_result",
+							tool_use_id: "srvtoolu_abc123",
+							content: { type: "advisor_result", text: "Use channel-based coordination." },
+						},
+					}
+				},
+			}))
+
+			const stream = handler.createMessage("system", [{ role: "user", content: "Hello" }], {
+				taskId: "test-task",
+			})
+
+			const chunks: any[] = []
+			for await (const chunk of stream) {
+				chunks.push(chunk)
+			}
+
+			const resultChunk = chunks.find((c) => c.type === "advisor_tool_result")
+			expect(resultChunk).toBeDefined()
+			expect(resultChunk.tool_use_id).toBe("srvtoolu_abc123")
+			expect(resultChunk.content).toBe("Use channel-based coordination.")
+			// rawContent must carry the verbatim object for round-tripping to the API
+			expect(resultChunk.rawContent).toEqual({ type: "advisor_result", text: "Use channel-based coordination." })
+		})
+
+		it("should extract text from advisor_result object content shape", async () => {
+			mockCreate.mockImplementationOnce(async () => ({
+				async *[Symbol.asyncIterator]() {
+					yield {
+						type: "message_start",
+						message: { usage: { input_tokens: 100, output_tokens: 50 } },
+					}
+					yield {
+						type: "content_block_start",
+						index: 0,
+						content_block: {
+							type: "advisor_tool_result",
+							tool_use_id: "srvtoolu_xyz",
+							content: { type: "advisor_result", text: "Plan: do X then Y." },
+						},
+					}
+				},
+			}))
+
+			const stream = handler.createMessage("system", [{ role: "user", content: "Plan?" }], {
+				taskId: "test-task",
+			})
+
+			const chunks: any[] = []
+			for await (const chunk of stream) {
+				chunks.push(chunk)
+			}
+
+			const resultChunk = chunks.find((c) => c.type === "advisor_tool_result")
+			expect(resultChunk).toBeDefined()
+			expect(resultChunk.content).toBe("Plan: do X then Y.")
+			// rawContent must be the verbatim object, not just the extracted text
+			expect(resultChunk.rawContent).toEqual({ type: "advisor_result", text: "Plan: do X then Y." })
+		})
+
+		it("should emit empty string for encrypted advisor_redacted_result content", async () => {
+			mockCreate.mockImplementationOnce(async () => ({
+				async *[Symbol.asyncIterator]() {
+					yield {
+						type: "message_start",
+						message: { usage: { input_tokens: 100, output_tokens: 50 } },
+					}
+					yield {
+						type: "content_block_start",
+						index: 0,
+						content_block: {
+							type: "advisor_tool_result",
+							tool_use_id: "srvtoolu_redacted",
+							content: { type: "advisor_redacted_result", encrypted_content: "opaque-blob" },
+						},
+					}
+				},
+			}))
+
+			const stream = handler.createMessage("system", [{ role: "user", content: "Plan?" }], {
+				taskId: "test-task",
+			})
+
+			const chunks: any[] = []
+			for await (const chunk of stream) {
+				chunks.push(chunk)
+			}
+
+			const resultChunk = chunks.find((c) => c.type === "advisor_tool_result")
+			expect(resultChunk).toBeDefined()
+			expect(resultChunk.tool_use_id).toBe("srvtoolu_redacted")
+			// Encrypted content has no text field — content should be empty string
+			expect(resultChunk.content).toBe("")
+			// rawContent must carry the verbatim encrypted object for round-tripping
+			expect(resultChunk.rawContent).toEqual({
+				type: "advisor_redacted_result",
+				encrypted_content: "opaque-blob",
+			})
+		})
 	})
 })

src/api/providers/anthropic.ts

@@ -272,16 +272,17 @@ export class AnthropicHandler extends BaseProvider implements SingleCompletionHa
 				case "message_stop":
 					// No usage data, just an indicator that the message is done.
 					break
-				case "content_block_start":
-					switch (chunk.content_block.type) {
+				case "content_block_start": {
+					const contentBlock = chunk.content_block as any
+					switch (contentBlock.type) {
 						case "thinking":
 							// We may receive multiple text blocks, in which
 							// case just insert a line break between them.
 							if (chunk.index > 0) {
 								yield { type: "reasoning", text: "\n" }
 							}
 
-							yield { type: "reasoning", text: chunk.content_block.thinking }
+							yield { type: "reasoning", text: contentBlock.thinking }
 							break
 						case "text":
 							// We may receive multiple text blocks, in which
@@ -290,21 +291,67 @@ export class AnthropicHandler extends BaseProvider implements SingleCompletionHa
 								yield { type: "text", text: "\n" }
 							}
 
-							yield { type: "text", text: chunk.content_block.text }
+							yield { type: "text", text: contentBlock.text }
 							break
 						case "tool_use": {
 							// Emit initial tool call partial with id and name
 							yield {
 								type: "tool_call_partial",
 								index: chunk.index,
-								id: chunk.content_block.id,
-								name: chunk.content_block.name,
+								id: contentBlock.id,
+								name: contentBlock.name,
 								arguments: undefined,
 							}
 							break
 						}
+						case "server_tool_use": {
+							const { id, name, input } = contentBlock
+							yield {
+								type: "advisor_tool_use",
+								id,
+								name,
+								input: typeof input === "object" ? JSON.stringify(input) : String(input ?? "{}"),
+							}
+							break
+						}
+						case "advisor_tool_result": {
+							const block = contentBlock as {
+								type: "advisor_tool_result"
+								tool_use_id: string
+								content:
+									| string
+									| { type: string; text?: string }
+									| Array<{ type: string; text?: string }>
+									| undefined
+							}
+							const rawContent = block.content
+							let text: string
+							if (typeof rawContent === "string") {
+								text = rawContent
+							} else if (Array.isArray(rawContent)) {
+								text = rawContent
+									.filter((b) => b.type === "text")
+									.map((b) => b.text ?? "")
+									.join("\n")
+							} else if (rawContent && typeof rawContent === "object" && "text" in rawContent) {
+								// advisor_result shape: { type: "advisor_result", text: "..." }
+								text = (rawContent as { text?: string }).text ?? ""
+							} else {
+								text = ""
+							}
+							yield {
+								type: "advisor_tool_result",
+								tool_use_id: block.tool_use_id,
+								content: text,
+								// Pass through the verbatim content object so it can be
+								// round-tripped on subsequent turns as the Anthropic API requires.
+								rawContent: rawContent,
+							}
+							break
+						}
 					}
 					break
+				}
 				case "content_block_delta":
 					switch (chunk.delta.type) {
 						case "thinking_delta":

src/api/transform/stream.ts

@@ -11,6 +11,8 @@ export type ApiStreamChunk =
 	| ApiStreamToolCallDeltaChunk
 	| ApiStreamToolCallEndChunk
 	| ApiStreamToolCallPartialChunk
+	| ApiStreamAdvisorToolUseChunk
+	| ApiStreamAdvisorToolResultChunk
 	| ApiStreamError
 
 export interface ApiStreamError {
@@ -107,6 +109,22 @@ export interface ApiStreamToolCallPartialChunk {
 	arguments?: string
 }
 
+export interface ApiStreamAdvisorToolUseChunk {
+	type: "advisor_tool_use"
+	id: string
+	name: string
+	input: string // JSON-serialized
+}
+
+export interface ApiStreamAdvisorToolResultChunk {
+	type: "advisor_tool_result"
+	tool_use_id: string
+	/** Extracted text for display purposes */
+	content: string
+	/** Verbatim original content object from the API, for round-tripping on subsequent turns */
+	rawContent: unknown
+}
+
 export interface GroundingSource {
 	title: string
 	url: string

src/core/task/Task.ts

@@ -35,6 +35,7 @@ import {
 	type ModelInfo,
 	type ClineApiReqCancelReason,
 	type ClineApiReqInfo,
+	type ClineAskUseAdvisorTool,
 	RooCodeEventName,
 	TelemetryEventName,
 	TaskStatus,
@@ -2792,6 +2793,18 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 				let assistantMessage = ""
 				let reasoningMessage = ""
 				let pendingGroundingSources: GroundingSource[] = []
+				let hasAdvisorEvents = false
+				// Accumulate advisor blocks in arrival order so they can be saved to API history.
+				// Anthropic requires the full assistant content (including server_tool_use /
+				// advisor_tool_result blocks) to be round-tripped on subsequent turns.
+				const pendingAdvisorBlocks: Array<{
+					type: "server_tool_use" | "advisor_tool_result"
+					id?: string
+					name?: string
+					input?: Record<string, unknown>
+					tool_use_id?: string
+					content?: unknown
+				}> = []
 				this.isStreaming = true
 
 				try {
@@ -3014,6 +3027,37 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 								presentAssistantMessage(this)
 								break
 							}
+							case "advisor_tool_use": {
+								hasAdvisorEvents = true
+								pendingAdvisorBlocks.push({
+									type: "server_tool_use",
+									id: chunk.id,
+									name: chunk.name,
+									input:
+										typeof chunk.input === "string" ? {} : (chunk.input as Record<string, unknown>),
+								})
+								const payload: ClineAskUseAdvisorTool = {
+									toolUseId: chunk.id,
+									name: chunk.name,
+									input: chunk.input,
+								}
+								await this.say("use_advisor_tool", JSON.stringify(payload))
+								break
+							}
+							case "advisor_tool_result": {
+								hasAdvisorEvents = true
+								pendingAdvisorBlocks.push({
+									type: "advisor_tool_result",
+									tool_use_id: chunk.tool_use_id,
+									// Use rawContent (the verbatim original object from the API) for
+									// round-tripping to Anthropic. The API requires content to be the
+									// original discriminated union object (e.g. { type: "advisor_result", text: "..." })
+									// not a plain string. chunk.content is the extracted text for display only.
+									content: chunk.rawContent,
+								})
+								await this.say("advisor_tool_result", chunk.content)
+								break
+							}
 							case "text": {
 								assistantMessage += chunk.text
 
@@ -3410,14 +3454,14 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 				// the assistant message is already in history. Otherwise, tool_result blocks would appear
 				// BEFORE their corresponding tool_use blocks, causing API errors.
 
-				// Check if we have any content to process (text or tool uses)
+				// Check if we have any content to process (text, tool uses, or advisor interactions)
 				const hasTextContent = assistantMessage.length > 0
 
 				const hasToolUses = this.assistantMessageContent.some(
 					(block) => block.type === "tool_use" || block.type === "mcp_tool_use",
 				)
 
-				if (hasTextContent || hasToolUses) {
+				if (hasTextContent || hasToolUses || hasAdvisorEvents) {
 					// Reset counter when we get a successful response with content
 					this.consecutiveNoAssistantMessagesCount = 0
 					// Display grounding sources to the user if they exist
@@ -3505,6 +3549,13 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 						}
 					}
 
+					// Append advisor blocks (server_tool_use / advisor_tool_result) that arrived during
+					// this stream. The Anthropic API requires these to be round-tripped verbatim on
+					// subsequent turns; omitting them causes a 400 invalid_request_error.
+					for (const advisorBlock of pendingAdvisorBlocks) {
+						assistantContent.push(advisorBlock as unknown as Anthropic.ToolUseBlockParam)
+					}
+
 					// Enforce new_task isolation: if new_task is called alongside other tools,
 					// truncate any tools that come after it and inject error tool_results.
 					// This prevents orphaned tools when delegation disposes the parent task.