@stack-spot/portal-network 0.215.1-alpha.0 → 0.216.0

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

@@ -1,6 +1,5 @@
 
 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'
@@ -8,10 +7,6 @@ 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() {
@@ -65,282 +60,6 @@ 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()

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 } 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'
 
@@ -173,11 +172,20 @@ export interface FixedPaginatedActivityResponse extends Omit<PaginatedActivityRe
 
 export interface FixedChatRequest extends ChatRequest {
   context?: {
+    workspace?: string,
+    conversation_id?: string,
+    stack_id?: string,
+    language?: string,
+    project_recent_files?: string,
+    knowledge_sources?: string[],
+    agent_id?: string,
+    agent_built_in?: boolean,
     platform?: string,
     platform_version?: string,
     stackspot_ai_version?: string,
     os?: string,
-    agent_id?: string,
+    upload_ids?: string[],
+    selected_model_id?: string,
   },
 }
 
@@ -358,17 +366,9 @@ export interface ToolCallsAgentInfo extends BaseAgentInfo {
 
 export type AgentInfo = GenericAgentInfo | PlanningAgentInfo | StepAgentInfo | ToolAgentInfo | ToolCallsAgentInfo
 
-export type ChatResponse = {
-    message: string,
-    cross_account_source: SourceKnowledgeSource[],
-    source: (SourceStackAi | SourceKnowledgeSource | SourceProjectFile3)[],
-    message_id: string | null,
-    stop_reason: 'stop',
-};
-
-export interface FixedChatResponse extends ChatResponse {
-  agent_info: AgentInfo[],
-  tools_id?: string[],
+export interface FixedChatResponse extends ChatResponse3 {
+  agent_info: AgentInfo,
+  tools?: string[],
 }
 export interface OpportunitiesPMAgent {
   title: string,

package/src/client/workspace-ai.ts

@@ -1,7 +1,9 @@
 import { HttpError } from '@oazapfts/runtime'
+import { getApiAddresses } from '../api-addresses'
 import { AgentResponse } from '../api/agent'
 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,
   addFavoriteV1WorkspacesWorkspaceIdFavoritePost,
@@ -24,12 +26,11 @@ 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'
 
 class WorkspaceAiClient extends ReactQueryNetworkClient {

package/src/utils/StreamedJson.tsx

@@ -21,11 +21,6 @@ interface ConstructorParams<T> {
    * @default 50
    */
   minChangeIntervalMS?: number,
-  /**
-   * Allows overriding the minimum interval by event.
-   * Useful when some events must flush immediately (agent_info events).
-   */
-  minChangeIntervalMSFromEvent?: (event: Partial<T>, data: Partial<T>) => number | undefined,
   /**
    * Optional. If set, this function will be called with every streaming event and must transform the current data object according to the
    * message received.
@@ -50,18 +45,16 @@ export class StreamedJson<T> {
   private abortController: AbortController | undefined
   private transform?: (event: Partial<T>, data: Partial<T>) => void | Promise<void>
   private ignoreKeys?: (keyof T)[]
-  private minChangeIntervalMSFromEvent?: (event: Partial<T>, data: Partial<T>) => number | undefined
   private textFromErrorEvent: (data: Partial<T>) => string
 
   /**
    * @param response the fetch response.
    * @param minChangeIntervalMS a stream can be too fast. This sets a minimum interval between running the listeners. The default is 50ms.
    */
-  constructor({ eventsPromise, abortController, minChangeIntervalMS = 50, minChangeIntervalMSFromEvent, transform, ignoreKeys, textFromErrorEvent }: ConstructorParams<T>) {
+  constructor({ eventsPromise, abortController, minChangeIntervalMS = 50, transform, ignoreKeys, textFromErrorEvent }: ConstructorParams<T>) {
     this.abortController = abortController
     this.transform = transform
     this.ignoreKeys = ignoreKeys
-    this.minChangeIntervalMSFromEvent = minChangeIntervalMSFromEvent
     this.run(eventsPromise, minChangeIntervalMS)
     this.textFromErrorEvent = textFromErrorEvent ?? ((data) => JSON.stringify(data))
   }
@@ -84,9 +77,7 @@ export class StreamedJson<T> {
           }
           await this.transform?.(json, this.data)
           this.merge(json, this.data)
-
-          const intervalMS = this.minChangeIntervalMSFromEvent?.(json, this.data) ?? minChangeIntervalMS
-          if (event.event !== 'error' && new Date().getTime() - lastChangeCall >= intervalMS) {
+          if (event.event !== 'error' && new Date().getTime() - lastChangeCall >= minChangeIntervalMS) {
             this.onChangeListeners.forEach(l => l(this.data))
             lastChangeCall = new Date().getTime()
             flushed = true