fix(providers): retain Prism streaming tool results

Author: rajitkhanna

apps/sim/providers/prism/index.test.ts

@@ -129,81 +129,96 @@ describe('prismProvider', () => {
     )
   })
 
-  it('uses the shared tool loop with reasoning replay and returns tool results', async () => {
-    mockPrepareTools.mockReturnValue({
-      tools: [
-        {
-          type: 'function',
-          function: {
-            name: 'lookup',
-            description: 'Look up a value',
-            parameters: { type: 'object', properties: {}, required: [] },
-          },
-        },
-      ],
-      toolChoice: 'auto',
-      forcedTools: [],
-    })
-    mockCreateToolStream.mockImplementation(
-      (options: { onComplete: (result: Record<string, unknown>) => void }) => {
-        options.onComplete({
-          content: 'Found it',
-          tokens: { input: 10, output: 5, total: 15 },
-          cost: { input: 0, output: 0, toolCost: 0.25, total: 0.25 },
-          toolCalls: { list: [], count: 0 },
-          toolResults: [{ value: 'result' }],
-          modelTime: 1,
-          toolsTime: 1,
-          firstResponseTime: 1,
-          iterations: 2,
-        })
-        return new ReadableStream({
-          start(controller) {
-            controller.close()
-          },
-        })
-      }
-    )
-
-    const result = await prismProvider.executeRequest(
-      request({
-        responseFormat: undefined,
+  it.each([
+    { mode: 'non-streaming', stream: false },
+    { mode: 'streaming', stream: true },
+  ])(
+    'uses the shared tool loop with reasoning replay and returns tool results ($mode)',
+    async ({ stream }) => {
+      mockPrepareTools.mockReturnValue({
         tools: [
           {
-            id: 'lookup',
-            description: 'Look up a value',
-            params: {},
-            parameters: { type: 'object', properties: {}, required: [] },
+            type: 'function',
+            function: {
+              name: 'lookup',
+              description: 'Look up a value',
+              parameters: { type: 'object', properties: {}, required: [] },
+            },
           },
         ],
+        toolChoice: 'auto',
+        forcedTools: [],
       })
-    )
+      mockCreateToolStream.mockImplementation(
+        (options: { onComplete: (result: Record<string, unknown>) => void }) => {
+          options.onComplete({
+            content: 'Found it',
+            tokens: { input: 10, output: 5, total: 15 },
+            cost: { input: 0, output: 0, toolCost: 0.25, total: 0.25 },
+            toolCalls: { list: [], count: 0 },
+            toolResults: [{ value: 'result' }],
+            modelTime: 1,
+            toolsTime: 1,
+            firstResponseTime: 1,
+            iterations: 2,
+          })
+          return new ReadableStream({
+            start(controller) {
+              controller.close()
+            },
+          })
+        }
+      )
+
+      const result = await prismProvider.executeRequest(
+        request({
+          responseFormat: undefined,
+          stream,
+          tools: [
+            {
+              id: 'lookup',
+              description: 'Look up a value',
+              params: {},
+              parameters: { type: 'object', properties: {}, required: [] },
+            },
+          ],
+        })
+      )
+
+      expect(mockCreateToolStream).toHaveBeenCalledWith(
+        expect.objectContaining({
+          providerName: 'Prism',
+          preserveAssistantReasoning: true,
+          basePayload: expect.objectContaining({
+            model: 'prism/deepseek-v4.1-flash',
+            tool_choice: 'auto',
+          }),
+        })
+      )
 
-    expect(mockCreateToolStream).toHaveBeenCalledWith(
-      expect.objectContaining({
-        providerName: 'Prism',
-        preserveAssistantReasoning: true,
-        basePayload: expect.objectContaining({
-          model: 'prism/deepseek-v4.1-flash',
-          tool_choice: 'auto',
-        }),
+      if ('stream' in result) {
+        const reader = result.stream.getReader()
+        while (!(await reader.read()).done) {}
+        expect(result.execution.output.toolResults).toEqual([{ value: 'result' }])
+        return
+      }
+
+      expect(result).toMatchObject({ toolResults: [{ value: 'result' }] })
+      expect(mockCalculateCost).toHaveBeenCalledWith('prism/deepseek-v4.1-flash', 10, 5)
+      expect(result.cost).toEqual({
+        input: 0.000003,
+        output: 0.000006,
+        toolCost: 0.25,
+        total: 0.250009,
+        pricing: {
+          input: 0.3,
+          cachedInput: 0.07,
+          output: 1.2,
+          updatedAt: '2026-09-12',
+        },
       })
-    )
-    expect(result).toMatchObject({ toolResults: [{ value: 'result' }] })
-    expect(mockCalculateCost).toHaveBeenCalledWith('prism/deepseek-v4.1-flash', 10, 5)
-    expect(result.cost).toEqual({
-      input: 0.000003,
-      output: 0.000006,
-      toolCost: 0.25,
-      total: 0.250009,
-      pricing: {
-        input: 0.3,
-        cachedInput: 0.07,
-        output: 1.2,
-        updatedAt: '2026-09-12',
-      },
-    })
-  })
+    }
+  )
 
   it.each(['none', 'low', 'medium', 'high'])('sends Prism reasoning effort %s', async (value) => {
     await prismProvider.executeRequest(request({ reasoningEffort: value }))

apps/sim/providers/prism/index.ts

@@ -9,8 +9,8 @@ import type {
 import type { NormalizedBlockOutput, StreamingExecution } from '@/executor/types'
 import { formatMessagesForProvider } from '@/providers/attachments'
 import { getProviderDefaultModel, getProviderModels } from '@/providers/models'
+import { createOpenAICompatibleAgentEventStream } from '@/providers/openai-compat/stream-events'
 import { createOpenAICompatStreamingToolLoopStream } from '@/providers/openai-compat/streaming-tool-loop'
-import { createReadableStreamFromPrismStream } from '@/providers/prism/utils'
 import type { AgentStreamEvent } from '@/providers/stream-events'
 import { createStreamingExecution } from '@/providers/streaming-execution'
 import type { StreamingToolLoopComplete } from '@/providers/streaming-tool-loop-shared'
@@ -183,6 +183,7 @@ export const prismProvider: ProviderConfig = {
                 output.tokens = result.tokens
                 output.cost = result.cost
                 output.toolCalls = result.toolCalls as NormalizedBlockOutput['toolCalls']
+                output.toolResults = result.toolResults
                 if (output.providerTiming) {
                   output.providerTiming.modelTime = result.modelTime
                   output.providerTiming.toolsTime = result.toolsTime
@@ -251,23 +252,26 @@ export const prismProvider: ProviderConfig = {
           isStreaming: true,
           streamFormat: 'agent-events-v1',
           createStream: ({ output, finalizeTiming }) =>
-            createReadableStreamFromPrismStream(streamResponse, (content, usage, thinking) => {
-              output.content = content
-              output.tokens = {
-                input: usage.prompt_tokens,
-                output: usage.completion_tokens,
-                total: usage.total_tokens,
-              }
-              output.cost = calculateCost(
-                request.model,
-                usage.prompt_tokens,
-                usage.completion_tokens
-              )
-              if (thinking) {
-                const segment = output.providerTiming?.timeSegments?.[0]
-                if (segment) segment.thinkingContent = thinking
-              }
-              finalizeTiming()
+            createOpenAICompatibleAgentEventStream(streamResponse, {
+              providerName: 'Prism',
+              onComplete: (result) => {
+                output.content = result.content
+                output.tokens = {
+                  input: result.usage.prompt_tokens,
+                  output: result.usage.completion_tokens,
+                  total: result.usage.total_tokens,
+                }
+                output.cost = calculateCost(
+                  request.model,
+                  result.usage.prompt_tokens,
+                  result.usage.completion_tokens
+                )
+                if (result.thinking) {
+                  const segment = output.providerTiming?.timeSegments?.[0]
+                  if (segment) segment.thinkingContent = result.thinking
+                }
+                finalizeTiming()
+              },
             }),
         })
       }