fix(huggingface): defer tool_call_end until arguments received

The sequence must be start → delta → end. For HuggingFace:
- tool-input-start emits tool_call_start
- tool-input-end is DEFERRED (no deltas yet, args not received)
- tool-call emits tool_call_delta + deferred tool_call_end

This ensures arguments appear before the end event.

Author: daniel-lxs

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

@@ -580,9 +580,10 @@ describe("AI SDK conversion utilities", () => {
 			const startChunks = [
 				...processor({ type: "tool-input-start" as const, id: "call_1", toolName: "read_file" }),
 			]
+			// End is deferred since we haven't received deltas yet
 			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
+			// tool-call should emit the delta (arguments) AND the deferred end
 			const toolCallChunks = [
 				...processor({
 					type: "tool-call" as const,
@@ -595,16 +596,20 @@ describe("AI SDK conversion utilities", () => {
 			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" })
+			// End is deferred when no deltas received
+			expect(endChunks).toHaveLength(0)
 
-			// The tool-call should emit just the delta with arguments
-			expect(toolCallChunks).toHaveLength(1)
+			// tool-call emits delta followed by the deferred end
+			expect(toolCallChunks).toHaveLength(2)
 			expect(toolCallChunks[0]).toEqual({
 				type: "tool_call_delta",
 				id: "call_1",
 				delta: '{"path":"test.ts"}',
 			})
+			expect(toolCallChunks[1]).toEqual({
+				type: "tool_call_end",
+				id: "call_1",
+			})
 		})
 
 		it("handles multiple tool calls correctly", () => {

src/api/transform/ai-sdk.ts

@@ -300,6 +300,8 @@ export function createAiSdkToolStreamProcessor(): (
 	const startedToolIds = new Set<string>()
 	// Track tool IDs that have received actual argument deltas
 	const toolsWithDeltas = new Set<string>()
+	// Track tool IDs that have ended but are waiting for arguments from tool-call
+	const pendingEndToolIds = new Set<string>()
 
 	return function* processStreamPart(part: ExtendedStreamPart): Generator<ApiStreamChunk> {
 		switch (part.type) {
@@ -324,9 +326,16 @@ export function createAiSdkToolStreamProcessor(): (
 				break
 
 			case "tool-input-end":
-				yield {
-					type: "tool_call_end",
-					id: part.id,
+				// If we already have deltas, we can emit the end now
+				// Otherwise, defer the end until we get arguments from tool-call
+				if (toolsWithDeltas.has(part.id)) {
+					yield {
+						type: "tool_call_end",
+						id: part.id,
+					}
+				} else {
+					// HuggingFace case: started but no deltas, arguments will come in tool-call
+					pendingEndToolIds.add(part.id)
 				}
 				break
 
@@ -345,14 +354,22 @@ export function createAiSdkToolStreamProcessor(): (
 				}
 
 				// If tool was started but no deltas received (like HuggingFace),
-				// emit the arguments from tool-call as a delta
+				// emit the arguments from tool-call as a delta, then the pending end
 				if (startedToolIds.has(toolCallPart.toolCallId)) {
 					const args = JSON.stringify(toolCallPart.input)
 					yield {
 						type: "tool_call_delta",
 						id: toolCallPart.toolCallId,
 						delta: args,
 					}
+					// Now emit the deferred end
+					if (pendingEndToolIds.has(toolCallPart.toolCallId)) {
+						pendingEndToolIds.delete(toolCallPart.toolCallId)
+						yield {
+							type: "tool_call_end",
+							id: toolCallPart.toolCallId,
+						}
+					}
 					break
 				}