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

package/src/client/ai.ts

@@ -1,5 +1,5 @@
 import { HttpError } from '@oazapfts/runtime'
-import { findLast, isArray, isNil, last } from 'lodash'
+import { isArray } from 'lodash'
 import { getApiAddresses } from '../api-addresses'
 import {
   addFavoriteV1AiStacksStackIdFavoritePost,
@@ -46,13 +46,9 @@ import {
   postEventV1EventsPost,
   publishV1QuickCommandsSlugPublishPost,
   quickActionsV1QuickActionsPost,
-  QuickCommandPromptResponse,
   QuickCommandPromptResponse2,
-  QuickCommandScriptExecutionResponse,
   QuickCommandsExecutionRequest,
   quickCommandsRunV2V2QuickCommandsSlugStepsStepSlugRunPost,
-  QuickCommandStepFetchResponse,
-  QuickCommandStepLlmResponse,
   resetKnowledgeObjectsV1KnowledgeSourcesSlugObjectsDelete,
   runFetchStepV1QuickCommandsSlugStepsStepSlugFetchRunPost,
   searchKnowledgeSourcesV1KnowledgeSourcesSearchPost,
@@ -71,21 +67,10 @@ import { StackspotAPIError } from '../error/StackspotAPIError'
 import { ReactQueryNetworkClient } from '../network/ReactQueryNetworkClient'
 import { removeAuthorizationParam } from '../utils/remove-authorization-param'
 import { StreamedJson } from '../utils/StreamedJson'
-import { formatJson, getSizeOfString } from '../utils/string'
-import { agentToolsClient } from './agent-tools'
 import {
-  AgentInfo,
-  ChatAgentTool,
-  ChatResponseWithSteps,
-  FixedChatRequest,
-  FixedChatResponse,
   FixedConversationResponse,
   FixedDependencyResponse,
-  QCContext,
-  QCContextExecution,
-  QCProgressProps,
   ReplaceResult,
-  StepChatStep,
 } from './types'
 
 const listQAV3WithoutAuthorization = removeAuthorizationParam(listAllV3QuickCommandsGet)
@@ -381,616 +366,6 @@ class AIClient extends ReactQueryNetworkClient {
   deleteReviewComment = this.mutation(
     removeAuthorizationParam(deleteReviewCommentV1ResourcesResourceTypeSlugResourceSlugReviewsReviewIdAnswersAnswerIdDelete))
 
-  private static async toolsOfAgent(agentId?: string, agent_version_number?: number) {
-    try {
-      const agent = agentId ? await agentToolsClient.agentV2.query({ 
-        agentCoreId: agentId, versionNumber: agent_version_number }) : undefined
-      if (!agent) return []
-      const tools: (Omit<ChatAgentTool, 'duration' | 'prompt' | 'output'>)[] = []
-      agent.version?.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.version?.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 []
-    }
-  }
-
-  /**
-   * Runs an Router step of a quick command.
-   */
-  async runRouterStep(
-    ctx: QCContextExecution,
-    stepIndex: number, iteration: Record<string, number>,
-    progress?:QCProgressProps,
-  ) {
-    const { qc: { slug, steps }, code, resultMap, customInputs } = ctx
-    const step = steps![stepIndex]
-    const inputData = Object.keys(customInputs).length > 0 && code ? { ...customInputs, [code]: code } : code ?? customInputs
-    try {
-      progress?.onStepChange?.({ step: step.slug, ...resultMap, ...{ statusResult: 'START' } })
-      if (step.slug in iteration) {
-        iteration[step.slug] = iteration[step.slug] + 1
-      } else {
-        iteration[step.slug] = 1
-      }
-
-      const { next_step_slug } = await aiClient.calculateNextStep.mutate({
-        stepSlug: step.slug,
-        slug: slug,
-        quickCommandEvaluateStepRouterRequest: {
-          executions_count: iteration[step.slug],
-          input_data: inputData,
-          slugs_executions: resultMap,
-        },
-      })
-      
-      progress?.onStepChange?.({ step: step.slug, ...resultMap, ...{ statusResult: 'END' } })
-
-      if (next_step_slug === step.slug) {
-        return aiClient.runStepsRecursively(stepIndex, ctx, iteration, progress)
-      }
-      const nextStepIndex = steps?.findIndex((step) => step.slug === next_step_slug)
-
-      if (isNil(nextStepIndex) || nextStepIndex === -1) return
-
-      return aiClient.runStepsRecursively(nextStepIndex, ctx, iteration, progress)
-    }
-    catch (error: any) {
-      progress?.onStepChange?.({ 
-        step: step.slug, error: error, answer: JSON.stringify(error.message), statusResult: 'ERROR', ...resultMap, 
-      })
-      // eslint-disable-next-line no-console
-      console.error('Error executing QC step', error)
-    }
-  }
-  
-  async getScriptStepStatus(
-    scriptExecutionId: string,
-    interval = 5000,
-    maxAttempts = 500,
-    currentAttempt = 0,
-  ): Promise<QuickCommandScriptExecutionResponse> {
-    if (currentAttempt >= maxAttempts) {
-      throw new Error('Max attempts reached in verify script status')
-    }
-    await aiClient.getStatusScriptStep.invalidate({ scriptExecutionId })
-    const response = await aiClient.getStatusScriptStep.query({ scriptExecutionId })
-    
-    if (response.status === 'success') {
-      return response
-    }
-
-    if (response.status === 'failure') {
-      throw response
-    }
-
-    await new Promise(resolve => {setTimeout(resolve, interval)})
-
-    return aiClient.getScriptStepStatus(scriptExecutionId, interval, maxAttempts, currentAttempt + 1)
-  }
-  /**
-   * Runs a fetch step of a quick command and puts the result in the `resultMap` of the context passed as parameter.
-   */
-  async runFetchStep(ctx: QCContextExecution, stepIndex: number, progress?: QCProgressProps) {
-    const { qc: { slug, steps }, code, context, resultMap, customInputs, executionId, signal } = ctx
-    const step = steps![stepIndex] as QuickCommandStepFetchResponse
-    progress?.onStepChange?.({ step: step.slug, ...resultMap, answer: undefined, statusResult: 'START' })
-    
-    //If is_remote we call backend to execute for us and we only have the response
-    if (step.is_remote) {
-      ctx.isRemote = true
-      try {
-        const { data } = await aiClient.fetchStepOfQuickCommandRemotely.mutate({
-          slug, stepSlug: step.slug,
-          quickCommandsExecutionRequest: {
-            code_selection: code, context, qc_execution_id: executionId,
-            slugs_executions: { ...resultMap, ...customInputs },
-          },
-        }, signal)
-
-        //data is the return of the request in the QC so we do not have full control over the response
-        //We handle the usual format with body, status_code and headers, but we might also handle other formats
-        const responseData = data as any
-        progress?.onStepChange?.({ 
-          step: step.slug, ...resultMap, answer: JSON.stringify(responseData.body) ?? JSON.stringify(responseData), statusResult: 'END' })
-        resultMap[step.slug] = {
-          status: responseData.status_code || 200,
-          data: JSON.stringify(responseData.body) ?? JSON.stringify(responseData),
-          headers: responseData.headers ?? {},
-        }
-        return
-      } catch (error) {
-        const errorMessage = `${error}, Failed to execute step "${step.slug}" of quick command "${slug}".`
-        progress?.onStepChange?.({ step: step.slug, ...resultMap, answer: errorMessage, error: errorMessage, statusResult: 'ERROR' })
-        throw new Error(errorMessage)
-      }
-    }
-    
-    const { headers, data, method, url } = await aiClient.fetchStepOfQuickCommand.mutate({
-      slug,
-      stepSlug: step.slug,
-      quickCommandsExecutionRequest: {
-        input_data: code, context, qc_execution_id: executionId,
-        slugs_executions: { ...resultMap, ...customInputs },
-      },
-    }, signal)
-    const body = ['get', 'head'].includes(method.toLowerCase()) ? undefined : data
-    
-    try {
-    //Local execution
-      const response = await fetch(url, { headers: headers || undefined, body, method, signal })
-      const responseData = await response.text()
-      if (!response.ok) throw new Error(`Failed to execute step "${step.slug}" of quick command "${slug}". Status ${response.status}.`)
-      progress?.onStepChange?.({ step: step.slug, ...resultMap, answer: responseData, statusResult: 'END' })
-
-      resultMap[step.slug] = {
-        status: response.status,
-        data: responseData,
-        headers: Object.fromEntries(response.headers.entries()),
-      }
-    }
-    catch (error) {
-      const errorMessage = `${error}, Failed to execute step "${step.slug}" of quick command "${slug}".`
-      progress?.onStepChange?.({ step: step.slug, ...resultMap, answer: errorMessage, error: errorMessage, statusResult: 'ERROR' })
-      throw new Error(errorMessage)
-    }
-  }
-
-  /**
-   * Runs an LLM step of a quick command and puts the result in the `resultMap` of the context passed as parameter.
-   */
-  async runLLMStep(
-    { qc: { slug, steps }, code, customInputs, context, executionId, resultMap, signal }: QCContextExecution,
-    stepIndex: number,
-    progress?: QCProgressProps,
-  ) {
-    const step = steps![stepIndex] as QuickCommandStepLlmResponse
-    let stepContext = context
-    if (!step.use_uploaded_files) {
-      const { upload_ids: _upload_ids, ...contextDataProps } = context
-      stepContext = { ...contextDataProps }
-    }
-    // eslint-disable-next-line no-async-promise-executor
-    return new Promise(async (resolve) => {
-      progress?.onStepChange?.({  step: step.slug, ...resultMap, answer: undefined, statusResult: 'START' })
-    
-      const stream = aiClient.streamLlmStepOfQuickCommand(
-        slug,
-        step.slug,
-        {
-          input_data: code,
-          context: stepContext,
-          qc_execution_id: executionId,
-          slugs_executions: { ...resultMap, ...customInputs },
-        },
-      )
-
-      signal.addEventListener('abort', () => stream.cancel())
-
-      stream.onChange(item => {
-        if (item?.sources?.length) {
-          progress?.onStepChange?.({  step: step.slug, ...resultMap, sources: JSON.stringify(item.sources) })
-        } else {
-          item.answer !== undefined && progress?.onStepChange?.({  step: step.slug, ...resultMap, answer: item.answer })
-        }
-      })
-    
-      try {
-        const finalValue = await stream.getValue()
-        resultMap[step.slug] = finalValue
-        progress?.onStepChange?.({ step: step.slug, ...resultMap, answer: finalValue.answer,
-          sources: finalValue.sources ? JSON.stringify(finalValue.sources) : '', statusResult: 'END' })
-        resolve(finalValue)
-      } catch (error: any) {
-      // eslint-disable-next-line no-console
-        console.error('Error executing QC step', error)
-        const errorStep = `Failed to execute step "${step.slug}" of quick command "${slug}". Reason: ${error.message}`
-        progress?.onStepChange?.({ step: step.slug, ...resultMap, answer: errorStep, error: errorStep, statusResult: 'ERROR' })
-        throw error
-      }
-    })
-  }
-
-  async runScriptStep(
-    { qc: { slug, steps }, code, context, resultMap, customInputs, signal }: QCContextExecution,
-    stepIndex: number,
-    progress?: QCProgressProps,
-  ) {
-    const step = steps![stepIndex] as QuickCommandStepLlmResponse
-    let stepContext = context
-    progress?.onStepChange?.({ step: step.slug, ...resultMap, ...{ statusResult: 'START' } })
-
-    if (!step.use_uploaded_files) {
-      const { upload_ids: _upload_ids, ...contextDataProps } = context
-      stepContext = { ...contextDataProps }
-    }
-
-    try {
-      const { script_execution_id } = await aiClient.startScriptStep.mutate({
-        stepSlug: step.slug,
-        slug: slug,
-        quickCommandStartScriptRequest: {
-          input_data: code,
-          custom_inputs: customInputs,
-          context: stepContext,
-          slugs_executions: resultMap,
-        },
-      }, signal)
-      const scriptResult = await aiClient.getScriptStepStatus(script_execution_id)
-      progress?.onStepChange?.({ step: step.slug, ...scriptResult, ...{ statusResult: 'END' } })
-      resultMap[step.slug] = scriptResult
-    }
-    catch (error: any) {
-      progress?.onStepChange?.({ step: step.slug, ...error, statusResult: 'ERROR', ...resultMap })
-      let message = error.result?.error ?? error.message ?? `${error}`
-      if (error instanceof StackspotAPIError) message = error.translate()
-      throw new Error(`Failed to execute step "${step.slug}" of quick command "${slug}". Error ${message}.`)
-    }
-  }
-
-  async runStepsRecursively(currentIndex: number, ctx: QCContextExecution, iteration: Record<string, number>,  
-    progress?: QCProgressProps) {
-    const { qc, resultMap } = ctx
-
-    if (!qc.steps || currentIndex >= qc.steps?.length) return
-    progress?.update?.(currentIndex)
-    
-    const currentStep = qc.steps[currentIndex]
-    
-    if (currentStep.type === 'ROUTER') {
-      await aiClient.runRouterStep(ctx, currentIndex, iteration, progress)
-      return
-    }
-
-    const parsedStep = currentStep as QuickCommandStepFetchResponse | QuickCommandStepLlmResponse
-    let nextIndex = currentIndex + 1
-    let nextStepSlug = parsedStep.next_step_slug
-    
-    if (currentStep.type === 'SCRIPT') {
-      await aiClient.runScriptStep(ctx, currentIndex, progress)
-    } else if (currentStep.type === 'FETCH') {
-      await aiClient.runFetchStep(ctx, currentIndex, progress) 
-    } else {
-      try {
-        await aiClient.runLLMStep(ctx, currentIndex, progress)
-      } catch (error: any) {
-        progress?.onStepChange?.({ step: currentStep.slug, 
-          error: error, answer: JSON.stringify(error), statusResult: 'ERROR', ...resultMap })
-      }
-      const stepResult = resultMap[currentStep.slug] as QuickCommandPromptResponse
-
-      //When we have an error but there is an error path defined
-      if (typeof stepResult !== 'string' && stepResult.answer_status?.next_step_slug) {
-        nextStepSlug = stepResult?.answer_status?.next_step_slug
-      } else if (!stepResult?.answer_status?.success) { //When we have an error but no error path defined we should fail the execution
-        progress?.onStepChange?.({ 
-          step: currentStep.slug, error: stepResult?.answer_status, 
-          answer: JSON.stringify(stepResult?.answer_status?.failure_message), statusResult: 'ERROR', ...resultMap })
-        throw new Error()
-      }
-    }
-    
-    const stepResult = ctx.resultMap[currentStep.slug]
-    if (stepResult && typeof stepResult !== 'string' && 'answer_status' in stepResult && !!stepResult.answer_status?.next_step_slug) {
-      nextStepSlug = stepResult.answer_status.next_step_slug
-    }
-
-    if (nextStepSlug) {
-      nextIndex = nextStepSlug === 'end' ?
-        qc.steps.length : qc.steps?.findIndex((step) => step.slug === nextStepSlug)
-    }
-    await aiClient.runStepsRecursively(nextIndex, ctx, iteration, progress)
-  }
-  
-  async formatResult({ qc, code, executionId, context, resultMap, customInputs, signal }: QCContextExecution) {
-    const formatted = await aiClient.formatResultOfQuickCommand.mutate({
-      slug: qc.slug,
-      quickCommandsExecutionRequest: {
-        input_data: code,
-        context,
-        qc_execution_id: executionId,
-        slugs_executions: { ...resultMap, ...customInputs },
-      },
-    
-    }, signal)
-    return formatted.result
-  }
-
-  /**
-   * This registers a quick command event in the backend (analytics).
-   */
-  private async registerQCAnalyticsEvent({ 
-    qc, isRemote, executionId, code = '', context }: QCContextExecution, status: string, start: number) {
-    const now = new Date().getTime()
-    try {
-      await aiClient.createEvent.mutate({
-        body: [{
-          type: 'custom_quick_command_execution',
-          quick_command_event: {
-            type: qc.type || '',
-            duration_execution: now - start,
-            status_execution: status,
-            slug: qc.slug,
-            qc_execution_id: executionId,
-            id: qc.id,
-            is_remote: isRemote,
-          },
-          code,
-          context,
-          knowledge_sources: [],
-          size: getSizeOfString(code),
-          generated_at: now,
-        }],
-      })
-    } catch (error) {
-      // eslint-disable-next-line no-console
-      console.warn('Failed to register event: quick command.')
-    }
-  }
-  
-  async runQuickCommand(ctx: QCContext, progress?: QCProgressProps) {
-    const start = new Date().getTime()
-
-    const { slug } = ctx
-    const qc = await aiClient.quickCommand.query({ slug })
-    const ctxExecution: QCContextExecution = { ...ctx, qc }
-    try {
-      await aiClient.runStepsRecursively(0, ctxExecution, {}, progress)
-      progress?.remove?.()
-      const result = await aiClient.formatResult(ctxExecution)
-      await aiClient.registerQCAnalyticsEvent(ctxExecution, '200', start)
-      return result
-    } catch (error: any) {
-      let message = error.message || `${error}`
-      if (error instanceof StackspotAPIError) message = error.translate()
-      await aiClient.registerQCAnalyticsEvent(ctxExecution, message, start)
-      throw error
-    }
-  }
-  
-  sendChatMessage(request: FixedChatRequest, minChangeIntervalMS?: number): StreamedJson<ChatResponseWithSteps> {
-    const abortController = new AbortController()
-    const headers = {
-      'Content-Type': 'application/json',
-      'Accept': 'text/event-stream',
-    }
-    const events = this.stream(
-      this.resolveURL('v3/chat'),
-      { method: 'post', body: JSON.stringify(request), 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>) {
-      const info = event.agent_info
-      if (!info) return
-      const tools = await AIClient.toolsOfAgent(request.context?.agent_id, request.agent_version_number ?? undefined)
-      data.steps = data.steps ? [...data.steps] : []
-    
-      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,
-      minChangeIntervalMS,
-      ignoreKeys: ['agent_info'],
-      transform,
-      textFromErrorEvent: data => data.answer ?? 'Unknown error',
-    })
-  }
-
   contentDependencies = this.query(removeAuthorizationParam(
     getContentDependenciesV1ContentContentTypeContentIdDependenciesGet as ReplaceResult<
       typeof getContentDependenciesV1ContentContentTypeContentIdDependenciesGet,

package/src/client/cloud-platform.ts

@@ -36,7 +36,6 @@ import {
   listRuntime,
   listTenant,
   listVpns,
-  providers,
   putCertificateTags,
   putCidrTags,
   putDnsZoneTags,
@@ -72,10 +71,6 @@ class CloudPlatformClient extends ReactQueryNetworkClient {
    * Get list of foundations folders or folder by id
    */
   getFolder = this.query(removeAuthorizationParam(getFolder))
-  /**
-   * Get list of providers for a foundation
-   */
-  listProviders = this.query(removeAuthorizationParam(providers))
   /**
    * Create a foundation
    */
@@ -225,12 +220,12 @@ class CloudPlatformClient extends ReactQueryNetworkClient {
   */
   deleteDnsRecord = this.mutation(removeAuthorizationParam(deleteDnsRecord))
   /**
-* Delete a VPN
-*/
+  * Delete a VPN
+  */
   deleteVPN = this.mutation(removeAuthorizationParam(deleteVpn))
   /**
-* Delete a CIDR
-*/
+  * Delete a CIDR
+  */
   deleteCidr = this.mutation(removeAuthorizationParam(deleteCidr))
 }