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

package/src/client/ai.ts

@@ -1,14 +1,16 @@
 import { HttpError } from '@oazapfts/runtime'
-import { findLast, isArray, last } from 'lodash'
+import { findLast, isArray, isNil, last } from 'lodash'
 import { getApiAddresses } from '../api-addresses'
 import {
   addFavoriteV1AiStacksStackIdFavoritePost,
   addFavoriteV1QuickCommandsSlugFavoritePost,
   calculateNextStepV1QuickCommandsSlugStepsStepSlugCalculateNextStepPost,
   callbackV1QuickCommandsCallbackExecutionIdGet,
+  checkQuickCommandExistsV1QuickCommandsSlugExistsGet,
   conversationHistoryV1ConversationsConversationIdGet,
   createAnswerForReviewV1ResourcesResourceTypeSlugResourceSlugReviewsReviewIdAnswersPost,
   createExecutionV1QuickCommandsCreateExecutionSlugPost,
+  createQuickCommandV1QuickCommandsPost,
   createResourceReviewV1ResourcesResourceTypeSlugResourceSlugReviewsPost,
   currentV1TokensUsageCurrentGet,
   defaults,
@@ -16,11 +18,15 @@ import {
   deleteFavoriteV1AiStacksStackIdFavoriteDelete,
   deleteFavoriteV1QuickCommandsSlugFavoriteDelete,
   deleteKnowledgeObjectByCustomIdV1KnowledgeSourcesSlugObjectsCustomIdDelete,
+  deleteKnowledgeSourceV1KnowledgeSourcesSlugDelete,
+  deleteQuickCommandV1QuickCommandsSlugDelete,
   deleteResourceReviewV1ResourcesResourceTypeSlugResourceSlugReviewsReviewIdDelete,
   deleteReviewCommentV1ResourcesResourceTypeSlugResourceSlugReviewsReviewIdAnswersAnswerIdDelete,
   downloadConversationV1ConversationsConversationIdDownloadGet,
   findKnowledgeObjectByCustomIdV1KnowledgeSourcesSlugObjectsCustomIdGet,
+  findKnowledgeSourceDependenciesV1KnowledgeSourcesSlugDependenciesGet,
   findKnowledgeSourceV1KnowledgeSourcesSlugGet,
+  forkV1QuickCommandsSlugForkPost,
   formatFetchStepV1QuickCommandsSlugStepsStepSlugFetchFormatPost,
   formatResultV1QuickCommandsSlugResultFormatPost,
   getContentDependenciesV1ContentContentTypeContentIdDependenciesGet,
@@ -38,10 +44,15 @@ import {
   listConversationsV1ConversationsGet,
   listKnowledgeSourcesV1KnowledgeSourcesGet,
   postEventV1EventsPost,
+  publishV1QuickCommandsSlugPublishPost,
   quickActionsV1QuickActionsPost,
+  QuickCommandPromptResponse,
   QuickCommandPromptResponse2,
+  QuickCommandScriptExecutionResponse,
   QuickCommandsExecutionRequest,
   quickCommandsRunV2V2QuickCommandsSlugStepsStepSlugRunPost,
+  QuickCommandStepFetchResponse,
+  QuickCommandStepLlmResponse,
   resetKnowledgeObjectsV1KnowledgeSourcesSlugObjectsDelete,
   runFetchStepV1QuickCommandsSlugStepsStepSlugFetchRunPost,
   searchKnowledgeSourcesV1KnowledgeSourcesSearchPost,
@@ -56,12 +67,11 @@ import {
   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 { formatJson } from '../utils/string'
+import { formatJson, getSizeOfString } from '../utils/string'
 import { agentToolsClient } from './agent-tools'
 import {
   AgentInfo,
@@ -71,6 +81,9 @@ import {
   FixedChatResponse,
   FixedConversationResponse,
   FixedDependencyResponse,
+  QCContext,
+  QCContextExecution,
+  QCProgressProps,
   ReplaceResult,
   StepChatStep,
 } from './types'
@@ -117,6 +130,10 @@ class AIClient extends ReactQueryNetworkClient {
    */
   vectorizeCustomKS = this.mutation(
     removeAuthorizationParam(vectorizeCustomKnowledgeSourceV1KnowledgeSourcesSlugCustomPost))
+  /**
+   * Deletes a KS
+   */
+  deleteKS = this.mutation(removeAuthorizationParam(deleteKnowledgeSourceV1KnowledgeSourcesSlugDelete))
   /**
    * Lists the AI Stacks according to their visibilities.
    */
@@ -158,6 +175,26 @@ class AIClient extends ReactQueryNetworkClient {
    * Gets the execution status and result of a quick command by its execution ID.
    */
   quickCommandCallbackExecutionId = this.query(removeAuthorizationParam(callbackV1QuickCommandsCallbackExecutionIdGet))
+  /**
+   * Creates a QC
+   */
+  createQuickCommand = this.mutation(removeAuthorizationParam(createQuickCommandV1QuickCommandsPost))
+  /**
+   * Deletes a QC
+   */
+  deleteQuickCommand = this.mutation(removeAuthorizationParam(deleteQuickCommandV1QuickCommandsSlugDelete))
+  /**
+   * Forks a QC
+   */
+  forkQuickCommand = this.mutation(removeAuthorizationParam(forkV1QuickCommandsSlugForkPost))
+  /**
+   * Publishes a QC
+   */
+  publishQuickCommand = this.mutation(removeAuthorizationParam(publishV1QuickCommandsSlugPublishPost))
+  /**
+   * Check Quick Command Available slug
+   */
+  checkAvailableQuickCommandSlug = this.query(removeAuthorizationParam(checkQuickCommandExistsV1QuickCommandsSlugExistsGet))
   /**
    * Lists the knowledge sources according to filters passed as parameter.
    */
@@ -174,6 +211,10 @@ class AIClient extends ReactQueryNetworkClient {
    * Lists knowledge sources matching the provided IDs.
    */
   searchKnowledgeSources = this.query(removeAuthorizationParam(searchKnowledgeSourcesV1KnowledgeSourcesSearchPost))
+  /**
+   * Finds Knowledge Source Dependencies
+   */
+  dependenciesKnowledgeSources = this.query(removeAuthorizationParam(findKnowledgeSourceDependenciesV1KnowledgeSourcesSlugDependenciesGet))
   /**
    * Gets the chat history. This is a paginated resource.
    */
@@ -340,15 +381,16 @@ class AIClient extends ReactQueryNetworkClient {
   deleteReviewComment = this.mutation(
     removeAuthorizationParam(deleteReviewCommentV1ResourcesResourceTypeSlugResourceSlugReviewsReviewIdAnswersAnswerIdDelete))
 
-  private static async toolsOfAgent(agentId?: string) {
+  private static async toolsOfAgent(agentId?: string, agent_version_number?: number) {
     try {
-      const agent = agentId ? await agentToolsClient.agent.query({ agentId }) : undefined
+      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.toolkits?.builtin_toolkits?.forEach(kit => kit.tools?.forEach(({ id, name, description }) => {
+      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.toolkits?.custom_toolkits?.forEach(kit => kit.tools?.forEach(({ id, name, 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
@@ -357,6 +399,359 @@ class AIClient extends ReactQueryNetworkClient {
     }
   }
 
+  /**
+   * 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 = {
@@ -380,7 +775,7 @@ class AIClient extends ReactQueryNetworkClient {
     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)
+      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') {
@@ -602,6 +997,7 @@ class AIClient extends ReactQueryNetworkClient {
       FixedDependencyResponse
     >,
   ))
+  
 }
 
 export const aiClient = new AIClient()

package/src/client/types.ts

@@ -1,7 +1,7 @@
 import { RequestOpts } from '@oazapfts/runtime'
 import { AccountScmInfoSaveRequest, AccountScmInfoUpdateRequest, AccountScmStatusResponse, GroupsFromResourceResponse, MembersFromResourceResponse } from '../api/account'
 import { AgentVisibilityLevelEnum, HttpMethod, ListAgentResponse, VisibilityLevelEnum } from '../api/agent-tools'
-import { ChatRequest, ChatResponse3, ContentDependencyResponse, ConversationHistoryResponse, ConversationResponse, DependencyResponse } from '../api/ai'
+import { ChatRequest, ChatResponse3, ContentDependencyResponse, ConversationHistoryResponse, ConversationResponse, DependencyResponse, QuickCommandResponse, QuickCommandStepResult } from '../api/ai'
 import { ConnectAccountRequestV2, ManagedAccountProvisionRequest } from '../api/cloudAccount'
 import { AllocationCostRequest, AllocationCostResponse, ChargePeriod, getAllocationCostFilters, ManagedService, ServiceResource } from '../api/cloudServices'
 import { Action } from '../api/workspace-ai'
@@ -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/client/workspace-ai.ts

@@ -1,9 +1,11 @@
 import { HttpError } from '@oazapfts/runtime'
-import { AgentResponse } from '../api/agent'
+import { getApiAddresses } from '../api-addresses'
 import { CustomToolkitResponse } from '../api/agent-tools'
-import { GetAiStackResponse, KnowledgeSourceItemResponse, QuickCommandResponse } from '../api/ai'
+import { GetAiStackResponse, QuickCommandResponse } from '../api/ai'
+import { KnowledgeSourceItemResponse } from '../api/dataIntegration'
 import {
   addContentV1WorkspacesWorkspaceIdContentTypePost,
+  addContentV2WorkspacesWorkspaceIdContentTypePost,
   addFavoriteV1WorkspacesWorkspaceIdFavoritePost,
   addPermissionV1ResourceTypeResourceTypeResourcesResourceIdentifierPatch,
   addPermissionV1WorkspacesWorkspaceIdPermissionsPatch,
@@ -24,13 +26,12 @@ import {
   updateWorkspaceV1WorkspacesWorkspaceIdPatch,
   useShareableLinkV1ShareShareIdPatch,
 } from '../api/workspace-ai'
+import { DefaultAPIError } from '../error/DefaultAPIError'
+import { wksAiDictionary } from '../error/dictionary/workspace-ai'
 import { StackspotAPIError } from '../error/StackspotAPIError'
 import { ReactQueryNetworkClient } from '../network/ReactQueryNetworkClient'
 import { removeAuthorizationParam } from '../utils/remove-authorization-param'
-import { getApiAddresses } from '../api-addresses'
-import { DefaultAPIError } from '../error/DefaultAPIError'
-import { wksAiDictionary } from '../error/dictionary/workspace-ai'
-import { FixedAddResourceToWorkspaceAi, FixedWorkspaceAiPermissions, ReplaceResult } from './types'
+import { AgentResponseWithBuiltIn, FixedAddResourceToWorkspaceAi, FixedWorkspaceAiPermissions, ReplaceResult } from './types'
 
 class WorkspaceAiClient extends ReactQueryNetworkClient {
   constructor() {
@@ -48,6 +49,7 @@ class WorkspaceAiClient extends ReactQueryNetworkClient {
   deleteWorkspaceAi = this.mutation(removeAuthorizationParam(deleteWorkspaceV1WorkspacesWorkspaceIdDelete))
 
   /**
+   * @deprecated
    * Adds a resource to the Spot.
    */
   addResourceTypeToWorkspaceAi = this.mutation({
@@ -61,6 +63,20 @@ class WorkspaceAiClient extends ReactQueryNetworkClient {
     permission: this.createPermissionFunctionFor(addContentV1WorkspacesWorkspaceIdContentTypePost),
   })
 
+  /**
+   * V2 for adding a resource to the Spot.
+   */
+  addResourceTypeV2ToSpot = this.mutation({
+    name: 'addResourceTypeToWorkspaceAi',
+    request: (
+      signal,
+      variables: Omit<Parameters<typeof addContentV2WorkspacesWorkspaceIdContentTypePost>[0], 'authorization'>,
+    ) =>
+      addContentV2WorkspacesWorkspaceIdContentTypePost({ ...variables, authorization: '' },
+        { signal }) as unknown as Promise<FixedAddResourceToWorkspaceAi>,
+    permission: this.createPermissionFunctionFor(addContentV2WorkspacesWorkspaceIdContentTypePost),
+  })
+
   /**
    * Lists all the knowledge sources in a Spot.
    */
@@ -117,7 +133,7 @@ class WorkspaceAiClient extends ReactQueryNetworkClient {
         'authorization' | 'contentType'>,
     ) =>
       listAllByContentTypeV1WorkspacesWorkspaceIdContentTypeGet({ ...variables, contentType: 'agent', authorization: '' },
-        { signal }) as unknown as Promise<AgentResponse[]>,
+        { signal }) as unknown as Promise<AgentResponseWithBuiltIn[]>,
     permission: this.createPermissionFunctionFor(listAllByContentTypeV1WorkspacesWorkspaceIdContentTypeGet),
   })
 

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
+}