@agentforge-io/sdk-server 4.0.18

package/dist/resources/chat.js

@@ -0,0 +1,180 @@
+"use strict";
+// chat resource — dos superficies distintas bajo un mismo nombre:
+//   - `createAnthropicClient()`: passthrough crudo al proxy Anthropic
+//     (`/api/v1/anthropic`), sin tool-calling ni persistencia de conversación.
+//   - `streamMessage()` / `getHistory()`: el chat AGENT-AWARE de
+//     chat-stream.controller.ts (`/api/v1/chat/*`) — resuelve connectors +
+//     tools 'remote' del agent, persiste la conversación, hace streaming SSE
+//     con tool-calling completo. Es lo que corre detrás de cualquier chat
+//     "de verdad" con un agent (SOP Architect, Finance Team, etc).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatResource = void 0;
+class ChatResource {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Devuelve una instancia de `Anthropic` (de @anthropic-ai/sdk) preconfigurada
+     * para hablar contra el proxy del platform.
+     *
+     * **Pre-req:** la app cliente tiene `@anthropic-ai/sdk` como dep regular y
+     * el `AgentForgeClient` se construyó con `apiKey` (ak_live_) además del
+     * chatToken.
+     *
+     * @example
+     *   const anthropic = await af.chat.createAnthropicClient();
+     *   const msg = await anthropic.messages.create({ ... });
+     */
+    async createAnthropicClient(opts = {}) {
+        const apiKey = this.client.getApiKey();
+        if (!apiKey) {
+            throw new Error('chat.createAnthropicClient requires apiKey (ak_live_) in AgentForgeClient. ' +
+                'Pass it alongside chatToken when constructing the client.');
+        }
+        let Anthropic;
+        try {
+            // Lazy import — @anthropic-ai/sdk es optionalDependency.
+            Anthropic = require('@anthropic-ai/sdk').default ?? require('@anthropic-ai/sdk');
+        }
+        catch {
+            throw new Error('@anthropic-ai/sdk is required for chat.createAnthropicClient. ' +
+                'Install it in the app: yarn add @anthropic-ai/sdk');
+        }
+        return new Anthropic({
+            apiKey,
+            baseURL: `${this.client.baseURL}/api/v1/anthropic`,
+            defaultHeaders: opts.anthropicVersion
+                ? { 'anthropic-version': opts.anthropicVersion }
+                : undefined,
+        });
+    }
+    /**
+     * Chat streaming AGENT-AWARE — `POST /api/v1/chat/messages/stream`. Auth:
+     * ChatToken (scoped al agent). Resuelve connectors del tenant + tools
+     * 'remote' registradas del agent automáticamente; el caller solo manda
+     * `content`.
+     *
+     * Yieldea `ChatStreamEvent` tipados en vez de frames SSE crudos — ver
+     * el tipo para el detalle de cada `kind`.
+     *
+     * @example
+     *   let conversationId: string | undefined;
+     *   for await (const ev of af.chat.streamMessage({ content: 'hola' })) {
+     *     if (ev.kind === 'conversation') conversationId = ev.conversationId;
+     *     else if (ev.kind === 'chunk' && ev.chunk.type === 'text_delta') {
+     *       process.stdout.write(ev.chunk.delta);
+     *     }
+     *   }
+     */
+    async *streamMessage(input) {
+        const res = await this.client.requestStream('POST', '/api/v1/chat/messages/stream', {
+            content: input.content,
+            ...(input.conversationId ? { conversationId: input.conversationId } : {}),
+        });
+        if (!res.body) {
+            throw new Error('chat.streamMessage: response has no readable body');
+        }
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            for (;;) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                let idx;
+                while ((idx = buffer.indexOf('\n\n')) !== -1) {
+                    const frame = buffer.slice(0, idx);
+                    buffer = buffer.slice(idx + 2);
+                    const raw = parseRawSseFrame(frame);
+                    if (!raw)
+                        continue;
+                    const event = toChatStreamEvent(raw);
+                    if (event)
+                        yield event;
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    /**
+     * Historial completo de una conversación — `GET
+     * /api/v1/chat/conversations/:id/messages`. Útil para "resumir" un chat
+     * tras un refresh de página cuando el `conversationId` se guardó (ej. en
+     * la URL). Tira `AgentForgeNotFoundError` si la conversación no existe o
+     * no pertenece al ChatToken que llama.
+     */
+    async getHistory(conversationId) {
+        return this.client.request('GET', `/api/v1/chat/conversations/${encodeURIComponent(conversationId)}/messages`);
+    }
+}
+exports.ChatResource = ChatResource;
+/** Frame SSE genérico: `event: <name>\ndata: <line>\ndata: <line>...`.
+ *  `event:` es opcional en el estándar SSE (default 'message') — acá SIEMPRE
+ *  viene, pero el fallback no hace daño. */
+function parseRawSseFrame(frame) {
+    let event = 'message';
+    const dataLines = [];
+    for (const line of frame.split('\n')) {
+        if (line.startsWith('event:'))
+            event = line.slice(6).trim();
+        else if (line.startsWith('data:'))
+            dataLines.push(line.slice(5).replace(/^ /, ''));
+    }
+    if (dataLines.length === 0)
+        return null;
+    return { event, data: dataLines.join('\n') };
+}
+/**
+ * Mapea un frame SSE crudo al `ChatStreamEvent` tipado. Ver chat-stream.
+ * controller.ts: `event: conversation` y `event: error` son frames propios
+ * del controller (no vienen de StreamChunk); todo lo demás es
+ * `writeSse(chunk.type, chunk)` — el `event:` name coincide con `chunk.type`,
+ * y el `data:` payload YA trae ese mismo `type` adentro, así que basta con
+ * mirar `data.type` para reconstruir el chunk (no hace falta el nombre del
+ * evento). La excepción es el frame final `event: done` / `data: {ok:true}`
+ * que cierra la conexión HTTP — se distingue de `StreamChunk`'s propio
+ * `{type:'done', messageId}` por la AUSENCIA de `.type`.
+ */
+function toChatStreamEvent(frame) {
+    if (frame.event === 'conversation') {
+        try {
+            const parsed = JSON.parse(frame.data);
+            if (parsed.conversationId) {
+                return { kind: 'conversation', conversationId: parsed.conversationId };
+            }
+        }
+        catch {
+            /* malformed frame — drop it, the stream continues */
+        }
+        return null;
+    }
+    if (frame.event === 'error') {
+        try {
+            const parsed = JSON.parse(frame.data);
+            return { kind: 'error', message: parsed.message ?? 'Unknown error' };
+        }
+        catch {
+            return { kind: 'error', message: frame.data };
+        }
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(frame.data);
+    }
+    catch {
+        return null;
+    }
+    if (parsed && typeof parsed === 'object') {
+        if ('type' in parsed) {
+            return { kind: 'chunk', chunk: parsed };
+        }
+        if ('ok' in parsed) {
+            return { kind: 'stream_end', ok: Boolean(parsed.ok) };
+        }
+    }
+    return null;
+}

package/dist/resources/connectors.d.ts

@@ -0,0 +1,200 @@
+import type { AgentForgeClient } from '../client';
+import type { ConnectorDefaultsResult, ConnectorStatus, CreateClickupTaskInput, CreateClickupTaskResult, ListConnectorResourcesResult, ToolPermission } from '../types';
+export declare class ConnectorsResource {
+    private readonly client;
+    constructor(client: AgentForgeClient);
+    /**
+     * `GET /connector-resources` — TODOS los connectors que el platform
+     * soporta, cada uno con su estado real de conexión para este tenant.
+     * Incluye los NO conectados para poder ofrecer "Conectar" inline.
+     *
+     * @example
+     *   const { items } = await af.connectors.listConnected();
+     *   const unconnected = items.filter((c) => !c.connected);
+     */
+    listConnected(): Promise<{
+        items: ConnectorStatus[];
+    }>;
+    /**
+     * `GET /connector-resources/:connectorId` — recursos reales del connector
+     * (canales de Slack, repos de GitHub, listas de ClickUp, archivos de
+     * Drive…). Si el connector está conectado pero no tiene selector
+     * implementado todavía, devuelve `{ items: [], unsupported: true }` en vez
+     * de tirar — no es un error, es un estado a mostrar en la UI.
+     */
+    listResources(connectorId: string): Promise<ListConnectorResourcesResult>;
+    /**
+     * `POST /connectors/oauth/:id/authorize-for-tenant` — arranca el OAuth
+     * authorize del connector para el tenant del ak_live_ (sin sesión de
+     * dashboard). Devuelve la URL a abrir (ej. `window.open` en el frontend) —
+     * el flujo de callback lo maneja el platform de punta a punta.
+     *
+     * @example
+     *   const { url } = await af.connectors.authorizeForTenant('slack', {
+     *     postAuthRedirect: 'https://myapp.com/settings',
+     *   });
+     */
+    authorizeForTenant(connectorId: string, opts?: {
+        postAuthRedirect?: string;
+    }): Promise<{
+        url: string;
+    }>;
+    /**
+     * `DELETE /connector-resources/:connectorId` — desconecta el connector
+     * para el tenant del ak_live_, borrando la autorización guardada.
+     * Idempotente: llamarlo sobre un connector ya desconectado no falla.
+     * Tras esto, `listConnected()` refleja `connected: false` y el usuario
+     * puede volver a llamar `authorizeForTenant()` para reconectar desde cero
+     * (útil cuando el token quedó revocado del lado del proveedor o el
+     * usuario quiere cambiar de cuenta).
+     *
+     * @example
+     *   await af.connectors.disconnect('google-drive');
+     */
+    disconnect(connectorId: string): Promise<{
+        ok: true;
+    }>;
+    /**
+     * `POST /connector-resources/clickup/tasks` — crea una tarea REAL en
+     * ClickUp para el tenant del ak_live_. Sin gobernanza propia: el caller
+     * (ej. el confirm de una propuesta "propose_clickup_task" en ScrappyDoc)
+     * es responsable de solo invocar esto tras una confirmación humana
+     * explícita.
+     *
+     * @example
+     *   const task = await af.connectors.createClickupTask({
+     *     listId: '901234',
+     *     name: 'Revisar contrato Q3',
+     *   });
+     */
+    createClickupTask(input: CreateClickupTaskInput): Promise<CreateClickupTaskResult>;
+    /**
+     * `GET /connector-resources/:connectorId/defaults` — reglas de tenant
+     * (permisos por tool: allow/approval/blocked) para este connector, más la
+     * lista de tools que el connector expone. Mismo mecanismo de 3 niveles que
+     * usa el dashboard de agentforge-platform (`ConnectorDefaultsService.resolve`):
+     * override del tenant → template del autor del connector → fallback allow-all.
+     */
+    getDefaults(connectorId: string): Promise<ConnectorDefaultsResult>;
+    /**
+     * `PUT /connector-resources/:connectorId/defaults` — sobrescribe las
+     * reglas de tenant para este connector. El caller es responsable de
+     * gatear quién puede llamar esto (ej. solo admin/owner del workspace) —
+     * el server valida cada nombre de tool contra el registry pero no impone
+     * ningún rol propio más allá de la ak_live_ tenant-wide.
+     */
+    updateDefaults(connectorId: string, permissions: ToolPermission[]): Promise<{
+        ok: true;
+    }>;
+    postSlackMessage(input: {
+        channelId: string;
+        text: string;
+    }): Promise<{
+        ok: true;
+        ts?: string;
+        permalink?: string;
+    }>;
+    /**
+     * `GET /connectors/oauth/:id/oauth-app` — indica si el tenant del
+     * ak_live_ ya trajo su propia OAuth app para `connectorId` (Slack,
+     * HubSpot, GitHub, Notion, o cualquier otro connector OAuth del
+     * catálogo — el server valida genéricamente contra el registry, no
+     * hay lista fija) en vez de depender de la app de instancia del
+     * platform. Nunca devuelve el secret, solo un hint del clientId para
+     * mostrar en UI.
+     *
+     * @example
+     *   const { configured } = await af.connectors.getOAuthApp('slack');
+     */
+    getOAuthApp(connectorId: string): Promise<{
+        configured: boolean;
+        clientIdHint?: string;
+        updatedAt?: string;
+    }>;
+    /**
+     * `POST /connectors/oauth/:id/oauth-app` — registra la OAuth app propia
+     * del tenant para `connectorId` (cualquier connector OAuth del catálogo:
+     * Slack, HubSpot, GitHub, Notion, etc.), sin pasar por el dashboard de
+     * agentforge-platform. Útil cuando ScrappyDoc (u otro producto externo)
+     * ya tiene su propia app y no quiere compartir la app de instancia del
+     * platform con otros tenants/productos.
+     *
+     * Efecto inmediato: el próximo `authorizeForTenant(connectorId)` usa
+     * estas credenciales — no hace falta reiniciar nada del lado del platform.
+     *
+     * `hostApp` (opcional): además de guardar bajo el tenant del ak_live_
+     * actual, espeja estas credenciales bajo un scope compartido por TODO ese
+     * host app (ej. 'scrappydoc') — así cualquier tenant per-(workspace,user)
+     * que ese host provisione después vía `POST /platform/host-tenants`
+     * hereda automáticamente esta OAuth app, sin volver a configurarla por
+     * tenant. Solo tiene sentido pasarlo desde el tenant GLOBAL del host (el
+     * dueño del ak_live_ fijo, no un tenant per-usuario) — el server rechaza
+     * el reclamo si otro tenant ya se adjudicó ese hostApp antes.
+     *
+     * @example
+     *   await af.connectors.setOAuthApp('slack', {
+     *     clientId: '123456.789',
+     *     clientSecret: 'abcdef...',
+     *     hostApp: 'scrappydoc',
+     *   });
+     */
+    setOAuthApp(connectorId: string, input: {
+        clientId: string;
+        clientSecret: string;
+        hostApp?: string;
+    }): Promise<{
+        configured: true;
+    }>;
+    /**
+     * `GET /connectors/inbox/agents/:agentId/inbox/channels` — canales del
+     * inbox omnicanal (WhatsApp, Instagram, Slack bot, etc.) ya conectados
+     * para `agentId`, sin sesión de dashboard de agentforge-platform (el
+     * `ak_live_` tenant-wide alcanza — el server valida que `agentId`
+     * pertenezca a este tenant).
+     *
+     * @example
+     *   const { items } = await af.connectors.listInboxChannels(agentId);
+     */
+    listInboxChannels(agentId: string): Promise<{
+        items: InboxChannelView[];
+    }>;
+    /**
+     * `POST /connectors/inbox/agents/:agentId/inbox/channels` — conecta un
+     * canal del inbox omnicanal para `agentId` (ej. `providerId: 'slack-bot'`
+     * con `credentials: { signingSecret, botUserId? }` — ver
+     * `SlackBotProvider.credentialsForm` en agentforge-platform para el shape
+     * exacto de cada provider).
+     *
+     * @example
+     *   await af.connectors.createInboxChannel(agentId, {
+     *     providerId: 'slack-bot',
+     *     credentials: { signingSecret: '8f742...' },
+     *   });
+     */
+    createInboxChannel(agentId: string, input: {
+        providerId: string;
+        label?: string;
+        credentials: Record<string, unknown>;
+    }): Promise<InboxChannelView>;
+    /**
+     * `DELETE /connectors/inbox/agents/:agentId/inbox/channels/:channelId` —
+     * desconecta un canal del inbox omnicanal.
+     */
+    destroyInboxChannel(agentId: string, channelId: string): Promise<void>;
+}
+export interface InboxChannelView {
+    id: string;
+    tenantId: string;
+    agentId?: string;
+    providerId: string;
+    label?: string;
+    externalIdentity?: string;
+    status: string;
+    lastError?: string;
+    lastSeenAt?: string;
+    displayName?: string;
+    username?: string;
+    avatarUrl?: string;
+    createdAt: string;
+    updatedAt: string;
+}

package/dist/resources/connectors.js

@@ -0,0 +1,192 @@
+"use strict";
+// connectors resource — selector de recursos estilo Gemini para apps
+// externas (ver ResourcePickerController / HostConnectorsController en el
+// server): lista los connectors del tenant + su estado, navega los recursos
+// reales de uno conectado (canales de Slack, repos de GitHub, etc), y arranca
+// el OAuth authorize para uno que falte conectar.
+//
+// Auth: SIEMPRE ak_live_ tenant-wide — estos 3 endpoints usan `ApiKeyGuard`
+// en el server y rechazan ChatToken de plano, aunque el `AgentForgeClient`
+// también tenga uno configurado (ver `requestWithApiKey`).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectorsResource = void 0;
+class ConnectorsResource {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * `GET /connector-resources` — TODOS los connectors que el platform
+     * soporta, cada uno con su estado real de conexión para este tenant.
+     * Incluye los NO conectados para poder ofrecer "Conectar" inline.
+     *
+     * @example
+     *   const { items } = await af.connectors.listConnected();
+     *   const unconnected = items.filter((c) => !c.connected);
+     */
+    async listConnected() {
+        return this.client.requestWithApiKey('GET', '/connector-resources');
+    }
+    /**
+     * `GET /connector-resources/:connectorId` — recursos reales del connector
+     * (canales de Slack, repos de GitHub, listas de ClickUp, archivos de
+     * Drive…). Si el connector está conectado pero no tiene selector
+     * implementado todavía, devuelve `{ items: [], unsupported: true }` en vez
+     * de tirar — no es un error, es un estado a mostrar en la UI.
+     */
+    async listResources(connectorId) {
+        return this.client.requestWithApiKey('GET', `/connector-resources/${encodeURIComponent(connectorId)}`);
+    }
+    /**
+     * `POST /connectors/oauth/:id/authorize-for-tenant` — arranca el OAuth
+     * authorize del connector para el tenant del ak_live_ (sin sesión de
+     * dashboard). Devuelve la URL a abrir (ej. `window.open` en el frontend) —
+     * el flujo de callback lo maneja el platform de punta a punta.
+     *
+     * @example
+     *   const { url } = await af.connectors.authorizeForTenant('slack', {
+     *     postAuthRedirect: 'https://myapp.com/settings',
+     *   });
+     */
+    async authorizeForTenant(connectorId, opts) {
+        const qs = opts?.postAuthRedirect
+            ? `?postAuthRedirect=${encodeURIComponent(opts.postAuthRedirect)}`
+            : '';
+        return this.client.requestWithApiKey('POST', `/connectors/oauth/${encodeURIComponent(connectorId)}/authorize-for-tenant${qs}`);
+    }
+    /**
+     * `DELETE /connector-resources/:connectorId` — desconecta el connector
+     * para el tenant del ak_live_, borrando la autorización guardada.
+     * Idempotente: llamarlo sobre un connector ya desconectado no falla.
+     * Tras esto, `listConnected()` refleja `connected: false` y el usuario
+     * puede volver a llamar `authorizeForTenant()` para reconectar desde cero
+     * (útil cuando el token quedó revocado del lado del proveedor o el
+     * usuario quiere cambiar de cuenta).
+     *
+     * @example
+     *   await af.connectors.disconnect('google-drive');
+     */
+    async disconnect(connectorId) {
+        return this.client.requestWithApiKey('DELETE', `/connector-resources/${encodeURIComponent(connectorId)}`);
+    }
+    /**
+     * `POST /connector-resources/clickup/tasks` — crea una tarea REAL en
+     * ClickUp para el tenant del ak_live_. Sin gobernanza propia: el caller
+     * (ej. el confirm de una propuesta "propose_clickup_task" en ScrappyDoc)
+     * es responsable de solo invocar esto tras una confirmación humana
+     * explícita.
+     *
+     * @example
+     *   const task = await af.connectors.createClickupTask({
+     *     listId: '901234',
+     *     name: 'Revisar contrato Q3',
+     *   });
+     */
+    async createClickupTask(input) {
+        return this.client.requestWithApiKey('POST', '/connector-resources/clickup/tasks', input);
+    }
+    /**
+     * `GET /connector-resources/:connectorId/defaults` — reglas de tenant
+     * (permisos por tool: allow/approval/blocked) para este connector, más la
+     * lista de tools que el connector expone. Mismo mecanismo de 3 niveles que
+     * usa el dashboard de agentforge-platform (`ConnectorDefaultsService.resolve`):
+     * override del tenant → template del autor del connector → fallback allow-all.
+     */
+    async getDefaults(connectorId) {
+        return this.client.requestWithApiKey('GET', `/connector-resources/${encodeURIComponent(connectorId)}/defaults`);
+    }
+    /**
+     * `PUT /connector-resources/:connectorId/defaults` — sobrescribe las
+     * reglas de tenant para este connector. El caller es responsable de
+     * gatear quién puede llamar esto (ej. solo admin/owner del workspace) —
+     * el server valida cada nombre de tool contra el registry pero no impone
+     * ningún rol propio más allá de la ak_live_ tenant-wide.
+     */
+    async updateDefaults(connectorId, permissions) {
+        return this.client.requestWithApiKey('PUT', `/connector-resources/${encodeURIComponent(connectorId)}/defaults`, { permissions });
+    }
+    async postSlackMessage(input) {
+        return this.client.requestWithApiKey('POST', '/connector-resources/slack/messages', input);
+    }
+    /**
+     * `GET /connectors/oauth/:id/oauth-app` — indica si el tenant del
+     * ak_live_ ya trajo su propia OAuth app para `connectorId` (Slack,
+     * HubSpot, GitHub, Notion, o cualquier otro connector OAuth del
+     * catálogo — el server valida genéricamente contra el registry, no
+     * hay lista fija) en vez de depender de la app de instancia del
+     * platform. Nunca devuelve el secret, solo un hint del clientId para
+     * mostrar en UI.
+     *
+     * @example
+     *   const { configured } = await af.connectors.getOAuthApp('slack');
+     */
+    async getOAuthApp(connectorId) {
+        return this.client.requestWithApiKey('GET', `/connectors/oauth/${encodeURIComponent(connectorId)}/oauth-app`);
+    }
+    /**
+     * `POST /connectors/oauth/:id/oauth-app` — registra la OAuth app propia
+     * del tenant para `connectorId` (cualquier connector OAuth del catálogo:
+     * Slack, HubSpot, GitHub, Notion, etc.), sin pasar por el dashboard de
+     * agentforge-platform. Útil cuando ScrappyDoc (u otro producto externo)
+     * ya tiene su propia app y no quiere compartir la app de instancia del
+     * platform con otros tenants/productos.
+     *
+     * Efecto inmediato: el próximo `authorizeForTenant(connectorId)` usa
+     * estas credenciales — no hace falta reiniciar nada del lado del platform.
+     *
+     * `hostApp` (opcional): además de guardar bajo el tenant del ak_live_
+     * actual, espeja estas credenciales bajo un scope compartido por TODO ese
+     * host app (ej. 'scrappydoc') — así cualquier tenant per-(workspace,user)
+     * que ese host provisione después vía `POST /platform/host-tenants`
+     * hereda automáticamente esta OAuth app, sin volver a configurarla por
+     * tenant. Solo tiene sentido pasarlo desde el tenant GLOBAL del host (el
+     * dueño del ak_live_ fijo, no un tenant per-usuario) — el server rechaza
+     * el reclamo si otro tenant ya se adjudicó ese hostApp antes.
+     *
+     * @example
+     *   await af.connectors.setOAuthApp('slack', {
+     *     clientId: '123456.789',
+     *     clientSecret: 'abcdef...',
+     *     hostApp: 'scrappydoc',
+     *   });
+     */
+    async setOAuthApp(connectorId, input) {
+        return this.client.requestWithApiKey('POST', `/connectors/oauth/${encodeURIComponent(connectorId)}/oauth-app`, input);
+    }
+    /**
+     * `GET /connectors/inbox/agents/:agentId/inbox/channels` — canales del
+     * inbox omnicanal (WhatsApp, Instagram, Slack bot, etc.) ya conectados
+     * para `agentId`, sin sesión de dashboard de agentforge-platform (el
+     * `ak_live_` tenant-wide alcanza — el server valida que `agentId`
+     * pertenezca a este tenant).
+     *
+     * @example
+     *   const { items } = await af.connectors.listInboxChannels(agentId);
+     */
+    async listInboxChannels(agentId) {
+        return this.client.requestWithApiKey('GET', `/connectors/inbox/agents/${encodeURIComponent(agentId)}/inbox/channels`);
+    }
+    /**
+     * `POST /connectors/inbox/agents/:agentId/inbox/channels` — conecta un
+     * canal del inbox omnicanal para `agentId` (ej. `providerId: 'slack-bot'`
+     * con `credentials: { signingSecret, botUserId? }` — ver
+     * `SlackBotProvider.credentialsForm` en agentforge-platform para el shape
+     * exacto de cada provider).
+     *
+     * @example
+     *   await af.connectors.createInboxChannel(agentId, {
+     *     providerId: 'slack-bot',
+     *     credentials: { signingSecret: '8f742...' },
+     *   });
+     */
+    async createInboxChannel(agentId, input) {
+        return this.client.requestWithApiKey('POST', `/connectors/inbox/agents/${encodeURIComponent(agentId)}/inbox/channels`, input);
+    }
+    /**
+     * `DELETE /connectors/inbox/agents/:agentId/inbox/channels/:channelId` —
+     * desconecta un canal del inbox omnicanal.
+     */
+    async destroyInboxChannel(agentId, channelId) {
+        await this.client.requestWithApiKey('DELETE', `/connectors/inbox/agents/${encodeURIComponent(agentId)}/inbox/channels/${encodeURIComponent(channelId)}`);
+    }
+}
+exports.ConnectorsResource = ConnectorsResource;

package/dist/resources/secrets.d.ts

@@ -0,0 +1,44 @@
+import type { AgentForgeClient } from '../client';
+import type { TenantSecretEntry } from '../types';
+export declare class SecretsResource {
+    private readonly client;
+    constructor(client: AgentForgeClient);
+    /**
+     * `GET /tenant-secrets` — metadata de TODOS los secrets company-scoped que
+     * este tenant ha configurado. Nunca devuelve el valor en claro, solo
+     * `valueHint` (últimos 4 chars) y flags — suficiente para renderizar una
+     * lista "configurado / no configurado" en la UI de la app hija.
+     *
+     * @example
+     *   const { items } = await af.secrets.list();
+     *   const configured = items.filter((s) => s.configured);
+     */
+    list(): Promise<{
+        items: TenantSecretEntry[];
+    }>;
+    /**
+     * `PUT /tenant-secrets/:key` — crea o sobrescribe UN secret company-scoped
+     * para este tenant. El valor viaja cifrado al vault del platform; la
+     * respuesta trae solo metadata (nunca el valor en claro). La `key` debe
+     * matchear `/^[A-Z][A-Z0-9_]*$/` (mayúsculas, dígitos, guión bajo; empieza
+     * con letra) — el server responde 400 si no.
+     *
+     * El caller es responsable de gatear quién puede llamar esto (ej. solo
+     * admin/owner del workspace) — el server no impone rol propio más allá de
+     * la ak_live_ tenant-wide.
+     *
+     * @example
+     *   await af.secrets.set('OPENAI_API_KEY', 'sk-...');
+     */
+    set(key: string, value: string): Promise<TenantSecretEntry>;
+    /**
+     * `DELETE /tenant-secrets/:key` — borra el override company-scoped de este
+     * tenant para `key`. No toca el valor 'instance' de la plataforma (si lo
+     * hubiera): tras esto, la resolución en runtime cae al fallback de
+     * plataforma. Devuelve 204 (sin body).
+     *
+     * @example
+     *   await af.secrets.remove('OPENAI_API_KEY');
+     */
+    remove(key: string): Promise<void>;
+}