fix(huggingface): properly handle tool arguments when streaming without deltas

HuggingFace SDK emits tool-input-start/end but NOT tool-input-delta.
The arguments come in the final tool-call event. The fix now:
1. Tracks tools that received actual deltas (toolsWithDeltas)
2. If tool-call arrives and tool was started but had no deltas,
   emit the arguments as a delta (HuggingFace-like behavior)
3. If tool-call arrives and tool had deltas, ignore it (fully streamed)
4. If tool-call arrives and tool wasn't started, emit full sequence

Author: daniel-lxs

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

@@ -573,11 +573,47 @@ describe("AI SDK conversion utilities", () => {
 			expect(chunks[2]).toEqual({ type: "tool_call_end", id: "call_1" })
 		})
 
+		it("handles HuggingFace-like providers (start/end but no deltas, args in tool-call)", () => {
+			const processor = createAiSdkToolStreamProcessor()
+
+			// HuggingFace emits tool-input-start and tool-input-end but NOT tool-input-delta
+			// The arguments come in the tool-call event
+			const startChunks = [
+				...processor({ type: "tool-input-start" as const, id: "call_1", toolName: "read_file" }),
+			]
+			const endChunks = [...processor({ type: "tool-input-end" as const, id: "call_1" })]
+
+			// tool-call should emit just the delta (arguments) since start/end were already emitted
+			const toolCallChunks = [
+				...processor({
+					type: "tool-call" as const,
+					toolCallId: "call_1",
+					toolName: "read_file",
+					input: { path: "test.ts" },
+				} as any),
+			]
+
+			expect(startChunks).toHaveLength(1)
+			expect(startChunks[0]).toEqual({ type: "tool_call_start", id: "call_1", name: "read_file" })
+
+			expect(endChunks).toHaveLength(1)
+			expect(endChunks[0]).toEqual({ type: "tool_call_end", id: "call_1" })
+
+			// The tool-call should emit just the delta with arguments
+			expect(toolCallChunks).toHaveLength(1)
+			expect(toolCallChunks[0]).toEqual({
+				type: "tool_call_delta",
+				id: "call_1",
+				delta: '{"path":"test.ts"}',
+			})
+		})
+
 		it("handles multiple tool calls correctly", () => {
 			const processor = createAiSdkToolStreamProcessor()
 
-			// First tool is streamed
+			// First tool is fully streamed with deltas
 			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":"a.ts"}' }))
 			Array.from(processor({ type: "tool-input-end" as const, id: "call_1" }))
 
 			// Second tool is not streamed (non-streaming provider behavior)
@@ -590,17 +626,17 @@ describe("AI SDK conversion utilities", () => {
 				} as any),
 			]
 
-			// Second tool should be emitted
+			// Second tool should be emitted with full start/delta/end
 			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
+			// First tool's tool-call should be ignored (it had deltas)
 			const ignoredChunks = [
 				...processor({
 					type: "tool-call" as const,
 					toolCallId: "call_1",
 					toolName: "read_file",
-					input: {},
+					input: { path: "a.ts" },
 				} as any),
 			]
 			expect(ignoredChunks).toHaveLength(0)
@@ -610,11 +646,12 @@ describe("AI SDK conversion utilities", () => {
 			const processor1 = createAiSdkToolStreamProcessor()
 			const processor2 = createAiSdkToolStreamProcessor()
 
-			// Stream a tool with processor1
+			// Stream a tool fully with processor1 (with delta)
 			Array.from(processor1({ type: "tool-input-start" as const, id: "call_1", toolName: "test" }))
+			Array.from(processor1({ type: "tool-input-delta" as const, id: "call_1", delta: "{}" }))
 			Array.from(processor1({ type: "tool-input-end" as const, id: "call_1" }))
 
-			// processor1 should ignore tool-call for call_1
+			// processor1 should ignore tool-call for call_1 (it had deltas)
 			const p1Chunks = [
 				...processor1({
 					type: "tool-call" as const,

src/api/transform/ai-sdk.ts

@@ -386,14 +386,16 @@ export function* processAiSdkStreamPart(part: ExtendedStreamPart): Generator<Api
 export function createAiSdkToolStreamProcessor(): (
 	part: ExtendedStreamPart,
 ) => Generator<ApiStreamChunk, void, unknown> {
-	// Track tool IDs that have been processed via streaming events
-	const streamedToolIds = new Set<string>()
+	// Track tool IDs that have been started via streaming events
+	const startedToolIds = new Set<string>()
+	// Track tool IDs that have received actual argument deltas
+	const toolsWithDeltas = 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)
+				// Track that this tool has started streaming
+				startedToolIds.add(part.id)
 				yield {
 					type: "tool_call_start",
 					id: part.id,
@@ -402,6 +404,8 @@ export function createAiSdkToolStreamProcessor(): (
 				break
 
 			case "tool-input-delta":
+				// Track that we received actual argument content for this tool
+				toolsWithDeltas.add(part.id)
 				yield {
 					type: "tool_call_delta",
 					id: part.id,
@@ -417,30 +421,46 @@ export function createAiSdkToolStreamProcessor(): (
 				break
 
 			case "tool-call": {
-				// Only emit tool-call if this tool wasn't already processed via streaming
+				// Handle tool-call events - the logic depends on whether we got streaming deltas
 				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
+
+				// If we received deltas, the arguments were already streamed - ignore tool-call
+				if (toolsWithDeltas.has(toolCallPart.toolCallId)) {
+					break
+				}
+
+				// If tool was started but no deltas received (like HuggingFace),
+				// emit the arguments from tool-call as a delta
+				if (startedToolIds.has(toolCallPart.toolCallId)) {
 					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
+				}
+
+				// Tool wasn't started via streaming - emit full start/delta/end sequence
+				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
 			}