@stack-spot/portal-network 1.0.0-stg.1768944863737 → 1.0.0-stg.1769540429713

package/src/client/ai.ts

@@ -1,5 +1,5 @@
 import { HttpError } from '@oazapfts/runtime'
-import { isArray } from 'lodash'
+import { isArray, isNil } from 'lodash'
 import { getApiAddresses } from '../api-addresses'
 import {
   addFavoriteV1AiStacksStackIdFavoritePost,
@@ -46,9 +46,13 @@ import {
   postEventV1EventsPost,
   publishV1QuickCommandsSlugPublishPost,
   quickActionsV1QuickActionsPost,
+  QuickCommandPromptResponse,
   QuickCommandPromptResponse2,
+  QuickCommandScriptExecutionResponse,
   QuickCommandsExecutionRequest,
   quickCommandsRunV2V2QuickCommandsSlugStepsStepSlugRunPost,
+  QuickCommandStepFetchResponse,
+  QuickCommandStepLlmResponse,
   resetKnowledgeObjectsV1KnowledgeSourcesSlugObjectsDelete,
   runFetchStepV1QuickCommandsSlugStepsStepSlugFetchRunPost,
   searchKnowledgeSourcesV1KnowledgeSourcesSearchPost,
@@ -60,17 +64,20 @@ import {
   updateResourceReviewV1ResourcesResourceTypeSlugResourceSlugReviewsReviewIdPatch,
   updateReviewCommentV1ResourcesResourceTypeSlugResourceSlugReviewsReviewIdAnswersAnswerIdPatch,
   updateTitleV1ConversationsConversationIdPatch,
-  vectorizeCustomKnowledgeSourceV1KnowledgeSourcesSlugCustomPost
+  vectorizeCustomKnowledgeSourceV1KnowledgeSourcesSlugCustomPost,
 } from '../api/ai'
 
-
 import { StackspotAPIError } from '../error/StackspotAPIError'
 import { ReactQueryNetworkClient } from '../network/ReactQueryNetworkClient'
 import { removeAuthorizationParam } from '../utils/remove-authorization-param'
 import { StreamedJson } from '../utils/StreamedJson'
+import { getSizeOfString } from '../utils/string'
 import {
   FixedConversationResponse,
   FixedDependencyResponse,
+  QCContext,
+  QCContextExecution,
+  QCProgressProps,
   ReplaceResult,
 } from './types'
 
@@ -166,7 +173,7 @@ class AIClient extends ReactQueryNetworkClient {
    */
   createQuickCommand = this.mutation(removeAuthorizationParam(createQuickCommandV1QuickCommandsPost))
   /**
-   * Creates a QC
+   * Deletes a QC
    */
   deleteQuickCommand = this.mutation(removeAuthorizationParam(deleteQuickCommandV1QuickCommandsSlugDelete))
   /**
@@ -367,12 +374,366 @@ class AIClient extends ReactQueryNetworkClient {
   deleteReviewComment = this.mutation(
     removeAuthorizationParam(deleteReviewCommentV1ResourcesResourceTypeSlugResourceSlugReviewsReviewIdAnswersAnswerIdDelete))
 
+  /**
+   * 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
+    }
+  }
+  
   contentDependencies = this.query(removeAuthorizationParam(
     getContentDependenciesV1ContentContentTypeContentIdDependenciesGet as ReplaceResult<
       typeof getContentDependenciesV1ContentContentTypeContentIdDependenciesGet,
       FixedDependencyResponse
     >,
   ))
+  
 }
 
 export const aiClient = new AIClient()

package/src/client/types.ts

@@ -1,10 +1,9 @@
 import { RequestOpts } from '@oazapfts/runtime'
 import { AccountScmInfoSaveRequest, AccountScmInfoUpdateRequest, AccountScmStatusResponse, GroupsFromResourceResponse, MembersFromResourceResponse } from '../api/account'
 import { AgentVisibilityLevelEnum, HttpMethod, ListAgentResponse, VisibilityLevelEnum } from '../api/agent-tools'
-import { ChatResponse3, ContentDependencyResponse, ConversationHistoryResponse, ConversationResponse, DependencyResponse, SourceKnowledgeSource, SourceProjectFile3, SourceStackAi } from '../api/ai'
+import { ChatRequest, ChatResponse3, ContentDependencyResponse, ConversationHistoryResponse, ConversationResponse, DependencyResponse, QuickCommandResponse, QuickCommandStepResult, SourceKnowledgeSource, SourceProjectFile3, SourceStackAi } from '../api/ai'
 import { ConnectAccountRequestV2, ManagedAccountProvisionRequest } from '../api/cloudAccount'
 import { AllocationCostRequest, AllocationCostResponse, ChargePeriod, getAllocationCostFilters, ManagedService, ServiceResource } from '../api/cloudServices'
-import { ChatRequest } from '../api/genAiInference'
 import { Action } from '../api/workspace-ai'
 import { ActivityResponse, FullInputContextResponse, InputConditionResponse, InputValuesContextResponse, PaginatedActivityResponse, PluginForAppCreationV2Response, PluginInputValuesInConsolidatedContextResponse, ValueByEnvResponse, WorkflowForCreationResponse } from '../api/workspaceManager'
 
@@ -178,6 +177,7 @@ export interface FixedChatRequest extends ChatRequest {
     stackspot_ai_version?: string,
     os?: string,
     agent_id?: string,
+    upload_ids?: string[],
   },
 }
 
@@ -421,3 +421,32 @@ export interface AgentToolsOpenAPIPreview {
   parameters?: Record<string, any>,
   request_body?: Record<string, any>,
 }
+
+type SlugExecution = Record<string, QuickCommandStepResult>
+
+
+interface BaseQCContext {
+  context: Required<FixedChatRequest>['context'],
+  resultMap: SlugExecution,
+  customInputs: Record<string, string>,
+  code?: string,
+  executionId: string,
+  signal: AbortSignal,
+  isRemote?: boolean, 
+  headers?: Record<string, string>,
+  conversation_id?: string,
+}
+
+export interface QCContext extends BaseQCContext {
+  slug: string,
+}
+
+export interface QCContextExecution extends BaseQCContext {
+  qc: QuickCommandResponse,
+}
+
+export interface QCProgressProps{ 
+  update?: (index: number) => void, 
+  remove?: () => void, 
+  onStepChange?: (stepResult: any) => void,
+}

package/src/utils/string.ts

@@ -17,3 +17,15 @@ export function formatJson(data: any): string {
   }
   return JSON.stringify(data, null, 2)
 }
+
+
+/**
+ * Gets the size of a string removing control characters and spaces
+ * @param str the string to count.
+ * @returns the count value.
+ */
+export function getSizeOfString(str: string): number {
+  // eslint-disable-next-line no-control-regex
+  const withoutSpacesAndControls = str.replace(/[\u0000-\u001F\u007F-\u009F\u061C\u200E\u200F\u202A-\u202E\u2066-\u2069\s]/g, '')
+  return withoutSpacesAndControls.length
+}