fix(service-ai): yield tool-result events in streamChatWithTools SSE stream

Previously, streamChatWithTools only yielded tool-call events but not
tool-result events. Tool results were pushed to the conversation but
never emitted via SSE, making it impossible for the frontend to track
tool output in real-time.

Now each tool execution result is yielded as a tool-result TextStreamPart
before being appended to the conversation, which the encoder maps to
tool-output-available SSE chunks.

Agent-Logs-Url: https://github.com/objectstack-ai/framework/sessions/6af7123e-c579-4a8f-84f6-a58107c88797

Co-authored-by: hotlong <50353452+hotlong@users.noreply.github.com>

Author: Copilot

packages/services/service-ai/src/__tests__/auth-and-toolcalling.test.ts

@@ -521,16 +521,64 @@ describe('streamChatWithTools', () => {
       events.push(event);
     }
 
-    // Should have tool-call event followed by text-delta + finish (no double call)
+    // Should have tool-call + tool-result events followed by text-delta + finish
     const toolCallEvents = events.filter(e => e.type === 'tool-call');
     expect(toolCallEvents).toHaveLength(1);
     expect((toolCallEvents[0] as any).toolName).toBe('get_weather');
 
+    const toolResultEvents = events.filter(e => e.type === 'tool-result');
+    expect(toolResultEvents).toHaveLength(1);
+    expect((toolResultEvents[0] as any).toolCallId).toBe('call_1');
+    expect((toolResultEvents[0] as any).toolName).toBe('get_weather');
+
     const finishEvent = events.find(e => e.type === 'finish');
     expect(finishEvent).toBeDefined();
     expect(adapter.chat).toHaveBeenCalledTimes(2);
   });
 
+  it('should yield tool-result events with tool output', async () => {
+    const toolCall: ToolCallPart = {
+      type: 'tool-call',
+      toolCallId: 'call_weather',
+      toolName: 'get_weather',
+      input: { city: 'Paris' },
+    };
+
+    let chatCallIndex = 0;
+    const adapter: LLMAdapter = {
+      name: 'mock-stream',
+      chat: vi.fn(async () => {
+        chatCallIndex++;
+        if (chatCallIndex === 1) {
+          return { content: '', toolCalls: [toolCall] };
+        }
+        return { content: 'Paris is 22°C' };
+      }),
+      complete: vi.fn(async () => ({ content: '' })),
+    };
+
+    const service = new AIService({ adapter, logger: silentLogger, toolRegistry: registry });
+    const events: TextStreamPart<ToolSet>[] = [];
+    for await (const event of service.streamChatWithTools(
+      [{ role: 'user', content: 'Weather in Paris?' }],
+    )) {
+      events.push(event);
+    }
+
+    // Verify the tool-result contains actual tool output
+    const toolResultEvents = events.filter(e => e.type === 'tool-result');
+    expect(toolResultEvents).toHaveLength(1);
+    const toolResult = toolResultEvents[0] as any;
+    expect(toolResult.toolCallId).toBe('call_weather');
+    expect(toolResult.toolName).toBe('get_weather');
+    expect(toolResult.output).toEqual({ type: 'text', value: JSON.stringify({ temp: 22, city: 'Paris' }) });
+
+    // Verify order: tool-call comes before tool-result
+    const toolCallIdx = events.findIndex(e => e.type === 'tool-call');
+    const toolResultIdx = events.findIndex(e => e.type === 'tool-result');
+    expect(toolCallIdx).toBeLessThan(toolResultIdx);
+  });
+
   it('should fall back to non-streaming when adapter has no streamChat', async () => {
     const adapter: LLMAdapter = {
       name: 'no-stream',

packages/services/service-ai/src/ai-service.ts

@@ -332,6 +332,13 @@ export class AIService implements IAIService {
             }
           }
         }
+        // Emit tool-result so the client can see tool output via SSE
+        yield {
+          type: 'tool-result',
+          toolCallId: tr.toolCallId,
+          toolName: tr.toolName,
+          output: tr.output,
+        } as TextStreamPart<ToolSet>;
         conversation.push({
           role: 'tool',
           content: [tr],