fix(huggingface): handle non-streaming tool calls without UI duplication

- Add createAiSdkToolStreamProcessor() to handle tool call deduplication
- Tracks tool IDs seen via tool-input-start streaming events
- Emits tool-call events only for tools that weren't streamed
- Converts tool-call to start/delta/end for UI consistency
- Update HuggingFace provider to use the new processor
- Add comprehensive tests for the new functionality

Author: daniel-lxs

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

@@ -550,7 +550,9 @@ describe("HuggingFaceHandler", () => {
 			expect(toolCallEndChunks[0].id).toBe("tool-call-1")
 		})
 
-		it("should ignore tool-call events to prevent duplicate tools in UI", async () => {
+		it("should process tool-call events for non-streaming providers", async () => {
+			// HuggingFace doesn't stream tool inputs, it only emits tool-call events
+			// The processor should convert tool-call to start/delta/end events
 			async function* mockFullStream() {
 				yield {
 					type: "tool-call",
@@ -579,11 +581,65 @@ describe("HuggingFaceHandler", () => {
 				chunks.push(chunk)
 			}
 
-			// tool-call events should be ignored (only tool-input-start/delta/end are processed)
-			const toolCallChunks = chunks.filter(
-				(c) => c.type === "tool_call_start" || c.type === "tool_call_delta" || c.type === "tool_call_end",
-			)
-			expect(toolCallChunks.length).toBe(0)
+			// tool-call events should be converted to start/delta/end for consistency
+			const toolCallStartChunks = chunks.filter((c) => c.type === "tool_call_start")
+			const toolCallDeltaChunks = chunks.filter((c) => c.type === "tool_call_delta")
+			const toolCallEndChunks = chunks.filter((c) => c.type === "tool_call_end")
+
+			expect(toolCallStartChunks.length).toBe(1)
+			expect(toolCallStartChunks[0].id).toBe("tool-call-1")
+			expect(toolCallStartChunks[0].name).toBe("read_file")
+
+			expect(toolCallDeltaChunks.length).toBe(1)
+			expect(toolCallDeltaChunks[0].delta).toBe('{"path":"test.ts"}')
+
+			expect(toolCallEndChunks.length).toBe(1)
+			expect(toolCallEndChunks[0].id).toBe("tool-call-1")
+		})
+
+		it("should ignore tool-call events when tool was already streamed", async () => {
+			// When a provider streams tool inputs AND sends tool-call, we should not duplicate
+			async function* mockFullStream() {
+				// First, streaming events
+				yield { type: "tool-input-start", id: "tool-call-1", toolName: "read_file" }
+				yield { type: "tool-input-delta", id: "tool-call-1", delta: '{"path":"test.ts"}' }
+				yield { type: "tool-input-end", id: "tool-call-1" }
+				// Then the tool-call event (should be ignored)
+				yield {
+					type: "tool-call",
+					toolCallId: "tool-call-1",
+					toolName: "read_file",
+					input: { path: "test.ts" },
+				}
+			}
+
+			const mockUsage = Promise.resolve({
+				inputTokens: 10,
+				outputTokens: 5,
+			})
+
+			const mockProviderMetadata = Promise.resolve({})
+
+			mockStreamText.mockReturnValue({
+				fullStream: mockFullStream(),
+				usage: mockUsage,
+				providerMetadata: mockProviderMetadata,
+			})
+
+			const stream = handler.createMessage(systemPrompt, messages)
+			const chunks: any[] = []
+			for await (const chunk of stream) {
+				chunks.push(chunk)
+			}
+
+			// Should have exactly 1 of each (not duplicated)
+			const toolCallStartChunks = chunks.filter((c) => c.type === "tool_call_start")
+			const toolCallDeltaChunks = chunks.filter((c) => c.type === "tool_call_delta")
+			const toolCallEndChunks = chunks.filter((c) => c.type === "tool_call_end")
+
+			expect(toolCallStartChunks.length).toBe(1)
+			expect(toolCallDeltaChunks.length).toBe(1)
+			expect(toolCallEndChunks.length).toBe(1)
 		})
 	})
 })

src/api/providers/huggingface.ts

@@ -9,7 +9,7 @@ import type { ApiHandlerOptions } from "../../shared/api"
 import {
 	convertToAiSdkMessages,
 	convertToolsForAiSdk,
-	processAiSdkStreamPart,
+	createAiSdkToolStreamProcessor,
 	mapToolChoice,
 	handleAiSdkError,
 } from "../transform/ai-sdk"
@@ -168,9 +168,12 @@ export class HuggingFaceHandler extends BaseProvider implements SingleCompletion
 		const result = streamText(requestOptions)
 
 		try {
-			// Process the full stream to get all events including reasoning
+			// Use the stateful processor to handle tool call deduplication
+			// HuggingFace doesn't emit streaming tool events (tool-input-start/delta/end),
+			// only the final tool-call event, so we need the processor to handle this
+			const processStreamPart = createAiSdkToolStreamProcessor()
 			for await (const part of result.fullStream) {
-				for (const chunk of processAiSdkStreamPart(part)) {
+				for (const chunk of processStreamPart(part)) {
 					yield chunk
 				}
 			}

src/api/transform/__tests__/ai-sdk.spec.ts

@@ -4,6 +4,7 @@ import {
 	convertToAiSdkMessages,
 	convertToolsForAiSdk,
 	processAiSdkStreamPart,
+	createAiSdkToolStreamProcessor,
 	mapToolChoice,
 	extractAiSdkErrorMessage,
 	handleAiSdkError,
@@ -495,6 +496,148 @@ describe("AI SDK conversion utilities", () => {
 		})
 	})
 
+	describe("createAiSdkToolStreamProcessor", () => {
+		it("processes text-delta chunks like processAiSdkStreamPart", () => {
+			const processor = createAiSdkToolStreamProcessor()
+			const part = { type: "text-delta" as const, id: "1", text: "Hello" }
+			const chunks = [...processor(part)]
+
+			expect(chunks).toHaveLength(1)
+			expect(chunks[0]).toEqual({ type: "text", text: "Hello" })
+		})
+
+		it("processes tool-input-start/delta/end events (streaming tools)", () => {
+			const processor = createAiSdkToolStreamProcessor()
+
+			// Simulate streaming tool events
+			const startChunks = [
+				...processor({ type: "tool-input-start" as const, id: "call_1", toolName: "read_file" }),
+			]
+			const deltaChunks = [...processor({ type: "tool-input-delta" as const, id: "call_1", delta: '{"path":' })]
+			const delta2Chunks = [
+				...processor({ type: "tool-input-delta" as const, id: "call_1", delta: '"test.ts"}' }),
+			]
+			const endChunks = [...processor({ type: "tool-input-end" as const, id: "call_1" })]
+
+			expect(startChunks).toHaveLength(1)
+			expect(startChunks[0]).toEqual({ type: "tool_call_start", id: "call_1", name: "read_file" })
+
+			expect(deltaChunks).toHaveLength(1)
+			expect(deltaChunks[0]).toEqual({ type: "tool_call_delta", id: "call_1", delta: '{"path":' })
+
+			expect(delta2Chunks).toHaveLength(1)
+			expect(delta2Chunks[0]).toEqual({ type: "tool_call_delta", id: "call_1", delta: '"test.ts"}' })
+
+			expect(endChunks).toHaveLength(1)
+			expect(endChunks[0]).toEqual({ type: "tool_call_end", id: "call_1" })
+		})
+
+		it("ignores tool-call events when tool was already streamed", () => {
+			const processor = createAiSdkToolStreamProcessor()
+
+			// Process streaming events first (consume the generator to update state)
+			Array.from(processor({ type: "tool-input-start" as const, id: "call_1", toolName: "read_file" }))
+			Array.from(processor({ type: "tool-input-delta" as const, id: "call_1", delta: '{"path":"test.ts"}' }))
+			Array.from(processor({ type: "tool-input-end" as const, id: "call_1" }))
+
+			// Now the tool-call event for the same tool should be ignored
+			const toolCallChunks = [
+				...processor({
+					type: "tool-call" as const,
+					toolCallId: "call_1",
+					toolName: "read_file",
+					input: { path: "test.ts" },
+				} as any),
+			]
+
+			expect(toolCallChunks).toHaveLength(0)
+		})
+
+		it("processes tool-call events for non-streaming providers", () => {
+			const processor = createAiSdkToolStreamProcessor()
+
+			// Directly process a tool-call event (no streaming events first)
+			const chunks = [
+				...processor({
+					type: "tool-call" as const,
+					toolCallId: "call_1",
+					toolName: "read_file",
+					input: { path: "test.ts" },
+				} as any),
+			]
+
+			// Should emit start/delta/end events
+			expect(chunks).toHaveLength(3)
+			expect(chunks[0]).toEqual({ type: "tool_call_start", id: "call_1", name: "read_file" })
+			expect(chunks[1]).toEqual({ type: "tool_call_delta", id: "call_1", delta: '{"path":"test.ts"}' })
+			expect(chunks[2]).toEqual({ type: "tool_call_end", id: "call_1" })
+		})
+
+		it("handles multiple tool calls correctly", () => {
+			const processor = createAiSdkToolStreamProcessor()
+
+			// First tool is streamed
+			Array.from(processor({ type: "tool-input-start" as const, id: "call_1", toolName: "read_file" }))
+			Array.from(processor({ type: "tool-input-end" as const, id: "call_1" }))
+
+			// Second tool is not streamed (non-streaming provider behavior)
+			const chunks = [
+				...processor({
+					type: "tool-call" as const,
+					toolCallId: "call_2",
+					toolName: "write_to_file",
+					input: { path: "output.ts", content: "test" },
+				} as any),
+			]
+
+			// Second tool should be emitted
+			expect(chunks).toHaveLength(3)
+			expect(chunks[0]).toEqual({ type: "tool_call_start", id: "call_2", name: "write_to_file" })
+
+			// First tool's tool-call should be ignored
+			const ignoredChunks = [
+				...processor({
+					type: "tool-call" as const,
+					toolCallId: "call_1",
+					toolName: "read_file",
+					input: {},
+				} as any),
+			]
+			expect(ignoredChunks).toHaveLength(0)
+		})
+
+		it("maintains separate state per processor instance", () => {
+			const processor1 = createAiSdkToolStreamProcessor()
+			const processor2 = createAiSdkToolStreamProcessor()
+
+			// Stream a tool with processor1
+			Array.from(processor1({ type: "tool-input-start" as const, id: "call_1", toolName: "test" }))
+			Array.from(processor1({ type: "tool-input-end" as const, id: "call_1" }))
+
+			// processor1 should ignore tool-call for call_1
+			const p1Chunks = [
+				...processor1({
+					type: "tool-call" as const,
+					toolCallId: "call_1",
+					toolName: "test",
+					input: {},
+				} as any),
+			]
+			expect(p1Chunks).toHaveLength(0)
+
+			// processor2 should emit tool-call for call_1 (it has its own state)
+			const p2Chunks = [
+				...processor2({
+					type: "tool-call" as const,
+					toolCallId: "call_1",
+					toolName: "test",
+					input: {},
+				} as any),
+			]
+			expect(p2Chunks).toHaveLength(3)
+		})
+	})
+
 	describe("mapToolChoice", () => {
 		it("should return undefined for null or undefined", () => {
 			expect(mapToolChoice(null)).toBeUndefined()

src/api/transform/ai-sdk.ts

@@ -364,6 +364,95 @@ export function* processAiSdkStreamPart(part: ExtendedStreamPart): Generator<Api
 	}
 }
 
+/**
+ * Creates a stateful stream processor that handles tool call deduplication.
+ * Some AI SDK providers (like HuggingFace) don't emit streaming tool events
+ * (tool-input-start/delta/end), only the final tool-call event. This function
+ * returns a processor that tracks which tools have been processed via streaming
+ * events and emits tool-call events only for tools that weren't streamed.
+ *
+ * Usage:
+ * ```typescript
+ * const processStreamPart = createAiSdkToolStreamProcessor()
+ * for await (const part of result.fullStream) {
+ *     for (const chunk of processStreamPart(part)) {
+ *         yield chunk
+ *     }
+ * }
+ * ```
+ *
+ * @returns A generator function that processes stream parts with tool deduplication
+ */
+export function createAiSdkToolStreamProcessor(): (
+	part: ExtendedStreamPart,
+) => Generator<ApiStreamChunk, void, unknown> {
+	// Track tool IDs that have been processed via streaming events
+	const streamedToolIds = new Set<string>()
+
+	return function* processStreamPart(part: ExtendedStreamPart): Generator<ApiStreamChunk> {
+		switch (part.type) {
+			case "tool-input-start":
+				// Track that this tool has streaming events
+				streamedToolIds.add(part.id)
+				yield {
+					type: "tool_call_start",
+					id: part.id,
+					name: part.toolName,
+				}
+				break
+
+			case "tool-input-delta":
+				yield {
+					type: "tool_call_delta",
+					id: part.id,
+					delta: part.delta,
+				}
+				break
+
+			case "tool-input-end":
+				yield {
+					type: "tool_call_end",
+					id: part.id,
+				}
+				break
+
+			case "tool-call": {
+				// Only emit tool-call if this tool wasn't already processed via streaming
+				const toolCallPart = part as {
+					type: "tool-call"
+					toolCallId: string
+					toolName: string
+					input: unknown
+				}
+				if (!streamedToolIds.has(toolCallPart.toolCallId)) {
+					// Emit as start/delta/end for consistency with streaming providers
+					const args = JSON.stringify(toolCallPart.input)
+					yield {
+						type: "tool_call_start",
+						id: toolCallPart.toolCallId,
+						name: toolCallPart.toolName,
+					}
+					yield {
+						type: "tool_call_delta",
+						id: toolCallPart.toolCallId,
+						delta: args,
+					}
+					yield {
+						type: "tool_call_end",
+						id: toolCallPart.toolCallId,
+					}
+				}
+				break
+			}
+
+			// Handle all other events with the stateless processor
+			default:
+				yield* processAiSdkStreamPart(part)
+				break
+		}
+	}
+}
+
 /**
  * Type for AI SDK tool choice format.
  */