mitra-interactions-sdk 1.0.60-beta.22 → 1.0.60-beta.24

package/README.md

@@ -244,6 +244,130 @@ const result2 = await listRecordsMitra({
 });
 ```
 
+## Agent Chat (copilot)
+
+Chat com o agente de IA embarcado. **REST-first**: chats, histórico, credenciais e modelos são HTTP no gateway `{origin}/copilot/api/v1` (mesmo domínio da `baseURL`, `Authorization: Bearer`). **Só o prompt é streaming** — um WebSocket por task em `wss://{origin}/copilot/ws/tasks/{taskId}?token=JWT`, aberto pela SDK quando a conversa começa.
+
+Precisa de `token` e `baseURL` configurados (o login já deixa pronto). O transporte do prompt aceita `transport: 'ws' | 'http'` — `'ws'` é o default; `'http'` é reservado pra ambientes serverless e hoje lança erro claro (o backend ainda não expõe prompt por HTTP).
+
+### Gerenciar os chats — `manageAgentChatMitra`
+
+Tudo HTTP: listar (com filtros), renomear e deletar (= arquivar).
+
+```typescript
+import { manageAgentChatMitra } from 'mitra-interactions-sdk';
+
+const chats    = await manageAgentChatMitra({ action: 'list' });                          // AgentChat[]
+const doAgente = await manageAgentChatMitra({ action: 'list', agentId: 'uuid-do-agente' }); // só os chats de um agente business
+const busca    = await manageAgentChatMitra({ action: 'list', search: 'vendas', page: 0, size: 20 });
+const renamed  = await manageAgentChatMitra({ action: 'rename', taskId, name: 'Novo nome' });
+const deleted  = await manageAgentChatMitra({ action: 'delete', taskId }); // arquiva (some da lista default)
+```
+
+- `action: 'list'` → `AgentChat[]` — `{ id, name, agentType, agentId, archived, createdAt, updatedAt }`. Filtros: `agentId?`, `archived?`, `search?`, `page?`, `size?`.
+- `action: 'rename'` → `{ taskId, name }` (PATCH `/tasks/{id}`)
+- `action: 'delete'` → `{ taskId, deleted }` (PATCH `/tasks/{id}/archive` — o histórico não é destruído)
+
+### Abrir uma session — `getAgentTaskMitra`
+
+Retorna uma `AgentTaskSession` que encapsula o ciclo de vida do chat. A task é criada via REST (`POST /tasks`) no primeiro `send()`; o WS da task conecta em seguida. Abrir a mesma `taskId` duas vezes devolve a **mesma** instância (cache).
+
+```typescript
+import { getAgentTaskMitra } from 'mitra-interactions-sdk';
+
+// Chat novo — taskId é preenchido no primeiro send() (evento taskCreated)
+const session = getAgentTaskMitra({ create: true, agentType: 'ANTHROPIC_CLAUDE_OPUS', name: 'Meu chat' });
+
+// Chat com um agente business (system prompt + SFs do agente; token escopado)
+const sales = getAgentTaskMitra({ create: true, agentId: 'uuid-do-agente' });
+
+// Chat existente
+const existing = getAgentTaskMitra({ taskId: 'uuid-da-task' });
+await existing.loadHistory({ limit: 50 });
+```
+
+`getAgentTaskMitra({ create: true, agentType?, name?, agentId?, transport? })` ou `getAgentTaskMitra({ taskId, transport? })`.
+
+- `agentType` vem de `manageAgentCredentialMitra({ action: 'list_models' })` — ex.: `'ANTHROPIC_CLAUDE_OPUS'`, `'OPENAI_GPT5'`, `'GOOGLE_GEMINI_PRO'`. Default: `'ANTHROPIC_CLAUDE_OPUS'`.
+- **`agentId`**: id de um agente business (CRUD via `mitra-sdk`: `listAgentsMitra` e família). A sessão sobe com o system prompt do agente e um token escopado — as tools enxergam só as Server Functions dele. Sem `agentId`, é o chat de desenvolvimento.
+
+#### Propriedades (somente leitura)
+
+| Propriedade | Tipo | Descrição |
+|-------------|------|-----------|
+| `taskId` | `string \| null` | `null` até o primeiro `send()` num chat novo |
+| `task` | `AgentChat \| null` | Metadados do chat |
+| `isNew` | `boolean` | Se foi aberto via `{ create: true }` |
+| `status` | `AgentTaskStatus` | `opening` · `idle` · `streaming` · `cancelled` · `error` · `closed` |
+| `history` | `AgentMessage[]` | Histórico carregado (`{ id, sender, type, content, createdAt }`) |
+| `content` | `string` | Conteúdo acumulado do turno atual |
+| `queue` | `QueuedItem[]` | Mensagens enfileiradas (enviadas enquanto streamava) |
+
+#### Métodos
+
+- `send(prompt)` → `void` — dispara um turno (WS `message`). Se já está streamando, **enfileira** (FIFO, máx 10).
+- `cancel()` → `Promise<void>` — interrompe o turno atual (WS `interrupt`, safety net de 10s).
+- `respondApproval(approved)` → `void` — responde um pedido de aprovação do agente (WS `approval_response`).
+- `loadHistory({ limit? })` → `Promise<AgentMessage[]>` — histórico persistido via REST.
+- `editQueueItem(id, text)` / `removeQueueItem(id)` / `clearQueue()` — manipulam a fila.
+- `on(event, handler)` → função de unsubscribe — assina eventos da session.
+- `close()` — encerra a session, fecha o WS e libera os listeners.
+
+#### Eventos (`session.on`)
+
+`statusChange` · `historyLoaded` · `taskCreated` · `turnStart` · `delta` (`{ delta, kind: 'text' | 'thinking' }`) · `tool` (`{ tool, toolId?, input?, content?, phase: 'call' | 'result' }`) · `turnEnd` (`{ content }`) · `cancelled` · `queueChange` · `error` (`{ code?, error }`) · `raw` (eventos não mapeados do stream, ex.: `workspace`).
+
+```typescript
+const session = getAgentTaskMitra({ create: true });
+
+session.on('delta', ({ delta, kind }) => { if (kind === 'text') process.stdout.write(delta); });
+session.on('tool',  ({ tool, phase }) => console.log('🔧', phase, tool));
+session.on('turnEnd', ({ content }) => console.log('\n✓ fim do turno'));
+session.on('taskCreated', ({ task }) => console.log('chat criado:', task.id));
+session.on('error', ({ error }) => console.error(error));
+
+session.send('Analise estas vendas e gere um resumo');
+```
+
+### Credenciais do agente — `manageAgentCredentialMitra`
+
+Função única, toda HTTP. Providers: `'anthropic'`, `'openai'`, `'google'`. API key via `save`/`remove`; OAuth via `auth`/`connect`; device flow via `device_auth`/`device_poll`.
+
+> 🔒 Tokens/keys nunca voltam crus — o backend devolve só status, e-mail da conta e a key mascarada.
+
+```typescript
+import { manageAgentCredentialMitra } from 'mitra-interactions-sdk';
+
+// Status por provider (pra montar a UI de conexão)
+const { providers } = await manageAgentCredentialMitra({ action: 'list_providers' });
+// AgentCredentialStatus[]: { provider, connected, credentialType, accountEmail, maskedApiKey }
+
+// Modelos selecionáveis → use o agentType em getAgentTaskMitra
+const { models } = await manageAgentCredentialMitra({ action: 'list_models' });
+// AgentModel[]: { model, name, provider, agentType }
+
+// API key
+await manageAgentCredentialMitra({ action: 'save', target: 'openai', key: 'sk-...' });
+await manageAgentCredentialMitra({ action: 'remove', target: 'anthropic' });
+```
+
+OAuth (ex.: Anthropic) — `auth` devolve o que mostrar, `connect` finaliza:
+
+```typescript
+const { authUrl, state } = await manageAgentCredentialMitra({ action: 'auth', target: 'anthropic' });
+// app abre authUrl; usuário autoriza e copia o código
+const { connected, email } = await manageAgentCredentialMitra({ action: 'connect', target: 'anthropic', code, state });
+```
+
+Device flow (ex.: OpenAI) — mostre `userCode` + `verificationUri` e faça polling:
+
+```typescript
+const { deviceAuthId, userCode, verificationUri, intervalSeconds } =
+  await manageAgentCredentialMitra({ action: 'device_auth', target: 'openai' });
+// app mostra: "abra {verificationUri} e digite {userCode}"; depois, a cada intervalSeconds:
+const { connected } = await manageAgentCredentialMitra({ action: 'device_poll', target: 'openai', deviceAuthId });
+```
+
 ## Tipos TypeScript
 
 Todos os tipos estão incluídos:
@@ -254,9 +378,6 @@ import type {
   // Login
   LoginOptions,
   LoginResponse,
-  // Email Auth
-  EmailSignupOptions,
-  EmailLoginOptions,
   // Options
   ExecuteServerFunctionOptions,
   ExecuteServerFunctionAsyncOptions,
@@ -272,7 +393,19 @@ import type {
   ExecuteServerFunctionResponse,
   ExecuteServerFunctionAsyncResponse,
   StopServerFunctionExecutionResponse,
-  ListRecordsResponse
+  ListRecordsResponse,
+  // Agent Chat
+  AgentChat,
+  AgentMessage,
+  AgentTaskSession,
+  AgentTaskStatus,
+  SendOptions,
+  ManageAgentChatOptions,
+  GetAgentTaskOptions,
+  // Agent Credentials
+  ManageAgentCredentialOptions,
+  ListAgentModelsResult,
+  ListAgentProvidersResult
 } from 'mitra-interactions-sdk';
 ```
 

package/dist/index.d.mts

@@ -195,6 +195,246 @@ interface StopServerFunctionExecutionResponse {
         executionStatus: string;
     };
 }
+/**
+ * Tipo/modelo do agente (enum do copilot — vem de list_models).
+ * Ex.: 'ANTHROPIC_CLAUDE_OPUS', 'OPENAI_GPT5', 'GOOGLE_GEMINI_PRO'.
+ */
+type AgentType = 'ANTHROPIC_CLAUDE_OPUS' | 'OPENAI_GPT5' | 'GOOGLE_GEMINI_PRO' | (string & {});
+/** Task/chat do copilot (TaskResponse). `name` espelha o `title` do backend. */
+interface AgentChat {
+    id: string;
+    name: string | null;
+    agentType: AgentType;
+    /** Agente business dono do chat (null = chat de desenvolvimento). */
+    agentId: string | null;
+    archived: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Mensagem persistida (MessageResponse do copilot). */
+interface AgentMessage {
+    id: string;
+    sender: 'USER' | 'AGENT' | (string & {});
+    type: string;
+    content: string;
+    createdAt: string;
+}
+type ChatManageAction = 'list' | 'rename' | 'delete';
+interface ManageAgentChatListOptions {
+    action: 'list';
+    /** Filtra os chats de um agente business específico. Omitido = todos os chats. */
+    agentId?: string;
+    /** Inclui só arquivados (true) ou só ativos (false, default). */
+    archived?: boolean;
+    /** Busca por título. */
+    search?: string;
+    /** Página (0-based, default 0). */
+    page?: number;
+    /** Tamanho da página (default 20). */
+    size?: number;
+}
+interface ManageAgentChatRenameOptions {
+    action: 'rename';
+    taskId: string;
+    name: string;
+}
+interface ManageAgentChatDeleteOptions {
+    action: 'delete';
+    taskId: string;
+}
+type ManageAgentChatOptions = ManageAgentChatListOptions | ManageAgentChatRenameOptions | ManageAgentChatDeleteOptions;
+interface RenameAgentChatResult {
+    taskId: string;
+    name: string;
+}
+/** delete = archive no backend (PATCH /tasks/{id}/archive). O chat some da lista default. */
+interface DeleteAgentChatResult {
+    taskId: string;
+    deleted: boolean;
+}
+/**
+ * Transporte do prompt. 'ws' (default) = streaming via WebSocket.
+ * 'http' = reservado pra ambientes serverless — o backend ainda não expõe
+ * o prompt por HTTP; hoje lança erro claro.
+ */
+type AgentTaskTransport = 'ws' | 'http';
+interface GetAgentTaskCreateOptions {
+    /** Cria chat novo. A task é criada via REST no primeiro send(). */
+    create: true;
+    /** Tipo/modelo do agente (de list_models). Default: 'ANTHROPIC_CLAUDE_OPUS'. */
+    agentType?: AgentType;
+    /** Nome/título do chat. */
+    name?: string;
+    /**
+     * ID de um agente business (CRUD via mitra-sdk: listAgentsMitra e família).
+     * Com agentId, a sessão sobe com o system prompt do agente e um token escopado —
+     * as tools enxergam só as Server Functions daquele agente. Sem agentId, é o
+     * chat de desenvolvimento de sempre.
+     */
+    agentId?: string;
+    /** Transporte do prompt (default 'ws'). */
+    transport?: AgentTaskTransport;
+}
+interface GetAgentTaskOpenOptions {
+    /** Abre chat existente. */
+    taskId: string;
+    /** Transporte do prompt (default 'ws'). */
+    transport?: AgentTaskTransport;
+}
+type GetAgentTaskOptions = GetAgentTaskCreateOptions | GetAgentTaskOpenOptions;
+type AgentTaskStatus = 'opening' | 'idle' | 'streaming' | 'cancelled' | 'error' | 'closed';
+interface QueuedItem {
+    id: string;
+    text: string;
+    seq: number;
+    createdAt: number;
+    status: 'pending' | 'sending';
+}
+interface SendOptions {
+    /** Reservado (o modelo/agentType é fixado na criação da task). */
+    _reserved?: never;
+}
+interface AgentDeltaEvent {
+    delta: string;
+    kind: 'text' | 'thinking';
+}
+interface AgentToolEvent {
+    /** Nome da tool (toolCall/toolResult). */
+    tool: string;
+    toolId?: string;
+    input?: unknown;
+    /** Presente no toolResult. */
+    content?: unknown;
+    phase: 'call' | 'result';
+    timestamp: number;
+}
+interface AgentTurnEndEvent {
+    content: string;
+}
+interface AgentTaskCreatedEvent {
+    task: AgentChat;
+}
+interface AgentErrorEvent {
+    code?: string;
+    error: string;
+}
+interface AgentQueueChangeEvent {
+    queue: QueuedItem[];
+}
+interface AgentStatusChangeEvent {
+    status: AgentTaskStatus;
+}
+/** Evento cru do WS que a SDK não mapeia (ex.: workspace, approvalRequest). */
+interface AgentRawEvent {
+    type: string;
+    payload: unknown;
+    timestamp: number;
+}
+interface AgentTaskEventMap {
+    statusChange: AgentStatusChangeEvent;
+    historyLoaded: {
+        history: AgentMessage[];
+    };
+    taskCreated: AgentTaskCreatedEvent;
+    turnStart: Record<string, never>;
+    delta: AgentDeltaEvent;
+    tool: AgentToolEvent;
+    turnEnd: AgentTurnEndEvent;
+    cancelled: Record<string, never>;
+    queueChange: AgentQueueChangeEvent;
+    error: AgentErrorEvent;
+    raw: AgentRawEvent;
+}
+type AgentTaskEventName = keyof AgentTaskEventMap;
+interface AgentTaskSession {
+    readonly taskId: string | null;
+    readonly task: AgentChat | null;
+    readonly isNew: boolean;
+    readonly status: AgentTaskStatus;
+    readonly history: AgentMessage[];
+    readonly content: string;
+    readonly queue: QueuedItem[];
+    /** Dispara um turno (fire-and-forget; resultado via eventos). Se streaming, enfileira. */
+    send(prompt: string, options?: SendOptions): void;
+    /** Interrompe o turno atual (WS interrupt). */
+    cancel(): Promise<void>;
+    /** Responde um pedido de aprovação do agente (evento raw approvalRequest). */
+    respondApproval(approved: boolean): void;
+    /** Carrega o histórico persistido (REST GET messages). */
+    loadHistory(options?: {
+        limit?: number;
+    }): Promise<AgentMessage[]>;
+    editQueueItem(id: string, text: string): void;
+    removeQueueItem(id: string): void;
+    clearQueue(): void;
+    on<E extends AgentTaskEventName>(event: E, handler: (payload: AgentTaskEventMap[E]) => void): () => void;
+    close(): void;
+}
+/** Providers do copilot. */
+type AgentProvider = 'anthropic' | 'openai' | 'google';
+type CredentialAction = 'list_providers' | 'list_models' | 'save' | 'remove' | 'auth' | 'connect' | 'device_auth' | 'device_poll';
+/** GET /credentials — status por provider. */
+interface AgentCredentialStatus {
+    provider: string;
+    connected: boolean;
+    credentialType: string | null;
+    accountEmail: string | null;
+    maskedApiKey: string | null;
+}
+/** GET /models — modelo selecionável (o value usável é `agentType`). */
+interface AgentModel {
+    model: string;
+    name: string;
+    provider: string;
+    agentType: AgentType;
+}
+interface ListAgentProvidersResult {
+    providers: AgentCredentialStatus[];
+}
+interface ListAgentModelsResult {
+    models: AgentModel[];
+}
+interface AuthAgentCredentialResult {
+    authUrl: string;
+    state: string;
+}
+interface ConnectAgentCredentialResult {
+    connected: boolean;
+    email: string | null;
+}
+interface DeviceAuthAgentCredentialResult {
+    deviceAuthId: string;
+    userCode: string;
+    verificationUri: string;
+    intervalSeconds: number;
+}
+type ManageAgentCredentialOptions = {
+    action: 'list_providers';
+} | {
+    action: 'list_models';
+} | {
+    action: 'save';
+    target: AgentProvider;
+    key: string;
+} | {
+    action: 'remove';
+    target: AgentProvider;
+} | {
+    action: 'auth';
+    target: AgentProvider;
+} | {
+    action: 'connect';
+    target: AgentProvider;
+    code: string;
+    state: string;
+} | {
+    action: 'device_auth';
+    target: AgentProvider;
+} | {
+    action: 'device_poll';
+    target: AgentProvider;
+    deviceAuthId: string;
+};
 
 /**
  * Mitra Interactions SDK - Instance
@@ -219,6 +459,9 @@ interface MitraInstance {
     patchRecord(options: PatchRecordOptions): Promise<Record<string, any>>;
     deleteRecord(options: DeleteRecordOptions): Promise<void>;
     createRecordsBatch(options: CreateRecordsBatchOptions): Promise<Record<string, any>[]>;
+    getAgentTask(options: GetAgentTaskOptions): AgentTaskSession;
+    manageAgentChat(options: ManageAgentChatOptions): Promise<unknown>;
+    manageAgentCredential(options: ManageAgentCredentialOptions): Promise<unknown>;
 }
 declare function createMitraInstance(initialConfig: Partial<MitraConfig>): MitraInstance;
 
@@ -282,6 +525,96 @@ declare function exchangeSsoCodeMitra(options: {
     state: string;
 }): Promise<LoginResponse>;
 
+/**
+ * Mitra Interactions SDK — Agent Chat (copilot novo mundo)
+ *
+ * REST-first: chats (tasks), histórico, credenciais e modelos são HTTP no
+ * gateway `{origin}/copilot/api/v1`. SÓ o prompt é streaming — WebSocket por
+ * task em `{origin}/copilot/ws/tasks/{taskId}?token=JWT`.
+ *
+ * API pública:
+ *   - manageAgentChatMitra({ action: 'list' | 'rename' | 'delete', ... })
+ *   - getAgentTaskMitra({ create | taskId, ... })
+ */
+
+/**
+ * Gerencia a coleção de chats do usuário — tudo HTTP:
+ *   - list   → GET /copilot/api/v1/tasks (filtros: agentId, archived, search, page, size)
+ *   - rename → PATCH /copilot/api/v1/tasks/{id}
+ *   - delete → PATCH /copilot/api/v1/tasks/{id}/archive (arquiva; some da lista default)
+ *
+ * @example
+ * const chats = await manageAgentChatMitra({ action: 'list' });
+ * const doAgente = await manageAgentChatMitra({ action: 'list', agentId: 'uuid' });
+ * await manageAgentChatMitra({ action: 'rename', taskId, name: 'Novo nome' });
+ * await manageAgentChatMitra({ action: 'delete', taskId });
+ */
+declare function manageAgentChatMitra(options: ManageAgentChatListOptions): Promise<AgentChat[]>;
+declare function manageAgentChatMitra(options: ManageAgentChatRenameOptions): Promise<RenameAgentChatResult>;
+declare function manageAgentChatMitra(options: ManageAgentChatDeleteOptions): Promise<DeleteAgentChatResult>;
+/**
+ * Abre um handle de chat (session). Use:
+ *   - `{ create: true }` para iniciar um chat novo (a task é criada via REST no 1º send)
+ *   - `{ taskId: 'X' }` para abrir um chat existente
+ *
+ * A session expõe histórico, streaming, fila, cancel e eventos. Se a
+ * mesma taskId for aberta duas vezes, retorna a MESMA instância (cache).
+ */
+declare function getAgentTaskMitra(options: GetAgentTaskOptions): AgentTaskSession;
+
+/**
+ * Mitra Interactions SDK — Agent Credentials (copilot novo mundo)
+ *
+ * Função ÚNICA `manageAgentCredentialMitra`, toda HTTP no gateway
+ * `{origin}/copilot/api/v1`:
+ *   - list_providers → GET  /credentials
+ *   - list_models    → GET  /models
+ *   - save           → PUT  /credentials/{provider}/api-key
+ *   - remove         → DELETE /credentials/{provider}
+ *   - auth           → POST /oauth/start           (OAuth: { authUrl, state })
+ *   - connect        → POST /oauth/exchange        (OAuth: { code, state })
+ *   - device_auth    → POST /credentials/{provider}/device-authorizations
+ *   - device_poll    → POST /credentials/{provider}/device-authorizations/{id}/poll
+ *
+ * SEGURANÇA: tokens/keys nunca voltam crus — o backend devolve só status,
+ * e-mail da conta e a key mascarada.
+ */
+
+declare function manageAgentCredentialMitra(options: {
+    action: 'list_providers';
+}): Promise<ListAgentProvidersResult>;
+declare function manageAgentCredentialMitra(options: {
+    action: 'list_models';
+}): Promise<ListAgentModelsResult>;
+declare function manageAgentCredentialMitra(options: {
+    action: 'save';
+    target: AgentProvider;
+    key: string;
+}): Promise<void>;
+declare function manageAgentCredentialMitra(options: {
+    action: 'remove';
+    target: AgentProvider;
+}): Promise<void>;
+declare function manageAgentCredentialMitra(options: {
+    action: 'auth';
+    target: AgentProvider;
+}): Promise<AuthAgentCredentialResult>;
+declare function manageAgentCredentialMitra(options: {
+    action: 'connect';
+    target: AgentProvider;
+    code: string;
+    state: string;
+}): Promise<ConnectAgentCredentialResult>;
+declare function manageAgentCredentialMitra(options: {
+    action: 'device_auth';
+    target: AgentProvider;
+}): Promise<DeviceAuthAgentCredentialResult>;
+declare function manageAgentCredentialMitra(options: {
+    action: 'device_poll';
+    target: AgentProvider;
+    deviceAuthId: string;
+}): Promise<ConnectAgentCredentialResult>;
+
 /**
  * Mitra Interactions SDK - Services
  */
@@ -337,4 +670,4 @@ declare function patchRecordMitra(options: PatchRecordOptions): Promise<Record<s
 declare function deleteRecordMitra(options: DeleteRecordOptions): Promise<void>;
 declare function createRecordsBatchMitra(options: CreateRecordsBatchOptions): Promise<Record<string, any>[]>;
 
-export { type CallIntegrationOptions, type CallIntegrationResponse, type CreateRecordOptions, type CreateRecordsBatchOptions, type DeleteRecordOptions, type ExecutePublicServerFunctionAsyncResponse, type ExecutePublicServerFunctionOptions, type ExecutePublicServerFunctionResponse, type ExecuteServerFunctionAsyncOptions, type ExecuteServerFunctionAsyncResponse, type ExecuteServerFunctionOptions, type ExecuteServerFunctionResponse, type GetPublicServerFunctionExecutionOptions, type GetPublicServerFunctionExecutionResponse, type GetRecordOptions, type IntegrationResponse, type ListIntegrationsOptions, type ListRecordsOptions, type ListRecordsResponse, type LoginOptions, type LoginResponse, type MitraConfig, type MitraInstance, type PatchRecordOptions, type StopServerFunctionExecutionOptions, type StopServerFunctionExecutionResponse, type UpdateRecordOptions, callIntegrationMitra, configureSdkMitra, createMitraInstance, createRecordMitra, createRecordsBatchMitra, deleteRecordMitra, exchangeSsoCodeMitra, executePublicServerFunctionAsyncMitra, executePublicServerFunctionMitra, executeServerFunctionAsyncMitra, executeServerFunctionMitra, getConfig, getPublicServerFunctionExecutionMitra, getRecordMitra, listIntegrationsMitra, listRecordsMitra, loginMitra, loginWithGoogleMitra, loginWithMicrosoftMitra, patchRecordMitra, refreshTokenSilently, resolveProjectId, stopServerFunctionExecutionMitra, updateRecordMitra };
+export { type AgentChat, type AgentCredentialStatus, type AgentDeltaEvent, type AgentErrorEvent, type AgentMessage, type AgentModel, type AgentProvider, type AgentQueueChangeEvent, type AgentRawEvent, type AgentStatusChangeEvent, type AgentTaskCreatedEvent, type AgentTaskEventMap, type AgentTaskEventName, type AgentTaskSession, type AgentTaskStatus, type AgentTaskTransport, type AgentToolEvent, type AgentTurnEndEvent, type AgentType, type AuthAgentCredentialResult, type CallIntegrationOptions, type CallIntegrationResponse, type ChatManageAction, type ConnectAgentCredentialResult, type CreateRecordOptions, type CreateRecordsBatchOptions, type CredentialAction, type DeleteAgentChatResult, type DeleteRecordOptions, type DeviceAuthAgentCredentialResult, type ExecutePublicServerFunctionAsyncResponse, type ExecutePublicServerFunctionOptions, type ExecutePublicServerFunctionResponse, type ExecuteServerFunctionAsyncOptions, type ExecuteServerFunctionAsyncResponse, type ExecuteServerFunctionOptions, type ExecuteServerFunctionResponse, type GetAgentTaskCreateOptions, type GetAgentTaskOpenOptions, type GetAgentTaskOptions, type GetPublicServerFunctionExecutionOptions, type GetPublicServerFunctionExecutionResponse, type GetRecordOptions, type IntegrationResponse, type ListAgentModelsResult, type ListAgentProvidersResult, type ListIntegrationsOptions, type ListRecordsOptions, type ListRecordsResponse, type LoginOptions, type LoginResponse, type ManageAgentChatDeleteOptions, type ManageAgentChatListOptions, type ManageAgentChatOptions, type ManageAgentChatRenameOptions, type ManageAgentCredentialOptions, type MitraConfig, type MitraInstance, type PatchRecordOptions, type QueuedItem, type RenameAgentChatResult, type SendOptions, type StopServerFunctionExecutionOptions, type StopServerFunctionExecutionResponse, type UpdateRecordOptions, callIntegrationMitra, configureSdkMitra, createMitraInstance, createRecordMitra, createRecordsBatchMitra, deleteRecordMitra, exchangeSsoCodeMitra, executePublicServerFunctionAsyncMitra, executePublicServerFunctionMitra, executeServerFunctionAsyncMitra, executeServerFunctionMitra, getAgentTaskMitra, getConfig, getPublicServerFunctionExecutionMitra, getRecordMitra, listIntegrationsMitra, listRecordsMitra, loginMitra, loginWithGoogleMitra, loginWithMicrosoftMitra, manageAgentChatMitra, manageAgentCredentialMitra, patchRecordMitra, refreshTokenSilently, resolveProjectId, stopServerFunctionExecutionMitra, updateRecordMitra };