@stack-spot/portal-network 0.194.1 → 0.195.0-beta.1

package/src/client/discover.ts

@@ -1,12 +1,17 @@
 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, getAll, getAll1, getAll2, getAllByHypothesis, getById, getById1, getById2, GetOpportunityResponse } from '../api/discover'
+import { create, create1, create2, defaults, deleteById, deleteById1, deleteById2, getAll, getAll1, getAll2, getAllByHypothesis, getById, getById1, getById2, GetOpportunityResponse, MessageRequest } from '../api/discover'
 import { DefaultAPIError } from '../error/DefaultAPIError'
 import { StackspotAPIError } from '../error/StackspotAPIError'
+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'
 
 export interface ChatConversionDetails extends ConversationResponse {
   opportunityName?: string,
@@ -67,8 +72,8 @@ class DiscoverClient extends ReactQueryNetworkClient {
         { ...variables, page: variables.page, size: variables.size ?? 40 },
       )
 
-      const filteredItems = variables.filter 
-        ? chatsHistory.filter((chat) => chat.title.toLowerCase().includes(variables.filter!.toLowerCase())) 
+      const filteredItems = variables.filter
+        ? chatsHistory.filter((chat) => chat.title.toLowerCase().includes(variables.filter!.toLowerCase()))
         : chatsHistory
 
       const enrichedChats = filteredItems?.map(chat => {
@@ -84,6 +89,218 @@ class DiscoverClient extends ReactQueryNetworkClient {
       return enrichedChats as ChatConversionDetails[]
     },
   })
+
+  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: MessageRequest & { agentId: string }, minChangeIntervalMS?: number): StreamedJson<ChatResponseWithSteps> {
+    const abortController = new AbortController()
+    const headers = {
+      'Content-Type': 'application/json',
+      'Accept': 'text/event-stream',
+    }
+    const events = this.stream(
+      this.resolveURL('/v2/ai/chat'),
+      { method: 'post', body: JSON.stringify(request), headers, signal: abortController.signal },
+    )
+    /**
+       * 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 DiscoverClient.toolsOfAgent(request.agentId)
+      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' && 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') {
+        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 }
+          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 = 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 === '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
+        }
+      }
+    }
+
+    return new StreamedJson({
+      eventsPromise: events,
+      abortController,
+      minChangeIntervalMS,
+      ignoreKeys: ['agent_info'],
+      transform,
+    })
+  }
 }
 
 export const discoverClient = new DiscoverClient()

package/src/client/types.ts

@@ -361,10 +361,25 @@ export interface FixedChatResponse extends ChatResponse3 {
   agent_info: AgentInfo,
   tools?: string[],
 }
+export interface OpportunitiesPMAgent {
+  title: string,
+  description: string,
+}
+
+export type HypothesisPMAgent = OpportunitiesPMAgent
 
+export type PrfaqPMAgent = {
+  title: string,
+  content: string,
+}
 export interface ChatResponseWithSteps extends FixedChatResponse {
   steps: ChatStep[],
 }
+export interface ChatResponseWithPMResources {
+  opportunities?: OpportunitiesPMAgent[],
+  hypothesis?: HypothesisPMAgent[],
+  prfaq?: PrfaqPMAgent,
+}
 
 export type OazapftsFunction<Variables = any, Result = any> = (variables: Variables, opts?: RequestOpts) => Promise<Result>
 
@@ -380,12 +395,12 @@ export type FixVariables<
 
 export type ReplaceResult<T extends (...args: any[]) => Promise<any>, Fix> = (...args: Parameters<T>) => Promise<Fix>
 
-export interface AgentResponseWithBuiltIn extends Omit<ListAgentResponse, 'conversation_starter' | 'avatar'>   {
+export interface AgentResponseWithBuiltIn extends Omit<ListAgentResponse, 'conversation_starter' | 'avatar'> {
   builtIn?: boolean,
   spaceName?: string,
   conversation_starter?: string[] | null,
   avatar?: string | null | undefined,
-} 
+}
 
 export type AgentVisibilityLevel = AgentVisibilityLevelEnum | VisibilityLevelEnum
 

package/src/error/dictionary/cloud-platform.ts

@@ -39,6 +39,9 @@ export const scfDictionary = {
     SCF_VPN_ERROR: 'VPN operation failed.',
     SCF_VPN_NOT_FOUND_ERROR: 'VPN with ID {1} not found.',
     SCF_VPN_NOT_READY_ERROR: 'VPN with ID {1} not ready.',
+    SCF_DNS_ZONE_NOT_EMPTY_ERROR: 'DNS Zone with ID {1} is not empty.',
+    SCF_FOLDER_NOT_EMPTY_ERROR: 'Folder with ID {1} is not empty.',
+    SCF_PROJECT_NOT_EMPTY_ERROR: 'Project with ID {1} is not empty.',
   },
   pt: {
     SCF_CERTIFICATE_ERROR: 'Falha na operação de Certificado.',
@@ -78,5 +81,8 @@ export const scfDictionary = {
     SCF_VPN_ERROR: 'Falha na operação de VPN.',
     SCF_VPN_NOT_FOUND_ERROR: 'VPN com ID {1} não encontrada.',
     SCF_VPN_NOT_READY_ERROR: 'VPN com ID {1} não está pronta.',
+    SCF_DNS_ZONE_NOT_EMPTY_ERROR: 'DNS Zone com ID {1} não está vazia.',
+    SCF_FOLDER_NOT_EMPTY_ERROR: 'Folder com ID {1} não está vazia.',
+    SCF_PROJECT_NOT_EMPTY_ERROR: 'Project com ID {1} não está vazia.',
   },
 } satisfies Dictionary

package/src/utils/StreamedJson.tsx

@@ -64,7 +64,14 @@ export class StreamedJson<T> {
       for await (const event of events) {
         if (this.error) return
         if (event.data) {
-          const json = JSON.parse(event.data)
+          let json
+          try {
+            json = JSON.parse(event.data)
+          } catch (e) {
+            // eslint-disable-next-line no-console
+            console.warn('Mal formed JSON in streaming:', event.data)
+            continue
+          }
           await this.transform?.(json, this.data)
           this.merge(json, this.data)
           if (new Date().getTime() - lastChangeCall >= minChangeIntervalMS) {
@@ -138,7 +145,7 @@ export class StreamedJson<T> {
   onChange(listener: (value: Partial<T>) => void) {
     if (this.fullPromise.resolved) {
       listener(this.data)
-      return () => {}
+      return () => { }
     }
     this.onChangeListeners.push(listener)
     return () => {