feat: include tool responses in getNewMessagesStream

Update getNewMessagesStream to yield ToolResponseMessage objects
after tool execution completes, in addition to AssistantMessages.
This allows consumers to receive the full message flow including
tool call results.

Author: mattapperson

src/lib/response-wrapper.ts

@@ -379,16 +379,45 @@ export class ResponseWrapper {
   /**
    * Stream incremental message updates as content is added.
    * Each iteration yields an updated version of the message with new content.
-   * Returns AssistantMessage in chat format.
+   * Also yields ToolResponseMessages after tool execution completes.
+   * Returns AssistantMessage or ToolResponseMessage in chat format.
    */
-  getNewMessagesStream(): AsyncIterableIterator<models.AssistantMessage> {
+  getNewMessagesStream(): AsyncIterableIterator<models.AssistantMessage | models.ToolResponseMessage> {
     return (async function* (this: ResponseWrapper) {
       await this.initStream();
       if (!this.reusableStream) {
         throw new Error("Stream not initialized");
       }
 
+      // First yield assistant messages from the stream
       yield* buildMessageStream(this.reusableStream);
+
+      // Execute tools if needed
+      await this.executeToolsIfNeeded();
+
+      // Yield tool response messages for each executed tool
+      for (const round of this.allToolExecutionRounds) {
+        for (const toolCall of round.toolCalls) {
+          // Find the tool to check if it was executed
+          const tool = this.options.tools?.find((t) => t.function.name === toolCall.name);
+          if (!tool || !hasExecuteFunction(tool)) {
+            continue;
+          }
+
+          // Get the result from preliminary results or construct from the response
+          const prelimResults = this.preliminaryResults.get(toolCall.id);
+          const result = prelimResults && prelimResults.length > 0
+            ? prelimResults[prelimResults.length - 1] // Last result is the final output
+            : undefined;
+
+          // Yield tool response message
+          yield {
+            role: "tool" as const,
+            content: result !== undefined ? JSON.stringify(result) : "",
+            toolCallId: toolCall.id,
+          } as models.ToolResponseMessage;
+        }
+      }
     }.call(this));
   }
 

tests/e2e/callModel.test.ts

@@ -108,6 +108,46 @@ describe("callModel E2E Tests", () => {
 
       const message = await response.getMessage();
 
+      // Ensure the message fully matches the OpenAI Chat API assistant message shape
+      expect(message).toMatchObject({
+        role: "assistant",
+        content: expect.anything(),
+      });
+      // content can be string, array, or null according to OpenAI spec
+      // Check rest of top-level shape
+      expect(Object.keys(message)).toEqual(
+        expect.arrayContaining([
+          "role",
+          "content",
+          // Optionally some implementations may also include:
+          // "tool_calls", "function_call", "tool_call_id", "name"
+        ])
+      );
+      // If content is array, match OpenAI content block shape
+      if (Array.isArray(message.content)) {
+        for (const block of message.content) {
+          expect(block).toMatchObject({
+            type: expect.any(String),
+            // text blocks have 'text', others may have different keys
+          });
+        }
+      }
+      // If present, tool_calls in OpenAI schema must be an array of objects
+      if (message.role === "assistant" && message.toolCalls) {
+        expect(Array.isArray(message.toolCalls)).toBe(true);
+        for (const call of message.toolCalls) {
+          expect(call).toMatchObject({
+            id: expect.any(String),
+            type: expect.any(String),
+            function: expect.any(Object),
+          });
+          expect(call.function).toMatchObject({
+            name: expect.any(String),
+            arguments: expect.any(String),
+          });
+        }
+      }
+
       expect(message).toBeDefined();
       expect(message.role).toBe("assistant");
       expect(message.content).toBeDefined();