@stack-spot/portal-network 1.0.0-dev.1769537511491 → 1.0.0-dev.1769793051111

package/src/client/discover.ts

@@ -2,16 +2,25 @@ import { HttpError } from '@oazapfts/runtime'
 import { findLast, last } from 'lodash'
 import { getApiAddresses } from '../api-addresses'
 import { ConversationResponse } from '../api/ai'
-import { create, create1, create2, defaults, deleteById, deleteById1, deleteById2, fetchInsights, getAll, getAll1, getAll2, getAllByHypothesis, getById, getById1, getById2, getInsightById, GetOpportunityResponse, AiChatRequest, refreshInsights } from '../api/discover'
+import { AiChatRequest, create, create1, create2, defaults, deleteById, deleteById1, deleteById2, fetchInsights, getAll, getAll1, getAll2, getAllByHypothesis, getById, getById1, getById2, getInsightById, GetOpportunityResponse, refreshInsights } from '../api/discover'
 import { DefaultAPIError } from '../error/DefaultAPIError'
+import { baseDictionary } from '../error/dictionary/base'
 import { StackspotAPIError } from '../error/StackspotAPIError'
+import { ReactQueryNetworkClient } from '../network/ReactQueryNetworkClient'
 import { StreamedJson } from '../utils/StreamedJson'
-import { baseDictionary } from '../error/dictionary/base'
 import { formatJson } from '../utils/string'
-import { ReactQueryNetworkClient } from '../network/ReactQueryNetworkClient'
-import { aiClient } from './ai'
-import { ChatAgentTool, ChatResponseWithSteps, FixedChatResponse, StepChatStep } from './types'
 import { agentToolsClient } from './agent-tools'
+import { aiClient } from './ai'
+import { AgentInfo, ChatAgentTool, ChatResponse, ChatStep, StepChatStep } from './types'
+
+export interface FixedDiscoveryChatResponse extends ChatResponse {
+  agent_info: AgentInfo[],
+  tools?: string[],
+}
+
+export interface DiscoveryChatResponseWithSteps extends FixedDiscoveryChatResponse {
+  steps: ChatStep[],
+}
 
 export interface ChatConversionDetails extends ConversationResponse {
   opportunityName?: string,
@@ -121,7 +130,8 @@ class DiscoverClient extends ReactQueryNetworkClient {
   }
 
 
-  sendChatMessage(request: AiChatRequest & { agentId: string }, minChangeIntervalMS?: number): StreamedJson<ChatResponseWithSteps> {
+  sendChatMessage(request: AiChatRequest & { agentId: string }, minChangeIntervalMS?: number)
+  : StreamedJson<DiscoveryChatResponseWithSteps> {
     const abortController = new AbortController()
     const headers = {
       'Content-Type': 'application/json',
@@ -136,172 +146,176 @@ class DiscoverClient extends ReactQueryNetworkClient {
        * normal streamings of data, we need this separate function to deal with them. It transforms the internal data model of the
        * StreamedJson object whenever an event is triggered.
        */
-    async function transform(event: Partial<FixedChatResponse>, data: Partial<ChatResponseWithSteps>) {
-      const info = event.agent_info
+    async function transform(event: Partial<FixedDiscoveryChatResponse>, data: Partial<DiscoveryChatResponseWithSteps>) {
+      const agentInfoList = event.agent_info
 
-      if (!info) return
+      if (!agentInfoList?.length) return
 
       const tools = await DiscoverClient.toolsOfAgent(request.agentId)
       data.steps = data.steps ? [...data.steps] : []
+      
+      for (const info of agentInfoList) {
+        if (!info) continue
 
-      if (info.type === 'planning' && info.action === 'end') {
-        data.steps.push({
-          id: 'planning',
-          type: 'planning',
-          status: 'success',
-          duration: info.duration || 0,
-          steps: info.data?.steps?.map(s => s.goal) ?? [],
-          goal: info.data?.plan_goal ?? '',
-        })
-
-        info.data?.steps.forEach(s => data.steps?.push({
-          id: s.id,
-          type: 'step',
-          status: 'pending',
-          input: s.goal,
-          attempts: [{
-            tools: s.tools?.map(t => ({
-              ...(tools.find(({ id }) => id === t.tool_id) ?? { id: t.tool_id, name: t.tool_id }),
-              executionId: t.tool_execution_id,
-              goal: t.goal,
-            })),
-          }],
-        }))
-        data.steps.push({ id: 'answer', type: 'answer', status: 'pending' })
-      }
-
-      if (info.type === 'planning' && info.action === 'awaiting_approval') {
-        data.steps.push({
-          id: 'planning',
-          type: 'planning',
-          status: 'awaiting_approval',
-          user_question: info.data?.user_question,
-          duration: info.duration || 0,
-          steps: info.data?.steps?.map(s => s.goal) ?? [],
-          goal: info.data?.plan_goal ?? '',
-        })
-        info.data?.steps.forEach(s => data.steps?.push({
-          id: s.id,
-          type: 'step',
-          status: 'pending',
-          input: s.goal,
-          attempts: [{
-            tools: s.tools?.map(t => ({
-              ...(tools.find(({ id }) => id === t.tool_id) ?? { id: t.tool_id, name: t.tool_id }),
-              executionId: t.tool_execution_id,
-              goal: t.goal,
-            })),
-          }],
-        }))
-        data.steps.push({ id: 'answer', type: 'answer', status: 'pending' })
-      }
-
-      if (info.type === 'step' && info.action === 'start') {
-        const step = data.steps.find(s => s.id === info.id)
-        if (step) step.status = 'running'
-      }
+        if (info.type === 'planning' && info.action === 'end') {
+          data.steps.push({
+            id: 'planning',
+            type: 'planning',
+            status: 'success',
+            duration: info.duration || 0,
+            steps: info.data?.steps?.map(s => s.goal) ?? [],
+            goal: info.data?.plan_goal ?? '',
+          })
 
-      if (info.type === 'step' && info.action === 'end') {
-        const step = data.steps.find(s => s.id === info.id) as StepChatStep
-        if (step) {
-          step.status = 'success'
-          step.duration = info.duration
-          const lastToolId = last(step.attempts[0].tools)?.id
-          const lastAttemptOfLastTool = findLast(step.attempts.map(a => a.tools).flat(), t => t?.id === lastToolId)
-          step.output = lastAttemptOfLastTool?.output
+          info.data?.steps.forEach(s => data.steps?.push({
+            id: s.id,
+            type: 'step',
+            status: 'pending',
+            input: s.goal,
+            attempts: [{
+              tools: s.tools?.map(t => ({
+                ...(tools.find(({ id }) => id === t.tool_id) ?? { id: t.tool_id, name: t.tool_id }),
+                executionId: t.tool_execution_id,
+                goal: t.goal,
+              })),
+            }],
+          }))
+          data.steps.push({ id: 'answer', type: 'answer', status: 'pending' })
         }
-      }
 
-      if (info.type === 'tool' && info.action === 'awaiting_approval') {
-        const tool = tools.find(({ id }) => id === info.data?.tool_id)
-        data.steps.push({
-          id: info.id,
-          type: 'tool',
-          status: 'awaiting_approval',
-          duration: info.duration || 0,
-          input: info.data?.input,
-          user_question: info.data?.user_question,
-          attempts: [{
-            tools: [{
-              executionId: info.id,
-              id: info.data?.tool_id ?? '',
-              name: tool?.name ?? '',
-              goal: tool?.goal,
-              ...tool,
+        if (info.type === 'planning' && info.action === 'awaiting_approval') {
+          data.steps.push({
+            id: 'planning',
+            type: 'planning',
+            status: 'awaiting_approval',
+            user_question: info.data?.user_question,
+            duration: info.duration || 0,
+            steps: info.data?.steps?.map(s => s.goal) ?? [],
+            goal: info.data?.plan_goal ?? '',
+          })
+          info.data?.steps.forEach(s => data.steps?.push({
+            id: s.id,
+            type: 'step',
+            status: 'pending',
+            input: s.goal,
+            attempts: [{
+              tools: s.tools?.map(t => ({
+                ...(tools.find(({ id }) => id === t.tool_id) ?? { id: t.tool_id, name: t.tool_id }),
+                executionId: t.tool_execution_id,
+                goal: t.goal,
+              })),
             }],
-          }],
-        })
-        data.steps.push({ id: 'answer', type: 'answer', status: 'pending' })
-      }
+          }))
+          data.steps.push({ id: 'answer', type: 'answer', status: 'pending' })
+        }
+
+        if (info.type === 'step' && info.action === 'start') {
+          const step = data.steps.find(s => s.id === info.id)
+          if (step) step.status = 'running'
+        }
 
-      if (info.type === 'tool' && info.action === 'start') {
-        const currentStep = data.steps.find(s => s.status === 'running') as StepChatStep
-        if (!info.data) return
+        if (info.type === 'step' && info.action === 'end') {
+          const step = data.steps.find(s => s.id === info.id) as StepChatStep
+          if (step) {
+            step.status = 'success'
+            step.duration = info.duration
+            const lastToolId = last(step.attempts[0].tools)?.id
+            const lastAttemptOfLastTool = findLast(step.attempts.map(a => a.tools).flat(), t => t?.id === lastToolId)
+            step.output = lastAttemptOfLastTool?.output
+          }
+        }
 
-        //There might be a tool with status awaiting_approval, so we want to inform tool has already started
-        if (!currentStep || !currentStep.attempts[0].tools) {
-          const input = formatJson(info.data.input)
-          const tool = tools.find(({ id }) => id === info.data?.tool_id) ?? { id: info.data?.tool_id, name: info.data?.tool_id }
+        if (info.type === 'tool' && info.action === 'awaiting_approval') {
+          const tool = tools.find(({ id }) => id === info.data?.tool_id)
           data.steps.push({
             id: info.id,
             type: 'tool',
-            status: 'running',
+            status: 'awaiting_approval',
             duration: info.duration || 0,
             input: info.data?.input,
             user_question: info.data?.user_question,
             attempts: [{
-              tools: [{ ...tool, executionId: info.id, input }],
+              tools: [{
+                executionId: info.id,
+                id: info.data?.tool_id ?? '',
+                name: tool?.name ?? '',
+                goal: tool?.goal,
+                ...tool,
+              }],
             }],
           })
-        } else {
-          const toolInFirstAttempt = currentStep.attempts[0].tools?.find(t => t.executionId === info.id)
-          //One step might have multiple tools. When in an approval mode, we might not have all the tools in the array yet.
-          //So we make sure to add any tools that are not in there.
-          if (!toolInFirstAttempt) {
+          data.steps.push({ id: 'answer', type: 'answer', status: 'pending' })
+        }
+
+        if (info.type === 'tool' && info.action === 'start') {
+          const currentStep = data.steps.find(s => s.status === 'running') as StepChatStep
+          if (!info.data) return
+
+          //There might be a tool with status awaiting_approval, so we want to inform tool has already started
+          if (!currentStep || !currentStep.attempts[0].tools) {
             const input = formatJson(info.data.input)
-            const tool = tools?.find(({ id }) => id === info.data?.tool_id) ?? { id: info.data?.tool_id, name: info.data?.tool_id }
-            currentStep.attempts[info.data.attempt - 1].tools?.push({
-              ...tool,
-              executionId: info.id,
-              input,
+            const tool = tools.find(({ id }) => id === info.data?.tool_id) ?? { id: info.data?.tool_id, name: info.data?.tool_id }
+            data.steps.push({
+              id: info.id,
+              type: 'tool',
+              status: 'running',
+              duration: info.duration || 0,
+              input: info.data?.input,
+              user_question: info.data?.user_question,
+              attempts: [{
+                tools: [{ ...tool, executionId: info.id, input }],
+              }],
             })
           } else {
-            const input = formatJson(info.data.input)
-            if (info.data.attempt === 1) {
-              toolInFirstAttempt.input = input
-            } else {
-              const tool = tools.find(({ id }) => id === info.data?.tool_id) ?? { id: info.data?.tool_id, name: info.data?.tool_id }
-              currentStep.attempts[info.data.attempt - 1] ??= { tools: [] }
+            const toolInFirstAttempt = currentStep.attempts[0].tools?.find(t => t.executionId === info.id)
+            //One step might have multiple tools. When in an approval mode, we might not have all the tools in the array yet.
+            //So we make sure to add any tools that are not in there.
+            if (!toolInFirstAttempt) {
+              const input = formatJson(info.data.input)
+              const tool = tools?.find(({ id }) => id === info.data?.tool_id) ?? { id: info.data?.tool_id, name: info.data?.tool_id }
               currentStep.attempts[info.data.attempt - 1].tools?.push({
                 ...tool,
                 executionId: info.id,
                 input,
               })
+            } else {
+              const input = formatJson(info.data.input)
+              if (info.data.attempt === 1) {
+                toolInFirstAttempt.input = input
+              } else {
+                const tool = tools.find(({ id }) => id === info.data?.tool_id) ?? { id: info.data?.tool_id, name: info.data?.tool_id }
+                currentStep.attempts[info.data.attempt - 1] ??= { tools: [] }
+                currentStep.attempts[info.data.attempt - 1].tools?.push({
+                  ...tool,
+                  executionId: info.id,
+                  input,
+                })
+              }
             }
           }
         }
-      }
 
-      if (info.type === 'tool' && info.action === 'end') {
-        const currentStep = data.steps.find(s => s.status === 'running') as StepChatStep
-        if (!currentStep || !info.data) return
-        const tool = currentStep.attempts[info.data.attempt - 1]?.tools?.find(t => t.executionId === info.id)
-        if (tool) {
-          tool.output = formatJson(info.data.output)
-          tool.duration = info.duration
+        if (info.type === 'tool' && info.action === 'end') {
+          const currentStep = data.steps.find(s => s.status === 'running') as StepChatStep
+          if (!currentStep || !info.data) return
+          const tool = currentStep.attempts[info.data.attempt - 1]?.tools?.find(t => t.executionId === info.id)
+          if (tool) {
+            tool.output = formatJson(info.data.output)
+            tool.duration = info.duration
+          }
         }
-      }
 
-      if (info.type === 'final_answer' && info.action === 'start') {
-        const answerStep = last(data.steps)
-        if (answerStep) answerStep.status = 'running'
-      }
+        if (info.type === 'final_answer' && info.action === 'start') {
+          const answerStep = last(data.steps)
+          if (answerStep) answerStep.status = 'running'
+        }
 
-      if (info.type === 'chat' && info.action === 'end') {
-        const answerStep = last(data.steps)
-        if (answerStep) {
-          answerStep.status = 'success'
-          answerStep.duration = info.duration
+        if (info.type === 'chat' && info.action === 'end') {
+          const answerStep = last(data.steps)
+          if (answerStep) {
+            answerStep.status = 'success'
+            answerStep.duration = info.duration
+          }
         }
       }
     }

package/src/client/gen-ai-inference.ts

@@ -1,5 +1,6 @@
 
 import { HttpError } from '@oazapfts/runtime'
+import { findLast, last } from 'lodash'
 import { getApiAddresses } from '../api-addresses'
 import { addSelfHostedModelV1LlmModelsPost, agentChatV1AgentAgentIdChatPost, defaults, deleteModelResourcesV1LlmResourcesResourceIdDelete, deleteV1LlmModelsModelIdDelete, getModelV1LlmModelsModelIdGet, listLlmProvidersV1LlmProvidersGet, listModelsV1LlmModelsGet, saveOrUpdateModelResourcesV1LlmModelsModelIdResourcesPut, toggleModelStatusV1LlmModelsModelIdPatch, updateV1LlmModelsModelIdPut } from '../api/genAiInference'
 import { DefaultAPIError } from '../error/DefaultAPIError'
@@ -7,6 +8,10 @@ import { inferenceDictionary } from '../error/dictionary/ai-inference'
 import { StackspotAPIError } from '../error/StackspotAPIError'
 import { ReactQueryNetworkClient } from '../network/ReactQueryNetworkClient'
 import { removeAuthorizationParam } from '../utils/remove-authorization-param'
+import { StreamedJson } from '../utils/StreamedJson'
+import { formatJson } from '../utils/string'
+import { agentToolsClient } from './agent-tools'
+import { AgentInfo, ChatAgentTool, ChatResponseWithSteps, FixedChatRequest, FixedChatResponse, StepChatStep } from './types'
 
 class GenAiInference extends ReactQueryNetworkClient {
   constructor() {
@@ -60,6 +65,282 @@ class GenAiInference extends ReactQueryNetworkClient {
    * Interaction with a specific AI agent
    */
   sendAgentMessage = this.mutation(removeAuthorizationParam(agentChatV1AgentAgentIdChatPost))
+
+
+  private static async toolsOfAgent(agentId?: string) {
+    try {
+      const agent = agentId ? await agentToolsClient.agent.query({ agentId }) : undefined
+      if (!agent) return []
+      const tools: (Omit<ChatAgentTool, 'duration' | 'prompt' | 'output'>)[] = []
+      agent.toolkits?.builtin_toolkits?.forEach(kit => kit.tools?.forEach(({ id, name, description }) => {
+        if (id) tools.push({ image: kit.image_url, id, name: name || id, description })
+      }))
+      agent.toolkits?.custom_toolkits?.forEach(kit => kit.tools?.forEach(({ id, name, description }) => {
+        if (id) tools.push({ image: kit.avatar ?? undefined, id, name: name || id, description })
+      }))
+      return tools
+    } catch {
+      return []
+    }
+  }
+
+  sendChatMessage(request: FixedChatRequest, minChangeIntervalMS?: number): StreamedJson<ChatResponseWithSteps> {
+    const abortController = new AbortController()
+    const { context, ...body } = request ?? {}
+    const headers = {
+      'Content-Type': 'application/json',
+      'Accept': 'text/event-stream',
+      'x-platform': context?.platform ?? '',
+      'x-os': context?.os ?? '',
+      'x-platform-version': context?.platform_version ?? '',
+      'x-stackspot-ai-version': context?.stackspot_ai_version ?? '',
+      'x-request-origin': 'chat',
+    }
+    const events = this.stream(
+      this.resolveURL(`/v1/agent/${context?.agent_id}/chat`),
+      { method: 'post', body: JSON.stringify(body), headers, signal: abortController.signal },
+    )
+
+    const DYNAMIC_TOOL_ID = 'dynamic'
+    function isDynamicTool(info: AgentInfo) {
+      return info.type === 'tool' && info.id === DYNAMIC_TOOL_ID
+    }
+    /**
+     * This function treats events in the streaming that deals with the execution of tools. Since these events are not concatenated like
+     * normal streamings of data, we need this separate function to deal with them. It transforms the internal data model of the
+     * StreamedJson object whenever an event is triggered.
+     */
+    async function transform(event: Partial<FixedChatResponse>, data: Partial<ChatResponseWithSteps>) {
+      // The API send a final snapshot containing the full `agent_info`.
+      // When `stop_reason === 'stop'` we can ignore it to avoid duplicating steps.
+      if (event?.stop_reason === 'stop') return
+
+      const infoList = event.agent_info ?? []
+      if (infoList.length === 0) return
+
+      const tools = await GenAiInference.toolsOfAgent(request.context?.agent_id)
+      data.steps = data.steps ? [...data.steps] : []
+
+      for (const info of infoList) {
+
+        if (info.type === 'planning' && info.action === 'end') {
+          data.steps.push({
+            id: 'planning',
+            type: 'planning',
+            status: 'success',
+            duration: info.duration || 0,
+            steps: info.data?.steps?.map(s => s.goal) ?? [],
+            goal: info.data?.plan_goal ?? '',
+          })
+
+          info.data?.steps.forEach(s => data.steps?.push({
+            id: s.id,
+            type: 'step',
+            status: 'pending',
+            input: s.goal,
+            attempts: [{
+              tools: s.tools?.map(t => ({
+                ...(tools.find(({ id }) => id === t.tool_id) ?? { id: t.tool_id, name: t.tool_id }),
+                executionId: t.tool_execution_id,
+                goal: t.goal,
+              })),
+            }],
+          }))
+          data.steps.push({ id: 'answer', type: 'answer', status: 'pending' })
+        }
+
+        if (info.type === 'planning' && info.action === 'awaiting_approval') {
+          data.steps.push({
+            id: 'planning',
+            type: 'planning',
+            status: 'awaiting_approval',
+            user_question: info.data?.user_question,
+            duration: info.duration || 0,
+            steps: info.data?.steps?.map(s => s.goal) ?? [],
+            goal: info.data?.plan_goal ?? '',
+          })
+          info.data?.steps.forEach(s => data.steps?.push({
+            id: s.id,
+            type: 'step',
+            status: 'pending',
+            input: s.goal,
+            attempts: [{
+              tools: s.tools?.map(t => ({
+                ...(tools.find(({ id }) => id === t.tool_id) ?? { id: t.tool_id, name: t.tool_id }),
+                executionId: t.tool_execution_id,
+                goal: t.goal,
+              })),
+            }],
+          }))
+          data.steps.push({ id: 'answer', type: 'answer', status: 'pending' })
+        }
+
+        if (info.type === 'step' && info.action === 'start') {
+          const step = data.steps.find(s => s.id === info.id)
+          if (step) step.status = 'running'
+        }
+
+        if (info.type === 'step' && info.action === 'end') {
+          const step = data.steps.find(s => s.id === info.id) as StepChatStep
+          if (step) {
+            step.status = 'success'
+            step.duration = info.duration
+            const lastToolId = last(step.attempts[0].tools)?.id
+            const lastAttemptOfLastTool = findLast(step.attempts.map(a => a.tools).flat(), t => t?.id === lastToolId)
+            step.output = lastAttemptOfLastTool?.output
+          }
+        }
+
+        if (info.type === 'tool_calls' && info.action === 'start') {
+          const hasPlanning = data.steps.find(s => s.type === 'planning')
+          // On the first tool_calls:start, create the synthetic planning ("dynamic") step.
+          if (!hasPlanning) {
+            const userPrompt = request.user_prompt === 'string' ? request.user_prompt : JSON.stringify(request.user_prompt)
+            data.steps.push({
+              id: 'dynamic',
+              type: 'planning',
+              status: 'success',
+              steps: [],
+              goal: userPrompt,
+              user_question: userPrompt,
+            })
+          }
+          const toolsStepId = data.steps.filter(s => s.id === 'tools' || s.id.startsWith('tools-')).length + 1
+          data.steps.push({
+            id: `tools-${toolsStepId.toString()}`,
+            type: 'step',
+            status: 'running',
+            attempts: [{ tools: [] }],
+          } as StepChatStep)
+        }
+
+        if (info.type === 'tool_calls' && info.action === 'end') {
+          const lastStep = findLast(data.steps, s => s.id === 'tools' || s.id.startsWith('tools-')) as StepChatStep
+          if (lastStep) {
+            lastStep.status = 'success'
+            lastStep.duration = info.duration
+            const lastAttemptOfLastTool = last(lastStep.attempts.map(a => a.tools).flat())
+            lastStep.output = lastAttemptOfLastTool?.output
+          }
+        }
+
+        if (info.type === 'tool' && info.action === 'awaiting_approval') {
+          const tool = tools.find(({ id }) => id === info.data?.tool_id)
+          data.steps.push({
+            id: info.id,
+            type: 'tool',
+            status: 'awaiting_approval',
+            duration: info.duration || 0,
+            input: info.data?.input,
+            user_question: info.data?.user_question,
+            attempts: [{
+              tools: [{
+                executionId: info.id,
+                id: info.data?.tool_id ?? '',
+                name: tool?.name ?? '',
+                goal: tool?.goal,
+                ...tool,
+              }],
+            }],
+          })
+          data.steps.push({ id: 'answer', type: 'answer', status: 'pending' })
+        }
+
+        if (info.type === 'tool' && info.action === 'start') {
+          if (!info.data) return
+          const input = formatJson(info.data.input)
+          const tool = findLast(tools, ({ id }) => id === info.data?.tool_id) ?? { id: info.data?.tool_id, name: info.data?.tool_id }
+
+          const currentStep = findLast(data.steps, s => s.status === 'running') as StepChatStep
+
+          //There might be a tool with status awaiting_approval, so we want to inform tool has already started
+          if (!currentStep || !currentStep?.attempts?.[0]?.tools) {
+            data.steps.push({
+              id: info.id,
+              type: 'tool',
+              status: 'running',
+              duration: info.duration || 0,
+              input: info.data?.input,
+              user_question: info.data?.user_question,
+              attempts: [{
+                tools: [{ ...tool, executionId: info.id, input }],
+              }],
+            })
+          } else {
+            const toolInFirstAttempt = findLast(currentStep?.attempts?.[0]?.tools, t => t.executionId === info.id)
+            //One step might have multiple tools. When in an approval mode, we might not have all the tools in the array yet.
+            //For dynamic tools (id === 'dynamic'), we always push a new tool, since dynamic executions can trigger
+            //multiple tool runs in the same step and do not follow the planned tool structure.
+            //So we make sure to add any tools that are not in there, or always add for dynamic tools.
+            if (!toolInFirstAttempt || isDynamicTool(info)) {
+              currentStep.attempts?.[0].tools?.push({
+                ...tool,
+                executionId: info.id,
+                input,
+                status: 'running',
+              })
+            } else {
+              const input = formatJson(info.data.input)
+              if (info.data.attempt === 1) {
+                toolInFirstAttempt.input = input
+              } else {
+                currentStep.attempts[info.data.attempt - 1] ??= { tools: [] }
+                currentStep.attempts[info.data.attempt - 1].tools?.push({
+                  ...tool,
+                  executionId: info.id,
+                  input,
+                })
+              }
+            }
+          }
+        }
+
+        if (info.type === 'tool' && info.action === 'end') {
+          const currentStep = data.steps.find(s => s.status === 'running') as StepChatStep
+          if (!currentStep || !info.data) return
+
+          // attempt index for tool execution starts at 0 for dynamically executed tools,while for planned tools it starts at 1
+          const attempt = isDynamicTool(info) ? info.data.attempt : info.data.attempt - 1
+          const tool = last(currentStep?.attempts?.[attempt]?.tools)
+          if (tool) {
+            tool.output = formatJson(info.data.output)
+            tool.duration = info.duration
+            tool.status = 'success'
+          }
+        }
+
+        if (info.type === 'final_answer' && info.action === 'start') {
+          const answerStep = last(data.steps)
+          if (answerStep) answerStep.status = 'running'
+        }
+
+
+        if (info.type === 'chat' && info.action === 'end') {
+          const lastStep = last(data.steps)
+          if (lastStep?.type === 'answer') {
+            lastStep.status = 'success'
+            lastStep.duration = info.duration
+          } else {
+            data.steps.push({ id: 'answer', type: 'answer', status: 'success' })
+          }
+        }
+      }
+    }
+
+    return new StreamedJson({
+      eventsPromise: events,
+      abortController,
+      ignoreKeys: ['agent_info'],
+      transform,
+      textFromErrorEvent: data => data.message ?? 'Unknown error',
+      minChangeIntervalMS,
+      minChangeIntervalMSFromEvent: (event) => {
+        if (event?.agent_info?.length) return 0
+        return minChangeIntervalMS
+      },
+    })
+  }
+
 }
 
 export const genAiInferenceClient = new GenAiInference()