@stack-spot/ai-chat-widget 0.11.0 → 1.0.0-dev.1768324407795

package/src/utils/upload/UploadManager.ts

@@ -0,0 +1,156 @@
+import { pull } from 'lodash'
+import { FileSize } from '../../state/types'
+import { FileAlreadyExists, FileIsTooLarge, MaxFilesReached, UploadError } from './errors'
+import { FileUpload } from './FileUpload'
+import { getFileId, unitPower } from './utils'
+
+export type UploadChangeListener = (files: FileUpload[]) => void
+export type UploadStatusChangeListener = (status: UploadManagerStatus) => void
+export type UploadErrorListener = (errors: UploadError[]) => void
+export type UploadManagerStatus = 'idle' | 'uploading' | 'error'
+
+export class UploadManager {
+  private changeListeners: UploadChangeListener[] = []
+  private statusListeners: UploadStatusChangeListener[] = []
+  private errorListeners: UploadErrorListener[] = []
+  private input: HTMLInputElement | null = null
+  private value: FileUpload[] = []
+  private maxSize?: FileSize
+  private maxItems: number
+  private accept: string[]
+  private onDestroy: () => void = () => {}
+  status: UploadManagerStatus = 'idle'
+
+  constructor(options?: { maxSize?: FileSize, accept?: string[], maxItems?: number }) {
+    this.maxSize = options?.maxSize
+    this.accept = options?.accept ?? []
+    this.maxItems = options?.maxItems ?? 0
+  }
+
+  private runChangeListeners() {
+    this.changeListeners.forEach(l => l(this.value))
+  }
+
+  private runStatusListeners() {
+    const status = this.computeStatus()
+    if (status === this.status) return
+    this.status = status
+    this.statusListeners.forEach(l => l(status))
+  }
+
+  private hasEquivalentFile(file: File) {
+    const id = getFileId(file)
+    return this.value.some(f => id === f.id)
+  }
+
+  private processFiles(files: FileList | File[]) {
+    const newFiles: FileUpload[] = []
+    const errors: UploadError[] = []
+    for (const f of files ?? []) {
+      if (this.maxSize && f.size > this.maxSize.value * Math.pow(1024, unitPower[this.maxSize?.unit])) {
+        errors.push(new FileIsTooLarge(f.name, this.maxSize))
+      } else if (this.maxItems && this.value.length + newFiles.length === this.maxItems) {
+        errors.push(new MaxFilesReached(f.name, this.maxItems))
+      } else if (this.hasEquivalentFile(f)) {
+        errors.push(new FileAlreadyExists(f.name))
+      } else {
+        const upload = new FileUpload(f)
+        newFiles.push(upload)
+        upload.onChange(() => this.runStatusListeners())
+      }
+    }
+    if (newFiles.length) {
+      this.value = [...this.value, ...newFiles]
+      this.runChangeListeners()
+      this.runStatusListeners()
+    }
+    if (errors.length) {
+      this.errorListeners.forEach(l => l(errors))
+    }
+  }
+
+  private attachEventListeners() {
+    const handleChange = () => {
+      this.processFiles(this.input?.files || [])
+      this.destroy()
+    }
+    this.onDestroy = () => this.input?.removeEventListener('change', handleChange)
+    this.input?.addEventListener('change', handleChange)
+  }
+
+  private createInput() {
+    this.input = document.createElement('input')
+    this.input.setAttribute('type', 'file')
+    this.input.setAttribute('multiple', '')
+    this.input.setAttribute('style', 'display: none')
+    this.input.setAttribute('accept', `.${this.accept.join(',.')}`)
+    document.body.append(this.input)
+    this.attachEventListeners()
+  }
+
+  private computeStatus(): UploadManagerStatus {
+    let uploading = false
+    for (const f of this.value) {
+      if (f.status === 'error') return 'error'
+      if (f.status === 'pending') uploading = true
+    }
+    return uploading ? 'uploading' : 'idle'
+  }
+
+  open() {
+    this.createInput()
+    this.input?.click()
+  }
+
+  get(): FileUpload[] {
+    return this.value
+  }
+
+  reset() {
+    this.value.forEach(f => f.destroy())
+    this.value = []
+    this.runChangeListeners()
+  }
+
+  add(files: File | File[] = []) {
+    const fileList = Array.isArray(files) ? files : [files]
+    this.processFiles(fileList)
+  }
+
+  remove(file: FileUpload) {
+    file.destroy()
+    this.value = this.value.filter(f => f !== file)
+    this.runChangeListeners()
+    this.runStatusListeners()
+  }
+
+  onChange(listener: UploadChangeListener) {
+    this.changeListeners.push(listener)
+    return () => {
+      pull(this.changeListeners, listener)
+    }
+  }
+
+  onChangeStatus(listener: UploadStatusChangeListener) {
+    this.statusListeners.push(listener)
+    return () => {
+      pull(this.statusListeners, listener)
+    }
+  }
+
+  onError(listener: UploadErrorListener) {
+    this.errorListeners.push(listener)
+    return () => {
+      pull(this.errorListeners, listener)
+    }
+  }
+
+  isFull() {
+    return !!this.maxItems && this.value.length === this.maxItems
+  }
+
+  destroy() {
+    this.onDestroy()
+    this.input?.remove()
+  }
+}

package/src/utils/upload/context.tsx

@@ -0,0 +1,44 @@
+import { useEffectOnce } from '@stack-spot/portal-components'
+import { createContext, ReactNode, useContext, useEffect, useState } from 'react'
+import { UploadError } from './errors'
+import { FileUpload } from './FileUpload'
+import { FileUploadStatus } from './types'
+import { UploadManager, UploadManagerStatus } from './UploadManager'
+
+const context = createContext<UploadManager | undefined>(undefined)
+
+export const UploadProvider = ({ value = new UploadManager(), children }: { value: UploadManager, children: ReactNode }) => {
+  useEffectOnce(() => () => value.destroy())
+  return <context.Provider value={value}>{children}</context.Provider>
+}
+
+export function useUploadManager() {
+  const manager = useContext(context)
+  if (!manager) throw new Error('"useUploadManager()" must be used only within the context of an <UploadProvider>.')
+  return manager
+}
+
+export function useUploads(): FileUpload[] {
+  const manager = useUploadManager()
+  const [files, setFiles] = useState<FileUpload[]>([])
+  useEffect(() => manager.onChange(setFiles))
+  return files
+}
+
+export function useUploadErrorEffect(effect: (errors: UploadError[]) => void) {
+  const manager = useUploadManager()
+  useEffect(() => manager.onError(effect))
+}
+
+export function useUploadManagerStatus() {
+  const manager = useUploadManager()
+  const [status, setStatus] = useState<UploadManagerStatus>(manager.status)
+  useEffect(() => manager.onChangeStatus(setStatus))
+  return status
+}
+
+export function useUploadStatus(file: FileUpload) {
+  const [status, setStatus] = useState<FileUploadStatus>(file.status)
+  useEffect(() => file.onChange(setStatus))
+  return status
+}

package/src/utils/upload/errors.ts

@@ -0,0 +1,34 @@
+import { FileSize } from '../../state/types'
+
+export class UploadError extends Error {
+  readonly fileName: string
+
+  constructor(fileName: string, message?: string) {
+    super(message || `There was an error while uploading ${fileName}`)
+    this.fileName = fileName
+  }
+}
+
+export class FileIsTooLarge extends UploadError {
+  readonly maxSize: FileSize
+
+  constructor(fileName: string, maxSize: FileSize) {
+    super(fileName, `Can't upload ${fileName} because it exceeds the maximum file size of ${maxSize.value} ${maxSize.unit}.`)
+    this.maxSize = maxSize
+  }
+}
+
+export class FileAlreadyExists extends UploadError {
+  constructor(fileName: string) {
+    super(fileName, `Can't upload ${fileName} because it is already on the list.`)
+  }
+}
+
+export class MaxFilesReached extends UploadError {
+  readonly maxFiles: number
+
+  constructor(fileName: string, maxFiles: number) {
+    super(fileName, `Can't upload ${fileName} because the maximum number of files (${maxFiles}) has been reached.`)
+    this.maxFiles = maxFiles
+  }
+}

package/src/utils/upload/types.ts

@@ -0,0 +1,7 @@
+export interface FileDescription {
+  id: string,
+  name: string,
+  extension: string,
+}
+
+export type FileUploadStatus = 'pending' | 'success' | 'error'

package/src/utils/upload/use-paste-upload.tsx

@@ -0,0 +1,30 @@
+import { useEffect } from 'react'
+
+interface UsePasteUploadProps {
+  textAreaRef: React.RefObject<HTMLTextAreaElement>,
+  onUploadFiles: (files: File[]) => void,
+  enabled?: boolean,
+}
+
+export const usePasteUpload = ({
+  textAreaRef,
+  onUploadFiles,
+  enabled = true,
+}: UsePasteUploadProps) => {
+  useEffect(() => {
+    const textarea = textAreaRef.current
+    if (!textarea || !enabled) return
+
+    const handlePaste = (e: ClipboardEvent) => {
+      if (e.clipboardData?.files?.length) {
+        onUploadFiles(Array.from(e.clipboardData.files))
+        e.preventDefault()
+      }
+    }
+
+    textarea.addEventListener('paste', handlePaste)
+    return () => {
+      textarea.removeEventListener('paste', handlePaste)
+    }
+  }, [onUploadFiles, textAreaRef, enabled])
+}

package/src/utils/upload/utils.ts

@@ -0,0 +1,12 @@
+import { FileSize } from '../../state/types'
+
+export function getFileId(file: File) {
+  return `${file.name}|${file.lastModified}|${file.size}`
+}
+
+export const unitPower: Record<FileSize['unit'], number> = {
+  B: 0,
+  KB: 1,
+  MB: 2,
+  GB: 3,
+}

package/src/utils/url.ts

@@ -0,0 +1,8 @@
+const stkAIDomain = /^https:\/\/ai(\.\w+)?\.stackspot\.com$/
+const localhostDomain = /^http:\/\/localhost:\d+$/
+const aiPrd = 'https://ai.stackspot.com'
+
+export function getUrlToStackSpotAI() {
+  const current = location.origin
+  return stkAIDomain.test(current) || localhostDomain.test(current) ? current : aiPrd
+}

package/src/views/Agents/AgentDescription.tsx

@@ -0,0 +1,107 @@
+import { Icon } from '@stack-spot/citric-icons'
+import { AsyncContent, Badge, Card, IconBox, ImageBox, ImageWithFallback, Text } from '@stack-spot/citric-react'
+import { agentToolsClient } from '@stack-spot/portal-network'
+import { useMemo } from 'react'
+import { useAgentsDictionary } from './dictionary'
+import { AgentDescriptionBox } from './styled'
+
+export const AgentDescription = ({ agentId }: { agentId?: string }) => {
+  const t = useAgentsDictionary()
+  const [agent,, error, { isLoading }] = agentToolsClient.agent.useStatefulQuery({ agentId: agentId! }, { enabled: !!agentId })
+  const numberOfKnowledgeSources = agent?.knowledge_sources_config?.knowledge_sources.length ?? 0
+  
+  const knowledgeSources = useMemo(
+    () => agent?.knowledge_sources_config?.knowledge_sources_details?.map((ks, index) => (
+      <li key={index}>
+        <Card gap="10px" direction="row" flex={1} size="xxs" bgLevel={500} justifyContent="space-between">
+          <Text color="light.contrastText">{ks.name}</Text>
+          <Badge colorScheme="inverse" appearance="square">{ks.type}</Badge>
+        </Card>
+      </li>
+    )),
+    [agent],
+  )
+  
+  const { tools, multiAgents } = useMemo(() => {
+    const tools: React.ReactElement[] = [] 
+    const multiAgents: React.ReactElement[] = [] 
+    const builtInTools = agent?.toolkits?.builtin_toolkits ?? []
+    const customToolkits = agent?.toolkits?.custom_toolkits ?? []
+    for (const toolkit of builtInTools) {
+      for (const tool of toolkit.tools ?? []) {
+        if (toolkit.id == 'UTILITIES'){ 
+          tools.push(
+            <li key={tool.id}>
+              <Card gap="10px" direction="row" flex={1} size="xxs" bgLevel={500}>
+                <ImageBox><ImageWithFallback src={toolkit.image_url} fallback={<Icon icon="Cog" />} /></ImageBox>
+                <Text color="light.contrastText">{tool?.name || tool?.id || 'unknown'}</Text>
+              </Card>
+            </li>,
+          )
+        }
+        if (toolkit.id == 'MULTI_AGENTS'){
+          multiAgents.push(
+            <li key={tool.id}>
+              <Card gap="10px" direction="row" flex={1} size="xxs" bgLevel={500}>
+                <IconBox icon="Agent" />
+                <Text color="light.contrastText">{tool.name}</Text>
+              </Card>
+            </li>,
+          )
+        }
+      }
+    }
+    for (const toolkit of customToolkits) {
+      for (const tool of toolkit.tools) {
+        tools.push(
+          <li key={tool.id}>
+            <Card gap="10px" direction="row" flex={1} size="xxs" bgLevel={500}>
+              <ImageBox><ImageWithFallback src={toolkit.avatar ?? undefined} fallback={<Icon icon="Cog" />} /></ImageBox>
+              <Text color="light.contrastText">{tool.name}</Text>
+            </Card>
+          </li>,
+        )
+      }
+    }
+    return { tools, multiAgents }
+  }, [agent])
+
+  const mcpToolkits = useMemo(() => agent?.toolkits?.mcp_toolkits?.map(t => (
+    <li key={`mcp-${t.id}`}>
+      <Card gap="10px" direction="row" flex={1} size="xxs" bgLevel={500}>
+        <ImageBox><ImageWithFallback src={t.avatar ?? undefined} fallback={<Icon icon="Cog" />} /></ImageBox>
+        <Text color="light.contrastText">{t.name}</Text>
+      </Card>
+    </li>
+  )), [agent?.toolkits?.mcp_toolkits])
+
+  return (
+    <AsyncContent loading={isLoading} error={error}>
+      <AgentDescriptionBox>
+        {agent?.description && <section>
+          <Text appearance="microtext1" className="title">{t.description}</Text>
+          <Text>{agent?.description}</Text>
+        </section>}
+        {(!!numberOfKnowledgeSources || !!knowledgeSources?.length) && <section>
+          <Text appearance="microtext1" className="title">Knowledge sources</Text>
+          <ul>{knowledgeSources}</ul>
+        </section>}
+        {!!tools?.length && <section>
+          <Text appearance="microtext1" className="title">{t.tools}</Text>
+          <ul>
+            {tools}
+            {mcpToolkits}
+          </ul>
+        </section>}
+        {!!multiAgents?.length && <section>
+          <Text appearance="microtext1" className="title">{t.multiAgent}</Text>
+          <ul>{multiAgents}</ul>
+        </section>}
+        {agent?.model_name && <section>
+          <Text appearance="microtext1" className="title">LLM</Text>
+          <Badge colorPalette="orange" appearance="square">{agent?.model_name}</Badge>
+        </section>}
+      </AgentDescriptionBox>
+    </AsyncContent>
+  )
+}

package/src/views/Agents/AgentsPanel.tsx

@@ -0,0 +1,57 @@
+import { Tab } from '@stack-spot/citric-react'
+import { agentToolsClient } from '@stack-spot/portal-network'
+import { useEffect, useRef } from 'react'
+import { RightPanelContentList } from '../../components/RightPanelContentList'
+import { RightPanelTabs } from '../../components/RightPanelTabs'
+import { useCurrentChat, useWidgetState } from '../../context/hooks'
+import { Scope } from '../../features'
+import { checkIsTrial } from '../../utils/check-is-trial'
+import { AgentsTab, AgentsTabWorkspace } from './AgentsTab'
+import { useAgentsDictionary } from './dictionary'
+
+/**
+ * Renders the Agent selection form in the Right Panel if this is the panel that is currently opened.
+ */
+export const AgentsPanel = () => {
+  const t = useAgentsDictionary()
+  const chat = useCurrentChat()
+  const isTrial = checkIsTrial()
+  const agent = useRef(chat.get('agent'))
+  const features = useWidgetState('features')
+  const isGroupResourcesByScope = features?.groupResourcesByScope
+  const scopes = features?.scopes ?? []
+  const spotId = features?.workspaceId
+
+  useEffect(() => {
+    if (agentToolsClient.agentDefaultSlug !== chat.get('agent')?.slug) {
+      agent.current = chat.get('agent')
+    }
+  }, [chat])
+
+  const allTabsMap: Record<Scope, Omit<Tab, 'key'>> = {
+    favorite: { label: t.favorites, content: <AgentsTab key="favorite" visibility="favorite" agent={agent} /> },
+    builtin: { label: t.builtin, content: <AgentsTab key="builtin" visibility="built_in" agent={agent} /> },
+    personal: { label: t.personal, content: <AgentsTab key="personal" visibility="personal" agent={agent} /> },
+    shared: { label: t.shared, content: <AgentsTab key="shared" visibility="shared" agent={agent} /> },
+    workspace: { label: t.spots, content: <AgentsTabWorkspace key="workspace" visibility="workspace" agent={agent} /> },
+    account: { label: t.account, content: <AgentsTab key="account" visibility="account" agent={agent} /> },
+  }
+   
+  const defaultScopes: Scope[] = ['favorite', 'builtin', 'personal', 'shared', 'workspace', 'account']
+
+  const rawScopes: Scope[] = scopes?.length ? scopes : defaultScopes
+
+  const scopesToRender: Scope[] = isTrial
+    ? ['favorite', 'builtin', 'personal']
+    : rawScopes
+
+  const tabs = scopesToRender
+    .map(scope => scope in allTabsMap ? ({ key: scope, ...allTabsMap[scope] }) : undefined)
+    .filter(Boolean) as Tab[]
+
+  return (isGroupResourcesByScope ? (
+    <RightPanelTabs key={chat.id} tabs={tabs} />
+  ) : (
+    <RightPanelContentList><AgentsTab workspaceId={spotId} agent={agent} /></RightPanelContentList>
+  ))
+}

package/src/views/Agents/AgentsTab.tsx

@@ -0,0 +1,126 @@
+import { Icon } from '@stack-spot/citric-icons'
+import { Button, ImageWithFallback } from '@stack-spot/citric-react'
+import { Placeholder } from '@stack-spot/portal-components/Placeholder'
+import { AgentResponseWithBuiltIn, agentToolsClient, AgentVisibilityLevel, workspaceAiClient } from '@stack-spot/portal-network'
+import { WorkspaceResponse } from '@stack-spot/portal-network/api/workspace-ai'
+import { debounce } from 'lodash'
+import { useCallback, useMemo, useState, useTransition } from 'react'
+import { NavigationComponent } from '../../components/ComponentNavigator'
+import { DescribedRadioGroup } from '../../components/form/DescribedRadioGroup'
+import { WorkspaceTabNavigator } from '../../components/WorkspaceTabNavigator'
+import { useCurrentChat } from '../../context/hooks'
+import { useRightPanel } from '../../right-panel/hooks'
+import { ChatProperties } from '../../state/ChatState'
+import { AgentDescription } from './AgentDescription'
+import { useAgentsDictionary } from './dictionary'
+import { useAgentFavorites } from './useAgentFavorites'
+
+export interface AgentTabProps {
+  visibility?: AgentVisibilityLevel,
+  workspaceId?: string,
+  agent: React.MutableRefObject<ChatProperties['agent']>,
+  showSubmitButton?: boolean,
+}
+
+export const AgentsTab = ({ visibility, workspaceId, agent, showSubmitButton = true }: AgentTabProps) => {
+  const t = useAgentsDictionary()
+  const { close } = useRightPanel()
+  const chat = useCurrentChat()
+  const { useFavorites, onAddFavorite, onRemoveFavorite } = useAgentFavorites()
+  const [submitEnabled, setSubmitEnabled] = useState(false)
+  const listFavorites = useFavorites()
+  const agentDefault = agentToolsClient.agentDefault.useQuery()
+
+  const [filter, setFilter] = useState<string | undefined>()
+  const [apiFilter, setApiFilter] = useState<string | undefined>()
+  const [isPending, startTransition] = useTransition()
+
+  const runOnChange = useCallback(
+    debounce((value?: string) => {
+      startTransition(() => {
+        setApiFilter(value)
+      })
+    }, 500),
+    [startTransition],
+  )
+
+  const data = workspaceAiClient.getAgentFromWorkspaceAi.useStatefulQuery({ workspaceId: workspaceId! },
+    { enabled: !!workspaceId })
+  const workspaceAgents = data?.[0] as AgentResponseWithBuiltIn[]
+
+  const [agentsData = [], { fetchNextPage, hasNextPage }] = agentToolsClient.agentsMultipleFilters.useInfiniteQuery({
+    filters: {
+      page: 1,
+      size: 20,
+      name: apiFilter,
+      ...(visibility?.length ? { visibility_list: [visibility] } : {}),
+    },
+  }, { enabled: !workspaceId })
+
+  const agents = workspaceId ? workspaceAgents : agentsData
+
+  const initialValue = useMemo<AgentResponseWithBuiltIn | undefined>(
+    () => {
+      const initial = agent.current
+        ? agents?.find(a => a.id === agent.current?.id)
+        : chat.get('agent') ? agents?.find(a => a.id === chat.get('agent')?.id) : agentDefault as unknown as AgentResponseWithBuiltIn
+      if (initial && !submitEnabled) setSubmitEnabled(true)
+      return initial
+    },
+    [agents],
+  )
+
+  function submit() {
+    if (agent.current) chat.set('agent', agent.current)
+    close()
+  }
+
+  return <>
+    <div className="content">
+      <DescribedRadioGroup
+        fetchNextPage={fetchNextPage}
+        hasNextPage={hasNextPage && !workspaceId}
+        options={agents}
+        initialValue={initialValue}
+        filter={workspaceId ? undefined : filter}
+        setFilter={workspaceId ? undefined : (value?: string) => {
+          setFilter(value)
+          runOnChange(value)
+        }}
+        onChange={(ag) => {
+          agent.current = ag
+            ? { ...ag, label: ag.name, image: ag.avatar!, slug: ag.slug, builtIn: ag.visibility_level === 'built_in' }
+            : undefined
+          setSubmitEnabled(true)
+        }}
+        isLoading={isPending}
+        data={ag => ({
+          idOrSlug: ag.id,
+          // below, "key" is important. I don't know why exactly, but sometimes the avatar doesn't update if we don't do this.
+          image: <ImageWithFallback key={ag.id} src={ag.avatar ?? undefined} fallback={<Icon icon="Agent" />} />,
+          description: <AgentDescription agentId={ag.id} />,
+          name: ag.name,
+          listFavorites,
+          onAddFavorite,
+          onRemoveFavorite,
+        })}
+        emptyResults={
+          <Placeholder title={t.noSearchResults} description={t.noSearchResultsDescription} className="no-data-placeholder" />
+        }
+        emptyDataset={<Placeholder title={t.noData} description={t.noDataDescription} />}
+      />
+    </div>
+    {!!agents?.length && showSubmitButton && <Button onClick={submit} disabled={!submitEnabled}>{t.apply}</Button>}
+  </>
+}
+
+export function AgentsTabWorkspace({ agent, visibility, showSubmitButton }: AgentTabProps) {
+  const workspaceTabComponents = useMemo(() => ({ agent: AgentsTab }), [agent])
+
+  const buildNavigateParams = (workspace: WorkspaceResponse): NavigationComponent<typeof workspaceTabComponents> => ({
+    component: 'agent',
+    props: { visibility, workspaceId: workspace.id, agent, showSubmitButton },
+  })
+
+  return <WorkspaceTabNavigator components={workspaceTabComponents} getNavigateParam={buildNavigateParams} />
+}

package/src/views/Agents/dictionary.ts

@@ -0,0 +1,45 @@
+import { Dictionary, useTranslate } from '@stack-spot/portal-translate'
+
+const dictionary = {
+  en: {
+    title: 'Agents',
+    subtitle: 'By selecting an Agent, it will be consulted to generate the answers.',
+    personal: 'Personal',
+    builtin: 'Built-in',
+    shared: 'Shared',
+    account: 'Account',
+    apply: 'Apply',
+    noSearchResults: "Your search didn't yield results.",
+    noSearchResultsDescription: 'Please, try another search term.',
+    noData: 'There are no agents in this category yet.',
+    noDataDescription: 'Use the tabs above to try other categories or use the AI portal to create new agents.',
+    defaultAgentDescription: 'The StackSpot CodeGen is an advanced artificial intelligence agent designed to optimize and accelerate software development. Integrated directly into your integrated development environment, StackSpot CodeGen offers real-time code suggestions, helping developers write high-quality code more efficiently. With robust features such as creating Stacks AI, customized knowledge sources, and quick commands, StackSpot CodeGen contextualizes your development needs to provide the best answers and code suggestions.',
+    description: 'Description',
+    favorites: 'Favorites',
+    tools: 'Tools',
+    spots: 'Spots',
+    multiAgent: 'Multi-agents',
+  },
+  pt: {
+    title: 'Agentes',
+    subtitle: 'Ao selecionar um Agente, ele será consultado para gerar as respostas.',
+    personal: 'Pessoal',
+    builtin: 'Embutido',
+    shared: 'Compartilhado',
+    account: 'Conta',
+    apply: 'Aplicar',
+    noSearchResults: 'Sua busca não produziu resultados.',
+    noSearchResultsDescription: 'Por favor, tente outra busca.',
+    noData: 'Ainda não há agentes nesta categoria.',
+    noDataDescription: 'Use as abas acima para tentar outras categorias ou use o Portal AI para criar novos agentes.',
+    defaultAgentDescription: 'O StackSpot CodeGen é um agente de inteligência artificial avançado projetado para otimizar e acelerar o desenvolvimento de software. Integrado diretamente ao seu ambiente de desenvolvimento, o StackSpot CodeGen oferece sugestões de código em tempo real, ajudando os desenvolvedores a escreverem código de alta qualidade de forma mais eficiente. Com recursos robustos, como a criação de Stacks AI, Knowledge Sources personalizadas e comandos rápidos, o StackSpot CodeGen contextualiza suas necessidades de desenvolvimento para fornecer as melhores respostas e sugestões de código.',
+    description: 'Descrição',
+    favorites: 'Favoritos',
+    tools: 'Ferramentas',
+    spots: 'Spots',
+    multiAgent: 'Multi-agents',
+
+  },
+} satisfies Dictionary
+
+export const useAgentsDictionary = () => useTranslate(dictionary)

package/src/views/Agents/index.tsx

@@ -0,0 +1,26 @@
+import { useEffect } from 'react'
+import { useWidget, useWidgetState } from '../../context/hooks'
+import { useRightPanel } from '../../right-panel/hooks'
+import { AgentsPanel } from './AgentsPanel'
+import { useAgentsDictionary } from './dictionary'
+
+/**
+ * Renders the panel to select an agent of this panel is opened.
+ */
+export const Agents = () => {
+  const t = useAgentsDictionary()
+  const panel = useWidgetState('panel')
+  const { open } = useRightPanel()
+  const widget = useWidget()
+
+  useEffect(() => {
+    if (panel === 'agent') open(
+      <AgentsPanel />,
+      { title: t.title, description: t.subtitle, onClose: () => widget.set('panel', undefined) },
+    )
+  }, [panel, t])
+
+  return null
+}
+
+