@stack-spot/portal-network 0.39.2 → 0.40.0

package/src/client/ai.ts

@@ -0,0 +1,69 @@
+import { HttpError } from '@oazapfts/runtime'
+import {
+  ChatResponse3,
+  conversationHistoryV1ConversationsConversationIdGet,
+  defaults,
+  deleteConversationV1ConversationsConversationIdDelete,
+  downloadConversationV1ConversationsConversationIdDownloadGet,
+  findKnowledgeObjectByCustomIdV1KnowledgeSourcesSlugObjectsCustomIdGet,
+  getQuickCommandV1QuickCommandsSlugGet,
+  HttpValidationError,
+  listAiStacksV1AiStacksGet,
+  listAllV1QuickCommandsAllGet,
+  listAssociationV1WorkspaceWorkspaceIdGet,
+  listConversationsV1ConversationsGet,
+  listKnowledgeSourcesV1KnowledgeSourcesGet,
+  postEventV1EventsPost,
+  quickActionsV1QuickActionsPost,
+  updateTitleV1ConversationsConversationIdPatch,
+} from '../api/ai'
+import apis from '../apis.json'
+import { StackspotAPIError } from '../error/StackspotAPIError'
+import { ReactQueryNetworkClient } from '../network/ReactQueryNetworkClient'
+import { removeAuthorizationParam } from '../utils/remove-authorization-param'
+import { StreamedJson } from '../utils/StreamedJson'
+import { FixedChatRequest } from './types'
+
+class AIClient extends ReactQueryNetworkClient {
+  constructor() {
+    super(apis.ai.url, defaults)
+  }
+
+  protected buildStackSpotError(error: HttpError): StackspotAPIError {
+    return new StackspotAPIError({
+      status: error.status,
+      headers: error.headers,
+      stack: error.stack,
+      message: (error.data as HttpValidationError | undefined)?.detail?.map(d => d.msg)?.join('\n'),
+    })
+  }
+
+  runQuickAction = this.mutation(removeAuthorizationParam(quickActionsV1QuickActionsPost))
+  aiStacks = this.query(removeAuthorizationParam(listAiStacksV1AiStacksGet))
+  workspace = this.query(removeAuthorizationParam(listAssociationV1WorkspaceWorkspaceIdGet))
+  quickCommands = this.query(removeAuthorizationParam(listAllV1QuickCommandsAllGet))
+  quickCommand = this.query(removeAuthorizationParam(getQuickCommandV1QuickCommandsSlugGet))
+  knowledgeSources = this.query(removeAuthorizationParam(listKnowledgeSourcesV1KnowledgeSourcesGet))
+  knowledgeSource = this.query(removeAuthorizationParam(findKnowledgeObjectByCustomIdV1KnowledgeSourcesSlugObjectsCustomIdGet))
+  chats = this.infiniteQuery(removeAuthorizationParam(listConversationsV1ConversationsGet))
+  chat = this.query(removeAuthorizationParam(conversationHistoryV1ConversationsConversationIdGet))
+  deleteChat = this.mutation(removeAuthorizationParam(deleteConversationV1ConversationsConversationIdDelete))
+  downloadChats = this.mutation(removeAuthorizationParam(downloadConversationV1ConversationsConversationIdDownloadGet))
+  renameChat = this.mutation(removeAuthorizationParam(updateTitleV1ConversationsConversationIdPatch))
+  createEvent = this.mutation(removeAuthorizationParam(postEventV1EventsPost))
+
+  sendChatMessage(request: FixedChatRequest, minChangeIntervalMS?: number): StreamedJson<ChatResponse3> {
+    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 },
+    )
+    return new StreamedJson(events, abortController, minChangeIntervalMS)
+  }
+}
+
+export const aiClient = new AIClient()

package/src/client/types.ts

@@ -1,5 +1,6 @@
 import { RequestOpts } from '@oazapfts/runtime'
 import { AccountScmInfoSaveRequest, AccountScmInfoUpdateRequest, AccountScmStatusResponse } from '../api/account'
+import { ChatRequest2 } from '../api/ai'
 import { ConnectAccountRequestV2, ManagedAccountProvisionRequest } from '../api/cloudAccount'
 import { AllocationCostRequest, AllocationCostResponse, ChargePeriod, getAllocationCostFilters, ManagedService, ServiceResource } from '../api/cloudServices'
 import { FullInputContextResponse, InputConditionResponse, InputValuesContextResponse, PluginForAppCreationV2Response, PluginInputValuesInConsolidatedContextResponse, ValueByEnvResponse } from '../api/workspaceManager'
@@ -154,6 +155,23 @@ Omit<PluginInputValuesInConsolidatedContextResponse, 'inputs' | 'input' | 'type'
   condition?: FixedInputConditionResponse,
 }
 
+export interface FixedChatRequest extends ChatRequest2 {
+  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,
+  },
+}
+
 export type OazapftsFunction<Variables = any, Result = any> = (variables: Variables, opts?: RequestOpts) => Promise<Result>
 
 type Unpromisify<T> = T extends Promise<infer R> ? Unpromisify<R> : T
@@ -167,4 +185,3 @@ export type FixVariables<
 >
 
 export type ReplaceResult<T extends (...args: any[]) => Promise<any>, Fix> = (...args: Parameters<T>) => Promise<Fix>
-

package/src/error/StackspotAPIError.ts

@@ -1,6 +1,6 @@
 import { Language, getLanguage } from '@stack-spot/portal-translate'
 
-type InternationalizedMessage = (language: Language) => string
+export type InternationalizedMessage = (language: Language) => string
 
 interface ErrorProperties {
   /**

package/src/error/StreamCanceledError.ts

@@ -0,0 +1,10 @@
+import { StreamError } from './StreamError'
+
+export class StreamCanceledError extends StreamError {
+  constructor() {
+    super(language => language === 'pt'
+      ? 'Erro: a mensagem foi abortada pelo usuário.'
+      : 'Error: the message was aborted by the user.',
+    )
+  }
+}

package/src/error/StreamError.ts

@@ -0,0 +1,7 @@
+import { InternationalizedMessage, StackspotAPIError } from './StackspotAPIError'
+
+export class StreamError extends StackspotAPIError {
+  constructor(message: InternationalizedMessage) {
+    super({ status: 0, message })
+  }
+}

package/src/error/StreamJsonError.ts

@@ -0,0 +1,10 @@
+import { StreamError } from './StreamError'
+
+export class StreamJsonError extends StreamError {
+  constructor() {
+    super(language => language === 'pt'
+      ? 'Erro no formato do stream. O conteúdo não é um JSON válido.'
+      : 'Stream format error. The streamed content is not a valid JSON.',
+    )
+  }
+}

package/src/index.ts

@@ -1,10 +1,11 @@
 export { accountClient } from './client/account'
+export { aiClient } from './client/ai'
 export { cloudAccountClient } from './client/cloud-account'
+export { cloudPlatformClient } from './client/cloud-platform'
 export { cloudServicesClient } from './client/cloud-services'
 export { contentClient } from './client/content'
 export { eventBusClient } from './client/event-bus'
 export { notificationClient } from './client/notification'
-export { cloudPlatformClient } from './client/cloud-platform'
 export { runtimeManagerClient } from './client/runtime-manager'
 export { secretsClient } from './client/secrets'
 export * from './client/types'
@@ -14,7 +15,12 @@ export { workspaceManagerClient } from './client/workspace-manager'
 export { workspaceSearchClient } from './client/workspace-search'
 export { DefaultAPIError } from './error/DefaultAPIError'
 export { StackspotAPIError } from './error/StackspotAPIError'
+export { StreamCanceledError } from './error/StreamCanceledError'
+export { StreamError } from './error/StreamError'
+export { StreamJsonError } from './error/StreamJsonError'
 export { NetworkClient } from './network/NetworkClient'
 export { queryClient } from './network/react-query-client'
 export { OperationResult, OperationVariables, UseQueryObjectOptions } from './network/types'
+export { StreamedJson } from './utils/StreamedJson'
 export { useExtendedList } from './utils/use-extended-list'
+

package/src/network/NetworkClient.ts

@@ -1,6 +1,8 @@
 import { AuthenticationError } from '@stack-spot/auth'
 import { requestPermission } from '@stack-spot/opa'
-import { Env, HTTPMethod, SessionManager } from './types'
+import { events } from 'fetch-event-stream'
+import { StackspotAPIError } from '../error/StackspotAPIError'
+import { Env, FetchEventStream, HTTPMethod, SessionManager } from './types'
 
 /**
  * A set of methods for performing network requests to an API.
@@ -94,6 +96,33 @@ export abstract class NetworkClient {
     }
   }
 
+  /**
+   * Reads an EventSource from the endpoint. Differently than the original specification, this allows common HTTP requests with method and
+   * body to be made.
+   * 
+   * @example
+   * ```
+   * let events = this.stream('url', options)
+   * for await (let event of events) {
+   *   console.log('<<', event.data)
+   * }
+   * ```
+   * @param input the url or request object.
+   * @param init the fetch options.
+   * @returns a promise with a FetchEventStream, which is an AsyncGenerator.
+   */
+  protected async stream(input: string | URL | Request, init?: RequestInit): Promise<FetchEventStream> {
+    const response = await this.fetch(input, init)
+    if (!response.ok) {
+      let message = `Failed to get stream response. Error status: ${response.status}.`
+      try {
+        message = await response.text()
+      } catch { /* empty */ }
+      throw new StackspotAPIError({ status: response.status, headers: response.headers, message })
+    }
+    return events(response, init?.signal)
+  }
+
   /**
    * Checks whether or not the current account is freemium.
    * @returns true if it's a freemium account, false otherwise.

package/src/network/types.ts

@@ -1,6 +1,7 @@
 import type { RequestOpts } from '@oazapfts/runtime'
 import { Session } from '@stack-spot/auth'
 import { InfiniteData, MutateOptions, UseInfiniteQueryOptions, UseInfiniteQueryResult, UseMutationOptions, UseMutationResult, UseQueryOptions, UseQueryResult } from '@tanstack/react-query'
+import { ServerSentEventMessage } from 'fetch-event-stream'
 import { StackspotAPIError } from '../error/StackspotAPIError'
 
 export interface SessionManager {
@@ -13,6 +14,8 @@ export type Env = 'dev' | 'stg' | 'prd'
 
 export type HTTPMethod = 'post' | 'patch' | 'delete' | 'put' | 'get'
 
+export type FetchEventStream = AsyncGenerator<ServerSentEventMessage, void, unknown>
+
 export interface OperationConfig<Args extends [AbortSignal, Record<string, any>] | [AbortSignal], Result> {
   /**
    * The operation name. To be used as key in React Query.
@@ -161,7 +164,7 @@ export interface QueryObject<Variables, Result> extends OperationObject<Variable
    * 
    * @param args if this query accepts variables, the first argument should be the variables and the second the query options
    * (optional). If it doesn't accept variables, the single optional argument must be the query options.
-   * @returns the response data or undefined if not fetched.
+   * @returns the response data.
    * @throws `StackspotAPIError`
    * @throws `Promise<Result>`
    */
@@ -169,7 +172,7 @@ export interface QueryObject<Variables, Result> extends OperationObject<Variable
     ...args: Variables extends void
       ? [options?: UseQueryObjectOptions<Result>]
       : [variables: Variables, options?: UseQueryObjectOptions<Result>]
-  ) => Result | undefined,
+  ) => Result,
   /**
    * Same as `query`, but a React Hook instead.
    * @param args if this query accepts variables, the first argument should be the variables and the second the query options
@@ -220,7 +223,7 @@ export interface InfiniteQueryObject<Variables, Result, Accumulator extends keyo
       ? [variables?: Variables, options?: UseInfiniteQueryObjectOptions<Result>]
       : [variables: Variables, options?: UseInfiniteQueryObjectOptions<Result>]
   ) => Readonly<[
-    (Accumulator extends keyof Result ? Result[Accumulator] : Result) | undefined,
+    (Accumulator extends keyof Result ? Result[Accumulator] : Result),
     UseInfiniteQueryResult<InfiniteData<Result>, StackspotAPIError>,
   ]>,
   /**

package/src/utils/StreamedJson.tsx

@@ -0,0 +1,135 @@
+import { CompletablePromise } from '@stack-spot/opa'
+import { StreamCanceledError } from '../error/StreamCanceledError'
+import { StreamError } from '../error/StreamError'
+import { StreamJsonError } from '../error/StreamJsonError'
+import { FetchEventStream } from '../network/types'
+
+type StreamingStatus = 'pending' | 'success' | 'error'
+type OnChangeListener<T> = (value: Partial<T>) => void
+
+/**
+ * An object represented by a JSON stream. This can be watched as the stream runs.
+ */
+export class StreamedJson<T> {
+  private onChangeListeners: OnChangeListener<T>[] = []
+  private error: StreamError | undefined
+  private data: Partial<T> = {}
+  private fullPromise = new CompletablePromise<T>()
+  private abortController: AbortController | undefined
+
+  /**
+   * @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: Promise<FetchEventStream>, abortController: AbortController, minChangeIntervalMS = 50) {
+    this.abortController = abortController
+    this.run(eventsPromise, minChangeIntervalMS)
+  }
+
+  private async run(eventsPromise: Promise<FetchEventStream>, minChangeIntervalMS: number) {
+    let lastChangeCall = 0
+    try {
+      const events = await eventsPromise
+      let flushed = true
+      for await (const event of events) {
+        if (this.error) return
+        if (event.data) {
+          const json = JSON.parse(event.data)
+          StreamedJson.merge(json, this.data)
+          if (new Date().getTime() - lastChangeCall >= minChangeIntervalMS) {
+            this.onChangeListeners.forEach(l => l(this.data))
+            lastChangeCall = new Date().getTime()
+            flushed = true
+          } else {
+            flushed = false
+          }
+        }
+      }
+      if (!flushed) this.onChangeListeners.forEach(l => l(this.data))
+    } catch (error: any) {
+      if (error instanceof DOMException && error.name === 'AbortError') this.fail(new StreamCanceledError())
+      if (error instanceof SyntaxError) this.fail(new StreamJsonError())
+      else if (error instanceof StreamError) this.fail(error)
+      else this.fail(new StreamError(error?.message || `${error}`))
+    }
+    if (!this.error) this.complete()
+  }
+
+  private static merge(source: Record<string, any>, target: Record<string, any>) {
+    Object.keys(source).forEach((k) => {
+      if (typeof source[k] !== typeof target[k]) target[k] = source[k]
+      else if (typeof source[k] === 'string') target[k] += source[k]
+      else if (Array.isArray(source[k])) target[k].push(...source[k])
+      else if (typeof source[k] === 'number') parseFloat(target[k] + source[k])
+      else if (typeof source[k] === 'object') this.merge(source[k], target[k])
+      else target[k] = source[k]
+    })
+  }
+
+  private clear() {
+    this.onChangeListeners = []
+    this.abortController = undefined
+  }
+
+  private fail(error: any) {
+    this.error = error
+    this.fullPromise.reject(this.error)
+    this.clear()
+  }
+
+  private complete() {
+    this.fullPromise.resolve(this.data as T)
+    this.clear()
+  }
+
+  /**
+   * Returns the full value of the object once the stream finishes.
+   */
+  getValue(): Promise<T> {
+    return this.fullPromise.promise
+  }
+
+  /**
+   * Returns the streamed object with everything already streamed. This will be the complete object if the stream has finished.
+   */
+  getPartialValue(): Partial<T> {
+    return this.data
+  }
+
+  /**
+   * Watches the object as it's streamed. This doesn't wait for the value to be complete.
+   * 
+   * The listener is called whenever the value changes.
+   * 
+   * @param listener the function to call with the new value.
+   * @returns a function that, when called, removes the listener.
+   */
+  onChange(listener: (value: Partial<T>) => void) {
+    if (this.fullPromise.resolved) {
+      listener(this.data)
+      return () => {}
+    }
+    this.onChangeListeners.push(listener)
+    return () => {
+      const index = this.onChangeListeners?.findIndex(l => l === listener)
+      if (index !== undefined && index >= 0) this.onChangeListeners?.splice(index, 1)
+    }
+  }
+
+  getStatus(): StreamingStatus {
+    if (this.error) return 'error'
+    if (this.fullPromise.resolved) return 'success'
+    return 'pending'
+  }
+
+  getError() {
+    return this.error
+  }
+
+  /**
+   * If this is a stream and it's not yet finished, calling this function cancels the stream.
+   */
+  cancel() {
+    this.abortController?.abort(new StreamCanceledError())
+  }
+}