diff --git a/content/docs/configuration/channel_gateway.mdx b/content/docs/configuration/channel_gateway.mdx new file mode 100644 index 000000000..df827a8c3 --- /dev/null +++ b/content/docs/configuration/channel_gateway.mdx @@ -0,0 +1,357 @@ +--- +title: Slack Channel Gateway (Beta) +description: Deploy the Slack gateway for organization workspaces or a manually configured connection. +icon: MessagesSquare +--- + +Run the Slack gateway alongside LibreChat to connect agents to Slack. This guide covers deployment. Once the gateway is ready, follow [Agent Channels](/docs/features/agent_channels) to connect a Slack app, assign an agent, and link your account. + +Choose a setup path: + +- **Organization workspaces:** [run one shared gateway](#organization-workspaces), then manage Slack apps in LibreChat. +- **Manual connection:** [bind a gateway to one connection](#run-the-slack-gateway). + +Using Helm? Go to [Kubernetes and Helm](#kubernetes-and-helm). Building from source? See [From source](#from-source). + + +Use matching LibreChat and gateway releases that include Channels. Ordinary LibreChat does not need the gateway; enabling Channels requires a transaction-capable database and the indexes described below. + + +## Configuration and prerequisites + +Both setup paths need the following. In shared mode, one gateway serves multiple installations while each person keeps their own account and tool credentials: + +- A verified transaction-capable database with the indexes below. +- Role permissions to use Agents and query them through Remote Agents (API) for participants, plus Agent sharing or administrator management access for setup. Sharing does not require permission to edit the Agent. +- API-key authentication enabled for the gateway's bound execution credential. +- A private `CHANNEL_SERVICE_TOKEN` with the same value in the API and gateway. Keep it server-side. It authenticates the gateway, and cannot be used as a browser token or general Agent API key. +- A trusted `DOMAIN_CLIENT` for account-link and owner-review URLs. Organization workspaces also require the public HTTPS addresses described below. + +Linking an account does not grant Agent access, new tools or offline access to connected services. See the [channel configuration reference](/docs/configuration/librechat_yaml/object_structure/agents#channels) for policy limits and defaults. + +### Database requirement + +Check your database before enabling Channels. Durable Channels and stored background Responses need both **transactions** and the required indexes, including **partial indexes**. + +| Database | What this means for setup | +| --- | --- | +| MongoDB replica set or another verified transaction-capable deployment | Check that the required indexes are supported too. | +| Standalone MongoDB or FerretDB 2.7 | Can run LibreChat without this durable feature. A different database setup is needed for Channels and stored background Responses. | +| Amazon DocumentDB 4.0 | [Partial indexes are not supported](https://docs.aws.amazon.com/documentdb/latest/devguide/indexes-single-field.html), so it cannot run this gateway. | + +Other MongoDB-compatible engines need compatibility validation before use. Unsupported channel writes return `transactions_unavailable`, and the Agent Builder explains the setup requirement. Transactional reads use the primary even when your connection normally prefers secondary reads. + +## Organization workspaces + +Use this mode for organization-owned Slack apps managed in LibreChat. An operator deploys one shared gateway; organization administrators then register apps and install workspaces through [Account settings](/docs/features/agent_channels#organization-workspaces). Each app supports one active workspace. No per-workspace gateway process or deployment secret is needed. + +### One-time operator setup + + + + +**Prepare the database and service token.** Meet the [prerequisites](#configuration-and-prerequisites), including transaction-capable MongoDB. Generate a private service token with `openssl rand -hex 32` and use the same value in the API and gateway. + + + + +**Set the public addresses.** Configure public HTTPS `DOMAIN_SERVER` and `DOMAIN_CLIENT` in `.env`, replacing the localhost defaults. Both are required. Include the application base path when present and remove any surrounding whitespace. + +If callbacks use a separate public origin, set `SLACK_GATEWAY_URL` to it. Otherwise callbacks use `DOMAIN_SERVER`. The shared deployment opt-in rejects local addresses. + + + + +**Route Slack callbacks to the gateway.** Forward `/slack/events/` and `/slack/interactions/`, including their organization/app suffixes. If callbacks use `DOMAIN_SERVER`, route those paths on the application origin to the gateway too. + +The gateway container listens on port 8080. The shared Compose overlay publishes it at `127.0.0.1:3081` for a host-level HTTPS proxy. + +Route the application and OAuth callback to LibreChat. Keep gateway health and metrics private. This deployment step does not need Slack dashboard access or app credentials. + + + + +For Docker Compose with a separate gateway origin, add these values to your `.env` file. Keep the file out of version control: + +```dotenv filename=".env" +SLACK_GATEWAY_URL=https://slack.example.com +CHANNEL_SERVICE_TOKEN= +DOMAIN_SERVER=https://chat.example.com +DOMAIN_CLIENT=https://chat.example.com +LIBRECHAT_IMAGE_TAG= +``` + + +The command below includes the replica overlay for a fresh local database. Read [Existing local data](#existing-local-data) before converting an existing installation. For a verified external database, omit that overlay and supply your normal connection configuration. + + +With `.env` and `librechat.yaml` prepared, start the release-matched application and shared gateway: + +```sh +docker compose -f docker-compose.yml -f docker-compose.channels.yml \ + -f docker-compose.slack-workspaces.yml -f docker-compose.mongo-replica.yml \ + --profile channels up -d api meilisearch channel-gateway +``` + +Use the same Compose project and files for subsequent commands. + +You still need to configure your HTTPS proxy and trusted certificate. A host-level proxy forwards the two Slack paths to `http://127.0.0.1:3081`, preserving the organization/app suffixes. Set `CHANNEL_GATEWAY_PORT` in `.env` to change that loopback port. A proxy in the same Compose network can forward to `http://channel-gateway:8080` instead. + +The shared overlay supplies `SLACK_WORKSPACES_ENABLED=true`, which enables webhook Channels, shared app installation and stored background Responses while retaining unrelated YAML policy, limits and explicit API authentication settings. Slack app credentials are entered by organization admins through the UI and stored encrypted; they are not deployment environment variables or YAML fields. With the flag unset or false, YAML continues to control the feature. Choosing shared setup changes the deployment's channel transport to webhook; existing bound connections must use matching webhook configuration. Manual Socket Mode remains available when using the manual setup instead. + +No `CHANNEL_ID`, `CHANNEL_TENANT_ID` or app-level `SLACK_APP_TOKEN` is needed in shared mode. The gateway receives its service token and private runtime policy; app client credentials stay in LibreChat, and installed bot tokens are encrypted in the database. For an unreleased source checkout, add `docker-compose.channels-build.yml` after `docker-compose.channels.yml` on every command and use `up -d --build` instead of expecting an unpublished release image. + +Before connecting Slack, [check gateway readiness](#verify-the-gateway). Then continue with [app registration](/docs/features/agent_channels#organization-workspaces). + +## Run the Slack gateway + +Use this manual setup for one tenant and connection. First enable Channels and background Responses in `librechat.yaml`; both default to `false`: + +```yaml filename="endpoints / agents" +endpoints: + agents: + remoteApi: + background: + enabled: true + channels: + enabled: true + transport: socket_mode +``` + +The `transport` option accepts `socket_mode` (default) or `webhook`. Manual connections generate a matching Slack manifest; organization workspaces use the [webhook setup above](#organization-workspaces). Selecting a transport does not deploy a receiver. Webhook manifests require an HTTPS `gatewayUrl` without credentials, a query, or a fragment. The gateway loads this policy from LibreChat before selecting ingress. `SLACK_TRANSPORT` is an optional deployment assertion; if supplied, it must match the server-selected mode. Missing or unsupported gateway policy prevents startup. + +Create and activate the [manual Slack connection](/docs/features/agent_channels#set-up-a-manual-slack-app-connection) before starting its gateway. The connection ID is needed below. For a container deployment, skip to [Docker Compose](#docker-compose); a source process requires Node.js 24+. + +### From source + +The gateway uses Slack's official Node SDKs and calls LibreChat over HTTP. It does not connect directly to MongoDB. In shared mode, the same source entry point works without the bound tenant/connection IDs or app-level token; supply the internal API URL and service token instead. + +From a LibreChat source checkout containing `packages/channel-gateway`: + +```sh +npm ci +npm run build:packages +npm run build --workspace @librechat/channel-gateway +node --env-file=/secure/channel-gateway.env packages/channel-gateway/dist/main.cjs +``` + +`npm run backend:dev` starts only LibreChat; it does not start the gateway. Build the application using LibreChat's normal development setup and run the gateway separately. If you reuse the application's `.env`, set the gateway port explicitly: `PORT=8080 node --env-file=.env packages/channel-gateway/dist/main.cjs`. This avoids binding the gateway to the application's port. + +Supply the environment file through your normal secret-management process. Do not commit it. A Socket Mode configuration is: + +```dotenv filename="channel-gateway.env" +LIBRECHAT_INTERNAL_URL=http://127.0.0.1:3080 +CHANNEL_SERVICE_TOKEN= +CHANNEL_TENANT_ID=_ +CHANNEL_ID= +SLACK_TRANSPORT=socket_mode +SLACK_APP_TOKEN= +``` + +`LIBRECHAT_INTERNAL_URL` must be reachable from the gateway process. For example, `127.0.0.1` refers to the gateway's own container when running inside a container. Use the exact tenant ID for a multi-tenant deployment; use `_` only for a single-tenant deployment without a tenant ID. The gateway obtains the bot token and signing secret from LibreChat's authenticated connection bundle, so those values do not need separate gateway environment variables. + +For Socket Mode, enable Socket Mode for the same Slack app and create an app-level token with `connections:write`. Keep that token only in the gateway's secret configuration. No public callback URL is needed, but the gateway needs outbound access to Slack and LibreChat. + +For webhooks, set `SLACK_TRANSPORT=webhook` instead and omit `SLACK_APP_TOKEN`. Put the gateway behind HTTPS and set these Slack request URLs, replacing the placeholders with the configured, URL-encoded IDs: + +```text +Events: https://gateway.example.com/slack/events// +Interactivity: https://gateway.example.com/slack/interactions// +``` + +The webhook receiver verifies Slack signatures using the connection's signing secret. Keep LibreChat's channel service routes private to trusted integrations. Expose only the required Slack callback paths publicly; keep health and metrics endpoints on an internal network. + +### Docker Compose + +The optional `docker-compose.channels.yml` overlay pulls release-matched LibreChat and gateway images. Set `LIBRECHAT_IMAGE_TAG` in `.env` to the release tag you are installing (including `-rcN` for a release candidate); both images use that same tag. If omitted, both use the latest stable release. Images are published for Linux AMD64 and ARM64 when the corresponding LibreChat release is published. A tag predating Agent Channels does not contain a gateway image. The separate `docker-compose.mongo-replica.yml` overlay initializes a single local MongoDB replica member and waits for a writable primary before the application starts. The gateway waits for application health, then authenticates its channel binding and selected Slack transport. Neither service is added to the default stack automatically. + +For a **fresh local database**, run these commands from the LibreChat repository root: + +1. Prepare `.env` and `librechat.yaml` using the normal LibreChat setup and the channel policy above. Set `LIBRECHAT_IMAGE_TAG` to the published LibreChat release containing Channels. Generate a private service token with `openssl rand -hex 32` and set `CHANNEL_SERVICE_TOKEN` in `.env`. Keep the same Compose files and project name on subsequent commands. +2. Pull and start the application and its dependencies: + + ```sh + docker compose -f docker-compose.yml -f docker-compose.channels.yml \ + -f docker-compose.mongo-replica.yml up -d --pull always api meilisearch + ``` + +3. Sign in, save an Agent, and [set up its Slack channel](/docs/features/agent_channels#set-up-a-manual-slack-app-connection). Enter the bot token in the Agent builder. Set `CHANNEL_ID` in `.env` to the resulting connection ID. `CHANNEL_TENANT_ID` defaults to `_` for an ordinary OSS installation; supply the actual tenant ID for a tenant-scoped installation. For Socket Mode, also set `SLACK_APP_TOKEN` to the matching app-level token with `connections:write`. +4. Start the gateway: + + ```sh + docker compose -f docker-compose.yml -f docker-compose.channels.yml \ + -f docker-compose.mongo-replica.yml --profile channels up -d --pull always channel-gateway + ``` + +5. Check readiness and startup errors: + + ```sh + docker compose -f docker-compose.yml -f docker-compose.channels.yml \ + -f docker-compose.mongo-replica.yml --profile channels ps -a + docker compose -f docker-compose.yml -f docker-compose.channels.yml \ + -f docker-compose.mongo-replica.yml --profile channels logs --tail=100 api mongodb-init channel-gateway + ``` + +`mongodb-init` exiting with status 0 is expected. Check that the application and gateway are running and healthy. Missing service/app bindings prevent gateway startup. + +Activation checks your Slack credentials. Check gateway readiness too, then [link your account](/docs/features/agent_channels#account-linking) and send the bot a new request to test the connection. + +The overlay points `LIBRECHAT_INTERNAL_URL` at `http://api:${PORT:-3080}` on the Compose network. The gateway listens on container port `8080`, with no published host ports. Socket Mode needs no inbound port; webhooks need an HTTPS reverse proxy forwarding the required callback paths to `channel-gateway:8080`. The gateway runs as a non-root user with a read-only filesystem and dropped capabilities. + +For an existing external transaction-capable database, omit the local MongoDB replica overlay and provide the application connection through your normal Compose override. The base Compose file sets the API service's `MONGO_URI`, so changing only `.env` does not replace that service environment entry. Never run the local initializer against an external database. + +A separate gateway environment file can be supplied through `--env-file .env --env-file /secure/channel-gateway.env`. Keep `CHANNEL_SERVICE_TOKEN` identical in LibreChat's own `.env`; Compose substitution does not update the file mounted into the application. + +For development or an unreleased checkout, add `-f docker-compose.channels-build.yml` immediately after `-f docker-compose.channels.yml` on **every** Compose command. This explicitly builds both services from the checkout instead of using release images. Use `up -d --build` instead of `up -d --pull always` on that path. The normal release path needs no local Node.js installation or image build. + +To build only the gateway image, use the repository root as its build context: + +```sh +docker build -f packages/channel-gateway/Dockerfile \ + -t librechat-channel-gateway:local . +``` + +#### Existing local data + +Back up the database, stop LibreChat and every gateway/worker that writes to it, then stop the database before applying the replica overlay. Retain the existing `data-node` directory; do not delete it or remove its volume. Start with that same data directory and the overlays above. Initialization preserves existing documents and only initializes an unconfigured local `rs0` member at `mongodb:27017`. It refuses a different replica configuration rather than silently reconfiguring it. Verify existing users/history before enabling the gateway, and retain the overlay on future restarts. + +A single local replica member enables transactions but does not provide high availability. The overlay follows the base development Compose authentication/network settings; it is not a production replica-set recipe. For authenticated, multi-member or production deployments, use the [MongoDB conversion procedure](https://www.mongodb.com/docs/manual/tutorial/convert-standalone-to-replica-set/) and your deployment's backup/security practices. + +### Gateway settings + +| Environment variable | Default | Purpose | +| --- | --- | --- | +| `PORT` | `8080` | Gateway HTTP port | +| `LISTEN_HOST` | `0.0.0.0` | Listen address; use loopback for a host-only local process | +| `LIBRECHAT_INTERNAL_URL` | `http://localhost:3080` | LibreChat service origin | +| `CHANNEL_SERVICE_TOKEN` | Required | Shared server-side service-boundary token | +| `CHANNEL_TENANT_ID` | Required in manual mode | Exact connection tenant; `_` for single-tenant deployments | +| `CHANNEL_ID` | Required in manual mode | Connection ID, not the Slack channel ID or Agent ID | +| `SLACK_TRANSPORT` | Server policy | Optional assertion: `webhook` or `socket_mode`; must match the server policy | +| `SLACK_APP_TOKEN` | Required for Socket Mode | App-level token for the same Slack app | +| `APP_TITLE` | `LibreChat` | Application name in browser-review button labels, such as “Open in LibreChat” | +| `API_CALL_TIMEOUT_MS` | `10000` | Timeout for individual service and Slack API calls | +| `AGENT_INVOKE_TIMEOUT_MS` | `120000` | Timeout for initial background Response submission, not the full Agent run | + +`SLACK_API_BASE_URL` defaults to `https://slack.com/api/`; leave it unchanged outside controlled tests. Ingress mode, native sessions, lifecycle reactions, signature tolerance and reconnect pacing come from `endpoints.agents.channels` in `librechat.yaml`, not process feature flags. Actor-bound durable execution cannot be disabled. + +## Verify the gateway + +Check readiness before moving on to Slack setup. The gateway exposes these internal endpoints: + +| Endpoint | What it checks | +| --- | --- | +| `/livez` | The HTTP process is alive. | +| `/readyz`, `/healthz` | Startup and transport readiness. | +| `/metrics` | Prometheus metrics. | + +Keep these routes private. Use the same deployment configuration for readiness checks and logs that you used to start the gateway. For shared Compose, include `docker-compose.slack-workspaces.yml` and any database/build overlays too. + +If the ingress mode or Socket app binding does not match, the gateway reports unready. Restart gateway replicas after changing the ingress mode or Socket app identity. + +Activation checks your Slack credentials. To test the complete connection, [link your account](/docs/features/agent_channels#account-linking), then send the bot a new request. + +If gateway requests to LibreChat return `401`, check that both processes use the same `CHANNEL_SERVICE_TOKEN` and that `LIBRECHAT_INTERNAL_URL` reaches the intended instance. This is separate from Slack callback signature verification. + +To stop the optional gateway, use the same Compose project and file list with `stop channel-gateway`, or disable `channelGateway.enabled` in Helm and remove the shared API opt-in. Keep the database configuration: stopping the gateway does not require converting or removing its data. + +### Native Agent UI and final replies + +By default, Slack shows a working message with **Stop** and, when needed, **Review** controls while the agent runs. The final answer is posted after generation. + +Replies can include code, tables, links, file attachments, and time and cost details when available. Missing costs are not estimated. + +To opt into Slack's native Agent sessions, enable Agent mode in the Slack app, add the `assistant:write` bot scope, and verify that `agent_session_stopped` is subscribed. Add that event if missing; the generated manual manifest already includes it, while the [basic organization setup](/docs/features/agent_channels#register-an-organizations-slack-app) does not. Reinstall the app, then set `endpoints.agents.channels.nativeSessions: true` in `librechat.yaml`. Without the required permissions or Stop subscription, the gateway falls back to durable progress controls. See [Slack Agent sessions](https://docs.slack.dev/ai/agent-sessions/) for app configuration. + +Native sessions show processing or waiting-for-input status and return to active when the run finishes. Completed answers can include Helpful/Not helpful controls. Optional lifecycle reactions use `endpoints.agents.channels.lifecycleReactions: true`, are separate from native sessions and require the reaction permissions already listed in the basic bot scopes. Neither an acknowledgement nor a reaction proves a tool completed; Stop requests cancellation of the sender's authorized work, not another participant's run. + +## Kubernetes and Helm + +The LibreChat Helm chart supports shared workspaces and manual connections. Both require a transaction-capable database; the default standalone database cannot run Channels. See [Helm configuration](/docs/local/helm_chart) for the application's environment, credentials and database setup. + +Enabling the gateway requires an explicit `image.tag` selecting a published LibreChat release containing Channels; the chart refuses to silently use its older application-version default. The gateway image tag defaults to that same selected release. Earlier releases have no gateway image. A custom `channelGateway.image.tag` is available for deliberate image overrides. + +### Shared workspace deployment + +Select a release containing organization workspaces and provide an existing Secret with `CHANNEL_SERVICE_TOKEN`. The service token is shared with LibreChat. No Slack app credentials belong in this Secret: organization admins register their apps in the UI after deployment. Existing explicit API environment entries take precedence over the generated service-token reference. + +The example below selects a replica set for a **fresh bundled MongoDB**. For an existing standalone database, plan and complete its data migration before changing topology; a Helm value does not migrate existing data. For an external transaction-capable database, supply its connection through your normal application configuration and disable the unused bundled database with `mongodb.enabled: false`. Shared mode refuses to render when LibreChat would use a bundled standalone MongoDB; existing external connection overrides remain supported. + +```yaml filename="shared-workspace-values.yaml" +image: + tag: +mongodb: + architecture: replicaset +channelGateway: + enabled: true + mode: shared + replicaCount: 2 + existingSecretName: gateway-service-credentials + ingress: + enabled: true + host: slack.example.com + tls: + - hosts: [slack.example.com] + secretName: slack-gateway-tls +``` + +Set public HTTPS `DOMAIN_SERVER` and `DOMAIN_CLIENT` through the application's normal environment settings. Shared mode supplies the app enablement flag and derives `SLACK_GATEWAY_URL` from its ingress host unless explicitly configured in `librechat.configEnv`. It omits connection IDs, tenant IDs and the Socket Mode token. Shared replicas use rolling updates and the existing durable claims; `mode: single` requires one replica and uses replacement updates. After deployment, organization admins register their apps and configure the displayed Slack URLs through Account settings, then use Agent Builder; no per-workspace Helm values or pods are required. + +### Manual connection deployment + +First upgrade the application to a published release containing Channels with the gateway disabled. Configure the [manual channel policy](#run-the-slack-gateway), then create and activate the connection in the Agent builder. Enable the gateway after obtaining its connection ID: + +```yaml filename="channel-values.yaml" +image: + tag: +channelGateway: + enabled: true + channelId: + tenantId: "_" + # Defaults to global.librechat.existingSecretName. + existingSecretName: librechat-credentials-env +``` + +To set the name used in gateway messages, configure `channelGateway.appTitle`. It defaults to `librechat.configEnv.APP_TITLE`, then `LibreChat`. Set it explicitly if the API obtains `APP_TITLE` through a Secret or `global.librechat.env`. + +The gateway title must: + +- Be nonempty after trimming. +- Have at most 40 UTF-16 characters. +- Contain no `<`, `>`, `|` or control characters. + +If the application name does not fit, choose a shorter gateway title. Helm rejects incompatible inherited titles before deployment; the application can keep its existing longer name. + +For manual Socket Mode, the existing Secret must contain `CHANNEL_SERVICE_TOKEN` matching LibreChat's server configuration and `SLACK_APP_TOKEN` for the matching app. By default, the application's existing Secret supplies the same service token to LibreChat. The gateway references only these individual keys, not all provider/database credentials. If you choose a separate gateway Secret, keep its service token identical to the API's. Rotate through your normal secret-management process and restart the API and gateway after rotation; changing an existing Secret does not automatically restart pods. + +The gateway derives the API URL from the chart's internal Service and port. Override `channelGateway.internalUrl` for a deliberately different service boundary. Configure gateway resources and annotations through `channelGateway`. Pod identity, `enableServiceLinks`, DNS, host aliases, image pull secrets, node selectors, tolerations and affinity follow the chart's shared platform settings. The configured ServiceAccount is reused while the gateway keeps its Kubernetes API token automount disabled. Manual single mode installs one gateway with replacement updates, so an upgrade may briefly interrupt Slack connectivity; it does not create another channel or Slack app. + +For webhook transport, set the server policy to `webhook`, configure its public HTTPS gateway URL and clear `channelGateway.slackAppTokenKey`. Enable the dedicated gateway Ingress using your installed ingress controller and a trusted TLS certificate: + +```yaml filename="channel-values.yaml" +channelGateway: + slackAppTokenKey: "" + ingress: + enabled: true + host: gateway.example.com + # Empty inherits ingress.className; set this for a different controller. + className: nginx + annotations: {} + tls: + - hosts: [gateway.example.com] + secretName: gateway-tls +``` + +Combine these settings with the enabled gateway and explicit application release above. Set the server's `gatewayUrl` to `https://gateway.example.com`, with no path prefix. The new Ingress routes only `/slack/events` and `/slack/interactions` to the gateway Service on port 8080; its health and metrics routes remain private. It can share the application's hostname: the more specific Slack paths route to the gateway while the existing application Ingress keeps its own backend. Gateway annotations are separate so application rewrite rules cannot silently change callback paths. The gateway Ingress requires Kubernetes 1.19+. + +The chart does not install an ingress controller or issue a TLS certificate. Configure TLS through the example Secret, your normal certificate controller/annotations, or an existing HTTPS termination layer. Slack needs a publicly trusted HTTPS endpoint. If you manage a separate external Ingress or need a custom base-path rewrite, leave `channelGateway.ingress.enabled: false` and route the callback paths to the rendered gateway Service yourself; do not add them as paths on the main application Ingress, whose backend is LibreChat. Socket Mode needs no public ingress. + +By default, the gateway runs without an automatically mounted Kubernetes API token, as a non-root user with a read-only filesystem and dropped capabilities. The chart's global pod/container security contexts are honored for platform-specific overrides. Gateway version labels follow its selected image tag. `/livez` drives liveness and `/readyz` drives readiness. Startup before the API or channel is available fails closed; Kubernetes retries the process, and it becomes ready after validating the shared app policy or its bound active connection and transport. + +After the Helm upgrade, check the gateway Deployment, pod events, logs and readiness. Missing Secret keys block pod startup; incorrect credentials or channel bindings prevent readiness. + +Once it is ready, connect the Slack app, assign an agent, and [link your account](/docs/features/agent_channels#account-linking). Send the bot a new request to test the complete setup. + +## Next steps + +[Connect a Slack app and assign an agent](/docs/features/agent_channels#organization-workspaces), then finish setup with a real Slack message. See the [gateway reference](/docs/configuration/channel_gateway_reference) for rich-message formatting, service routes and delivery recovery. diff --git a/content/docs/configuration/channel_gateway_reference.mdx b/content/docs/configuration/channel_gateway_reference.mdx new file mode 100644 index 000000000..998ead015 --- /dev/null +++ b/content/docs/configuration/channel_gateway_reference.mdx @@ -0,0 +1,180 @@ +--- +title: Channel Gateway Reference (Beta) +description: Rich-message formatting, service routes, and delivery recovery for gateway operators and integrators. +icon: Network +--- + + +Agent Channels and the gateway protocol are beta. Use a matching LibreChat and gateway release. + + +Use this reference when building a gateway integration or investigating delivery behavior. It covers rich-message formatting and the private API used by the [Slack channel gateway](/docs/configuration/channel_gateway). + +For app setup and everyday use, start with [Agent Channels](/docs/features/agent_channels). + +## Terms used in this reference + +| Term | Meaning | +| --- | --- | +| Response | The agent execution and result tracked by the Responses API. | +| Run | The channel's record of a request, its execution and its delivery. | +| Actor | The Slack participant making the request. Their linked account determines their access. | +| Lease | A worker's time-limited claim on a run. | +| Fence | The `{ runId, owner, epoch }` values used to reject writes from a stale worker. | +| Delivery receipt | The record of an external write attempt and its outcome. | + +## Rich Agent messages + +An Agent can return semantic presentation data in its final answer. The gateway validates the document and converts it deterministically to Slack Block Kit; it does not accept arbitrary Slack JSON, callback IDs, approval controls, file identifiers or modal definitions. Ordinary Markdown remains unchanged. This works in both ordinary threads and native Agent sessions, without a new OAuth scope or a configuration migration. + +To enable this behavior for an Agent, add the following to its instructions using the existing Agent editor (or include it in a request when testing): + +> When a chart, table, image or card would help, write a short readable answer followed by exactly one final, top-level fenced code block named `librechat-presentation`. Its JSON must be `{ "version": 1, "blocks": [...] }`. Use only the semantic components described below; never emit raw Slack blocks or interactive callback IDs. Use ordinary Markdown for other answers. Use public HTTPS URLs for images and links. The gateway generates complete text fallbacks from the data, so do not repeat every value in the introductory answer. + +For example, ask the Agent to compare the following measured results and show both a chart and a table. Its final answer can be: + +````text +Latency fell from 20 ms to 17 ms. + +```librechat-presentation +{ + "version": 1, + "blocks": [ + { + "type": "chart", + "title": "Latency", + "chart": { + "type": "line", + "axis_config": { "categories": ["Mon", "Tue"], "y_label": "ms" }, + "series": [{ "name": "p95", "data": [{ "label": "Mon", "value": 20 }, { "label": "Tue", "value": 17 }] }] + } + }, + { "type": "table", "title": "Measurements", "columns": ["Day", "p95 (ms)"], "rows": [["Mon", 20], ["Tue", 17]] } + ] +} +``` +```` + +| Semantic component | Fields and constraints | +| ----------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| `text`, `header`, `context`, `code` | `text` string; maximum 3000, 150, 2000 and 3000 Unicode characters respectively. Text components use literal text, so mentions cannot grant interaction authority. Use ordinary Markdown outside the document for formatted prose. | +| `divider` | No additional fields. | +| `image` | `url`, `alt`, optional `title` (150 characters). HTTPS URLs only; alt text is required (2000 characters). The gateway never fetches remote media. | +| `card` | Required `title` (150), optional `subtitle` (150), `body` (200), `image: {url, alt}`, and up to three `links: [{label, url}]`. Labels are at most 75 characters. Links navigate only; they cannot run an Agent action. | +| `carousel` | `cards`: 1–10 cards. | +| `table` | `title` (150), `columns`: 1–20 labels (150 each), `rows`: 1–200 rectangular rows of strings or finite numbers. Maximum 20,000 characters across cells including headers. Numeric cells retain numeric sorting. | +| `chart` | `title` (50), `chart` as described below. | +| `container` | `title` (150), `blocks`: 1–10 text, header, context, code, divider or image components. | +| `layout` | `title` (150), `rows`: 1–5 arrays of 1–3 components, including containers. Charts, tables and carousels each occupy their own row. Layouts cannot nest. The gateway makes the title visible and generates explicit compatibility fallback blocks. | + +Charts support `line`, `bar` and `area` with `axis_config: {categories, x_label?, y_label?}` and `series: [{name, data: [{label, value}]}]`. Categories have 1–20 distinct labels; each series must have exactly one point per category. Series names are distinct; at most 12 series are allowed. Names and labels are at most 20 characters, axis titles 50. Values must be finite; negative values are supported. Pie charts instead use `chart: {type: "pie", segments: [{label, value}]}` with 1–12 distinct labels and positive finite values. + +A document has at most 40 top-level components and the final answer must fit the 128,000-byte presentation parsing boundary. Malformed, incomplete, quoted, ambiguous or unrecognized documents stay on the ordinary text path. The gateway isolates components into messages, counts nested blocks, enforces two charts and 20,000 table characters per message, and preserves every value and link in generated text. Components which exceed Slack's nested block or serialized payload limits become text. The server's existing `maxDeliveryParts` policy still applies, with an explicit shortening notice when needed. + +The gateway freezes versioned blocks and text together before posting. Retries replay that plan. A definitive Slack `invalid_blocks` or `invalid_attachments` rejection permits a text-only retry; ambiguous network outcomes retain the existing reconciliation behavior. Clients that cannot render layouts receive the generated stable fallback blocks. + +This is rich **message** support. Existing app-owned Stop, approval, question and feedback workflows remain responsible for interactions. New input forms, App Home, modals, Work Objects, plan/task execution controls and embedded video are not exposed to Agent output. Authorized file attachments continue through the existing artifact delivery path. Slack may limit newer blocks by client or app availability; automated tests cover SDK payloads and rejection fallback, while live rendering requires a configured Slack workspace. + +## Identity and account links + +Organization workspace connections use personal identities. Manual connections can use `per_user` (each linked participant uses their own account) or `shared` (only the connection creator can link). Shared gateway deployment is unrelated to the manual `shared` identity mode. + +Each actor/link revision has its own execution lane. Sharing a Slack thread does not share a LibreChat conversation, files, OAuth state, approvals, usage, or trace session. Mode changes, unlinking, account removal and access/key revocation invalidate old authority rather than remapping it to another user. + +Browser routes under `/api/channels/links` preview, accept, list and revoke links using authenticated sessions and same-origin checks. Ticket lifetime defaults to 10 minutes and accepted links to 30 days; see the [channel policy](/docs/configuration/librechat_yaml/object_structure/agents#channels) to change them. Browser acceptance still requires confirmation by the same Slack actor before execution is permitted. + +## Gateway protocol boundary + +Service requests use `Authorization: Bearer ` and the exact tenant/channel context. For routes without a tenant path parameter, send the channel's exact tenant in `x-tenant-id`; do not choose a tenant from untrusted message text. The service token permits this integration boundary, not arbitrary user impersonation. Never put it in client-side code, Slack messages, tracing payloads, or public logs. The credential bundle endpoint returns secrets to the trusted gateway and must not be exposed as a public discovery API. + +| Stage | Route under `/api/channels` | Responsibility | +| --- | --- | --- | +| Configuration | `GET /service/slack/{tenantId}/{channelId}` | Read the active channel and encrypted-at-rest credentials through an authenticated service boundary | +| Identity | `/service/{channelId}/identity/{externalUserId}` and its ticket/confirm operations | Resolve explicit actor linking; never infer a principal from thread history | +| Admission | `POST /service/{channelId}/runs` | Admit an idempotent event with verified team/app/actor identity | +| Ownership | `POST /service/{channelId}/runs/claim`, then `/{runId}/renew` or `/{runId}/yield` | Claim, renew, or safely yield the exact polling lease | +| Execution preparation | `POST /service/{channelId}/runs/{runId}/response/prepare` | Obtain the bound execution credential, request, and stable request key | +| Response binding | `POST /service/{channelId}/runs/{runId}/response/bind` | Bind the returned Responses identity to the admitted run | +| Progress and result | `/{runId}/advance`, `/{runId}/progress/*`, `/{runId}/plan`, `/{runId}/delivery/*`, `/{runId}/commit` | Project canonical state and record fenced delivery effects | +| Review projection | `POST /service/{channelId}/runs/{runId}/review` | Reauthorize the original actor; obtain the browser fallback and, for the exact external channel, the current private question/tool-review payload | +| Review decision | `POST /service/{channelId}/runs/{runId}/review/decision` | Submit the current actor's decision to the same canonical Response, using its immutable decision receipt and resume preflight | +| Artifacts | `POST /service/{channelId}/runs/{runId}/artifacts/{artifactId}` | Read only an artifact bound to the authorized run | +| Stop | `POST /service/{channelId}/runs/stop-thread` or `/{runId}/cancel` | Cancel only the authorized actor lane/run | +| Feedback | `POST /service/{channelId}/reactions` | Apply authenticated, deduplicated reaction events to confirmed delivered replies | + +Run-relative paths in the table are beneath `/service/{channelId}/runs`. Lease mutations carry the exact server-issued `{ runId, owner, epoch }` fence. Treat stale leases, changed authority, and ambiguous delivery outcomes as protocol states to reconcile, not permission to mint a new run or blindly resend a Slack message. + +A gateway can yield a Responses-bound polling turn only after its progress writes and renewal loop have drained. The backend invalidates that polling fence and enforces a reclaim cooldown (one second by default); the next claim increments the epoch. This does not release the actor lane, cancel the provider, change the Response, or erase delivery evidence. Inflight or unknown remote writes cannot yield. If a host does not support yield or the request is uncertain, retain ordinary lease-expiry recovery instead of starting a new execution. + +Execution preparation returns an `apiKey`, `requestKey`, optional retained `responseId`, and a Responses `request` with the Agent ID, admitted input, `background: true`, `store: true`, and any authorized continuation. Submit that request to `/api/agents/v1/responses` using the bound key and `Idempotency-Key: `, then bind the returned response ID. Do not substitute a creator's unrestricted key, change the actor/Agent, or send the input to a channel bookkeeping route to execute it. + +The gateway owns Slack event verification, retry/deduplication, native message formatting, rate-limit handling, and delivery receipt reconciliation. Preserve exact event identifiers and timestamps. For feedback events, `eventTimestampUs` is an integer timestamp in microseconds; do not round it to milliseconds. Report confirmed, failed, or ambiguous side effects accurately before advancing delivery state. + +## Delivery recovery + +Slack can accept a reply even if the network connection drops before the gateway receives confirmation. Posting it again could duplicate the answer. + +The gateway saves each delivery operation and its receipt. If a required operation's result is unknown, it keeps that actor's execution lane held until the outcome is reconciled. Stopping the worker or requesting cancellation does not tell you whether Slack accepted the earlier request. + +Check what reached Slack before attempting recovery. + +### Reconcile a verified provider result + +1. Pause gateway processing for the affected channel while investigating. Keep the channel enabled and preserve its actor link and source authority; disabling these is not a recovery bypass. +2. Inspect the frozen run plan and retained receipt. Verify in the provider that the exact operation reached the intended channel or thread. Record its message key or file ID, matching the retained attempt and any upload checkpoint. If the result cannot be verified, leave the receipt unknown and the lane held. +3. After the old lease expires, use `POST /api/channels/service/:channelId/runs/claim` with `{ "owner": "" }`, normal private service authentication and tenant binding. Verify that the returned run ID is the run being investigated; claims select eligible work and do not take a target run ID. Use the returned current fence, renewing it through `POST /renew` as needed. An expired or replaced worker's fence cannot reconcile the run. +4. Submit the confirmed receipt through the private channel API. These endpoints confirm existing attempts; they do not send messages, replace the frozen plan, reset attempts or accept a retryable outcome. + +All paths below are relative to `/api/channels/service/:channelId/runs/:runId`. Send the channel service bearer token and the configured tenant header, using the same internal service URL as the gateway. Preserve the complete fence returned by the claim. + +For a delivery operation, `POST /delivery/reconcile`: + +```json +{ + "fence": { "runId": "", "owner": "", "epoch": 1 }, + "receipt": { + "operationId": "", + "outcome": "confirmed", + "attempts": 1, + "externalMessageKey": ":" + } +} +``` + +Replace the example values with the run's current fence and saved attempt count. In particular, do not copy the example epoch unchanged. For a verified file operation, supply `externalFileId` as required by the saved operation and checkpoint. + +Reconciliation confirms an existing message or file. It cannot replace that provider identity with a different one. + +For a progress update, `POST /progress/reconcile` with the current `fence`, the retained progress `revision`, and a `receipt` containing `outcome: "confirmed"`, the retained `attempts` and verified `externalMessageKey`. The message identity remains fixed across progress revisions. + +Once every required delivery operation is confirmed, `POST /commit` with the current `fence` to complete delivery and release the actor lane. Resume normal gateway processing afterward. If any required result remains uncertain, keep the run held rather than resending or recreating it. Optional exhausted effects follow the gateway's bounded recovery policy and do not justify replaying a required answer. + +## Review and privacy + +The public run snapshot contains only an opaque action descriptor. A review request with the original verified actor, current channel revision, and exact `externalChannelId` can obtain minimal private question/tool-approval details. The backend derives the owner and Response from the run and checks the current actor link and source grant; it does not accept an arbitrary user ID. The gateway must show these details only to that actor, not publicly in a shared thread. Slack can use ephemeral choice buttons and private modals. Native tool approval is for the individual call only; unsupported/richer forms retain the browser fallback. + +Decision requests include that same actor, revision, external channel, and the existing Responses `decision` body. Backend decision receipts, expiry/conflict checks, full authorization preflight, and same-Response resume remain authoritative. A Slack click alone is not permission to resume work. Provider OAuth URLs remain exclusively in the authenticated browser review flow. See the [background Responses lifecycle](/docs/features/background_responses#review-a-required-action). + +Successful submission closes the private modal and sends a private acknowledgement; it does not claim the tool finished. Provider sign-in and unsupported forms open the authenticated browser flow. The Agent's existing approval policy determines whether a tool needs approval; connecting Slack does not make every tool manual or bypass that policy. + +A saved decision whose queue publication failed remains retryable with the exact immutable decision; it cannot be replaced by a different answer. Keep Stop available while work remains active and update public progress only through the fenced delivery protocol. + +### Files + +Artifacts are scoped to the authorized run and actor. User-submitted rows do not count as server-generated provenance for artifacts or trace links. Limits default to five files and 10 MiB per file. One `artifactReadTimeoutMs` budget (30 seconds by default) covers catalog queries, storage reads and final authorization rather than restarting for every file. Limits resolution is separately capped at 60 seconds, and its elapsed time counts against the selected budget once available. An expired budget omits artifacts while retaining the answer for authorized text delivery. + +New plain-text answer files require more than `artifactAnswerFileThresholdBytes` UTF-8 bytes (6,000 by default); fenced answers also qualify. This threshold controls new projections, while saved descriptors retain their content identity and still require current authorization, retention and maximum-size checks. Do not replace an unavailable artifact with another actor's file or an unauthenticated internal download URL. Usage and cost summaries identify incomplete or unavailable coverage instead of presenting a partial subtotal as the complete thread total. + +### Feedback + +Reaction feedback maps only to confirmed delivered assistant messages. It does not overwrite the browser's feedback field. Export is constrained by recorded sampling/destination provenance and current export policy. Temporary-chat provenance is retained; an old mapping without that provenance is not treated as a permanent chat. A policy change can suppress export even when the original trace was sampled. + +## Operational limits + +Disabling a channel or changing its credential mode retires old authority; it does not undo external tool effects. Stop can remain pending until the exact provider is drained and canonical cancellation/cleanup completes. A gateway must poll/reconcile canonical state rather than interpreting an acknowledgement as terminal completion. + +With the process-local job store, restarting the API while a tool approval is pending makes the review unavailable. The request stays held for reconciliation and a stale approval does not execute the tool. Durable checkpoint storage alone does not recreate the missing live execution state. Completed history and subsequent thread continuation survive restart. + +Build the gateway package from the LibreChat source tree; it is not published as an npm package. The gateway is for Slack. + +A request waiting for sign-in may not resume after a server restart. A new browser sign-in may be needed, and signing in does not prove that the original request resumed. Check the original request and any external results. If the outcome is still uncertain, do not report completion or retry the work as a new request. diff --git a/content/docs/configuration/librechat_yaml/object_structure/agents.mdx b/content/docs/configuration/librechat_yaml/object_structure/agents.mdx index 4dc7e1fd0..9cdea3b5f 100644 --- a/content/docs/configuration/librechat_yaml/object_structure/agents.mdx +++ b/content/docs/configuration/librechat_yaml/object_structure/agents.mdx @@ -1497,10 +1497,70 @@ Tokens must be unexpired and present a single, non-conflicting client identifier Unknown management-auth fields, duplicate client IDs, malformed user or tenant IDs, and enabled authentication without a client binding fail configuration validation. See [Agents API - Agent Management](/docs/features/agents_api#agent-management-api) for routes and examples. +## channels + +For organization workspaces, `channels.maxBotManagers` limits the number of explicitly granted bot managers per app/workspace installation (default `50`, range `1`–`1000`). Administrators grant these users through the workspace’s **Manage access** button (**Manage bot access** dialog); bot management does not grant Agent sharing or installation-administration permissions. + +Configures the opt-in [Agent Channels integration](/docs/features/agent_channels). Enabled background Responses and a separately running gateway are required. The LibreChat source includes the standalone TypeScript Slack gateway in `packages/channel-gateway`; this setting does not start it or enable execution permissions. + +| Option | Default | Accepted values / purpose | +| --- | --- | --- | +| `enabled` | `false` | Enable channel setup and service routes | +| `transport` | `socket_mode` | Select `socket_mode` or `webhook` ingress; manual connections generate a matching manifest and the gateway runs separately | +| `gatewayUrl` | Omitted | Required HTTPS base URL for manual webhook manifests; organization workspaces default to `DOMAIN_SERVER` when omitted. Not needed for Socket Mode | +| `nativeSessions` | `false` | Enable optional Slack native Agent status emission after app setup | +| `lifecycleReactions` | `false` | Add optional processing/completion reactions | +| `signatureToleranceSeconds` | `300` | Webhook signature timestamp window; integer from 1 to 300 seconds | +| `socketReconnectDelayMs` | `5000` | Socket reconnect delay; integer from 100 to 60000 milliseconds | +| `ticketLifetimeMs` | `600000` | Link ticket lifetime, `60000`–`3600000` ms | +| `linkLifetimeMs` | `2592000000` | Accepted link lifetime, `60000`–`7776000000` ms | +| `leaseMs` | `60000` | Run lease, `10000`–`300000` ms | +| `responseCredentialLifetimeMs` | `86400000` | Bound execution credential lifetime, `60000`–`604800000` ms | +| `artifactMaxBytes` | `10485760` | Per-artifact limit, `1`–`52428800` bytes | +| `artifactMaxFiles` | `5` | Artifacts per run, `1`–`20` | +| `artifactReadTimeoutMs` | `30000` | Shared artifact-operation budget, `1000`–`60000` ms; not a separate timeout for each file | +| `artifactAnswerFileThresholdBytes` | `6000` | Create new plain-text answer files only above this UTF-8 byte length, `0`–`52428800`; fenced answers also qualify | + +`slackApp` enables organization-owned apps and sets installation/runtime policy. Set `channels.enabled: true`, `transport: webhook` and `slackApp.enabled: true`. Each registered app supports one active workspace. Organization admins register an existing Slack app through **Settings → Account → Slack → Set up/Manage → Add Slack app**, with an optional friendly name and app/client credentials; credentials are encrypted in the database and are not YAML or environment settings. The deployment opt-in `SLACK_WORKSPACES_ENABLED=true` enables these policies and background Responses while preserving other YAML settings. Without the opt-in, YAML remains authoritative. `SLACK_GATEWAY_URL` supplies the public gateway URL. See [gateway deployment](/docs/configuration/channel_gateway#organization-workspaces) and [organization workspace setup](/docs/features/agent_channels#organization-workspaces). + +| `slackApp` option | Default | Purpose | +| --- | --- | --- | +| `enabled` | `false` | Enable organization app registration and workspace installation | +| `flowLifetimeMs` | `600000` | Browser install lifetime, `60000`–`3600000` ms | +| `requestTimeoutMs` | `10000` | Slack installation/verification request deadline, `1000`–`30000` ms | +| `maxResponseBytes` | `65536` | Maximum Slack response bytes, `1024`–`262144` | +| `gateway.ingressConcurrency` | `32` | Concurrent shared ingress requests, `1`–`128` | +| `gateway.workerConcurrency` | `4` | Concurrent durable worker turns per process, `1`–`32` | +| `gateway.discoveryBatchSize` | `32` | Shared discovery page, `1`–`100`, also capped by `maxMetadataPageSize` | +| `gateway.pollIntervalMs` | `1000` | Discovery polling interval, `100`–`60000` ms | + +Workspace-bound Agent connections require personal identities. Shared gateway mode does not mean the manual owner-only `shared` credential mode; it shares transport and workers across installations, while every member retains their own execution identity. + +The artifact budget covers catalog queries, storage acquisition/consumption and final authorization. Limits resolution is capped at the schema maximum of 60 seconds; once resolved, its elapsed time counts toward the configured budget. Expiry omits artifacts rather than returning files without current authorization. The threshold applies to new answer-file projections; existing saved descriptors remain bound to their bytes and require current owner, tenant, retention and maximum-size checks. + +`cleanup` accepts `batchSize` (`25`, range `1`–`100`), `intervalMs` (`1000`, range `1000`–`60000`), and `maxIdleIntervalMs` (`30000`, range `1000`–`300000`). + +`feedback` accepts `maxConflictRetries` (`5`, range `1`–`20`), `exportTimeoutMs` (`10000`, range `1000`–`60000`), `exportLeaseMs` (`60000`, range `60000`–`300000`), `exportRetryMs` (`5000`, range `1000`–`300000`), and the same `batchSize`, `intervalMs`, and `maxIdleIntervalMs` defaults/ranges as `cleanup`. + +The gateway service boundary requires the server-side `CHANNEL_SERVICE_TOKEN`. Do not expose it to browsers or use it as a general Agent execution credential. Channel credential mode (`shared` or `per_user`) belongs to the channel record, not this deployment block. Both modes require explicit current actor linking; `shared` restricts linking to the channel creator's account rather than granting all external participants that account's privileges. + +The gateway reads this versioned policy from LibreChat before selecting ingress. `SLACK_TRANSPORT` is optional and asserts the selected mode; a mismatch or unsupported policy prevents startup. Native sessions, lifecycle reactions and signature policy are configured here rather than through gateway process flags. Gateway runtime settings, including its tenant/connection IDs, app-level Socket Mode token and optional `APP_TITLE` label, are documented in [Run the Slack gateway](/docs/configuration/channel_gateway#run-the-slack-gateway). + ## remoteApi Configuration for Remote Agent API authentication. Controls how external services authenticate when calling the Agents API endpoints. +### remoteApi.background + +Enables the opt-in [background Responses lifecycle](/docs/features/background_responses). It does not enable Remote Agents permissions or human approval by itself. + +| Option | Type | Default | Meaning | +| --- | --- | --- | --- | +| `enabled` | Boolean | `false` | Accept durable background Responses requests | +| `acknowledgementTimeoutMs` | Integer | `10000` | Worker admission acknowledgement timeout, from `100` through `60000` ms; not the model run timeout | + +Background requests require an Agent API key, stored responses, and non-streaming submission. Human-action resume requires durable MongoDB checkpoints and the corresponding existing approval/question policy. Set `DOMAIN_CLIENT` to the trusted public owner-review URL origin. + ### remoteApi.auth +Agent Channels requires a separate [Slack gateway](/docs/configuration/channel_gateway) and a transaction-capable database. An administrator needs to set these up before you can connect an agent. + + +## Before you start + +Follow the steps for your role: + +| Who | What to do | +| --- | --- | +| Deployment operator | [Run the gateway](/docs/configuration/channel_gateway#organization-workspaces) and configure the public HTTPS callback URLs. | +| Organization administrator | [Register a Slack app and connect a workspace](#organization-workspaces), then grant bot management access if needed. | +| Agent manager | [Assign an agent](#assign-an-agent) to the bot or a channel. | +| Each Slack participant | [Link your account](#account-linking), confirm it in Slack, and send a new request. | + +If your deployment uses a manually configured Slack app instead of organization workspaces, follow [manual connection setup](#set-up-a-manual-slack-app-connection). + +## Organization workspaces + +A Slack app provides the bot's identity; installing it grants access to a workspace. Each registered app supports **one active workspace**. Use separate apps for additional workspaces. + +### Register an organization’s Slack app + + + + +**Create the app in Slack.** Open [Your Apps](https://api.slack.com/apps) and create an app from scratch, or use one your organization controls. If Slack shows the **Pick features** wizard, continue without scopes or events, then select **Create → Create Anyway**. Do not install it yet. + + + + +**Register it in LibreChat.** Open **Settings → Account → Slack → Set up** (or **Manage**), then **Add Slack app**. + +Copy these values from Slack's **Basic Information → App Credentials** into the matching fields: + +- **App ID** +- **Client ID** +- **Client Secret** +- **Signing Secret** + +Select **Show** before copying a secret. You can also enter a **Name** to identify the app in LibreChat; this does not rename the bot in Slack. + +Select **Save**. You can now expand the registered app to find its callback URLs. + + + + + + +**Configure its callbacks.** Slack uses separate URLs for app installation, incoming events, and button clicks. + +Turn **Socket Mode off** in Slack. In LibreChat, expand the saved app and open the gear button, **Connection settings**. Copy each URL into its matching setting in the same Slack app: + +| LibreChat value | Slack setting | +| --- | --- | +| OAuth redirect URL | **OAuth & Permissions → Redirect URLs**; add and save | +| Events URL | **Event Subscriptions → Enable Events → Request URL**; wait for **Verified** | +| Interactivity URL | **Interactivity & Shortcuts → Interactivity → Request URL**; save | + +Keep the complete URLs, including any base path and organization/app suffixes. The gateway must be running and publicly reachable before Slack can verify the Events URL. + + + + +**Add bot permissions.** Under **OAuth & Permissions → Bot Token Scopes**, add: + +```text +app_mentions:read +chat:write +reactions:read +reactions:write +files:write +im:write +im:history +``` + +No user-token scopes are needed. + + + + +**Subscribe to events.** Under **Event Subscriptions → Subscribe to bot events**, add: + +- `app_mention` +- `message.im` +- `reaction_added` +- `reaction_removed` +- `app_uninstalled` +- `tokens_revoked` + +Save the subscriptions. + + + + +**Allow direct messages.** Under **App Home**, enable the **Messages tab** and allow users to send messages from it. + +Leave token rotation and organization-wide installation disabled. If you want Slack's [native Agent status and Stop controls](/docs/configuration/channel_gateway#native-agent-ui-and-final-replies), follow that additional setup too. + + + + +**Install the app.** In LibreChat, select **Add to workspace**, choose the intended Slack workspace, and approve installation. Workspace approval policies still apply. + +Wait for **Connecting to Slack…** to close. When the workspace shows **Connected**, you can [assign an agent](#assign-an-agent). + +Use **Cancel** to abandon a pending installation or **Retry** after a failure. + + + + +LibreChat stores these credentials encrypted. Organization setup uses app credentials rather than a pasted bot token or app-level token. + + + + +Use the pencil button, **Edit App**, to update the app later. Leaving a secret blank keeps its saved value. If you change the client ID, enter its matching client secret too. To change the App ID, register another app. + +After changing scopes in Slack, reconnect the installed app through LibreChat and approve the new grant. Existing tokens do not gain scopes just because you changed the app settings. + + + + +## Assign an agent + +Before assigning an agent, you need permission to share it and management access to the Slack bot. Installation administrators do not need a separate bot-manager grant. + +To grant bot management, an administrator opens the workspace's users button, **Manage access** (**Manage bot access** dialog). This permission lets someone assign agents through the bot. It does not grant Agent sharing permission, and people only talking to the bot do not need it. + + + + +Save an agent you have permission to share. In the Agent Builder's **Channels** section, select **Add**, then the **Slack** card in the Channel Library. + + + + +Choose a **Slack bot**, then **Continue**. If none appear, ask an administrator to connect a workspace and grant you bot management access. + + + + +Choose **Default** for new direct messages and mentions without a channel-specific assignment. Or choose **Channel Specific** and enter the **Slack channel ID** from Slack's channel details, rather than its name. Select **Assign agent**. + +If another agent already owns that destination, **Replace default agent** or **Replace channel agent** asks for confirmation. Existing conversations keep their original agent. + + + + + + +## Account linking + +Link your LibreChat account the first time you use the bot. Your account needs access to the agent, and your role must allow using Agents and querying them through Remote Agents (API). Installing the app or linking an account does not grant these permissions. + +Linking happens in two places: choose your LibreChat account in the browser, then confirm that account in Slack. Both steps are required. + + + + +Invite the bot to a Slack channel with `/invite @YourBot`, then mention it: `@YourBot hello`. Installation does not invite it to every channel. Or send a direct message when the Messages tab is enabled. + + + + +Select **Link account** in the bot's private message. Sign in to the LibreChat account you want to use, check the account and agent shown, then select **Link account** in the browser. + + + + + + +Seeing **One more step in Slack** in the browser is expected. Return to the bot's private Slack message and select **Confirm account** from the **same Slack account**. + +If the message has expired or does not update, mention the bot again to get another prompt. + + + + +When Slack shows **Account connected**, send a **new request**. Your earlier message will not run automatically. + +A successful answer completes setup. To check tool access too, ask the agent to use a tool your account is allowed to use. + + + + +You may need to link again after the link expires, you disconnect, or the connection is reactivated. + +## Use the agent + +Continue in the same Slack thread for follow-up questions. A working message provides **Stop** and, when needed, **Review**. Supported questions and individual tool approvals use private Slack controls; provider sign-in and unsupported forms open the authenticated browser flow. The agent's approval policy still applies. + +Answers can contain code, tables, links, files, and charts. Agent authors can opt into richer layouts using the [rich-message format](/docs/configuration/channel_gateway_reference#rich-agent-messages). Optional native Agent status and lifecycle reactions are configured by the deployment operator. + +Sharing a Slack thread does not share another person's files, account, pending question, or approval authority. **Stop** cancels your authorized work without undoing effects a tool already performed. Wait for the final status; an acknowledgement alone does not mean work has finished. + +## Manage connections + + + + +Hover over or focus a connection row and open its gear button, **Manage connection**. + +Use **Add assignment** for another destination, or **Remove** beside an assignment and confirm. **Delete connection** removes all its assignments after confirmation. Existing threads keep their original agent. + + + + +Disabling stops execution and keeps the assignments. To reactivate, select **Activate channel** and confirm the retained assignment. Each person must link and confirm their account again afterward. + +Removing a manager's access alone does not stop existing assignments or conversations. + + + + +Open **Settings → Account → Your channel account links**. Each row shows the agent name and Slack user/workspace IDs. Hover over its Slack icon to read the link status. + +Hover over or focus the row, select **Disconnect**, and confirm to disconnect your account from this agent. You can disconnect an unavailable link too. Completed actions will not be undone. + + + + +Open **Settings → Account → Slack → Manage** and select **Disconnect workspace**. This disconnects the installation in LibreChat and leaves the app installed in Slack. + +Installing it again after disconnecting creates a new installation identity. Set up its assignments and bot managers again. Reconnecting an active installation updates its grant and keeps its managers. + + + + +Disconnect the app's workspace first, then use **Remove app** to delete its saved credentials. The app itself remains in Slack. + +Removing the person who configured the app does not delete the organization's installation. + + + + +## Set up a manual Slack app connection + +Use this path when organization workspaces are not enabled. Ask your deployment administrator to enable manual Channels and [prepare the gateway](/docs/configuration/channel_gateway#configuration-and-prerequisites) first. + + + + +Save the agent, then choose **Channels → Add → Slack**. Choose **Per-user accounts** for each participant's own account, or **Channel owner only** to restrict use to the creator. Select **Continue**. Owner-only mode does not lend your account to others. + + + + +In **Create**, select **Create in Slack** to open Slack with the generated manifest. Choose the workspace, create the app, then **Install to Workspace → Allow**. If the link fails, expand **Link not working? Paste the manifest manually**. Make later app changes in Slack's app settings. + + + + + + +In **Credentials**, enter the matching **Slack app ID** and **Bot token**. Webhook mode also requires the **Signing secret**. Select **Continue**, review the values in **Activate**, then select **Activate channel**. LibreChat verifies the bot identity and stores the credentials encrypted. + + + + +Hover over or focus the Slack/status icon in the connection dialog to find the **Connection ID**. Give it to the operator to [start the bound gateway](/docs/configuration/channel_gateway#run-the-slack-gateway). Invite and mention the bot, then complete [account linking](#account-linking). + + + + + + + + +Changing identity mode invalidates existing links and pending requests. Each person will need to link and confirm again. + +1. In **Manage connection**, select the pencil beside the identity mode. If the connection is active, confirm **Disable and change**. +2. Choose the new mode and select **Save**. +3. Reopen **Manage connection → Setup**. Use the existing Slack app and re-enter its bot token (and signing secret for webhooks). +4. Finish the wizard and select **Activate channel**. + + + + +## Troubleshooting + +| Problem | What to check | +| --- | --- | +| Channels or a Slack bot is missing | Save the agent first. Check gateway setup, Agent and Remote Agents permissions, sharing access, and bot management access. | +| Events URL will not verify, or Slack callbacks return `401` | Gateway is running on public HTTPS; the URL and **Signing Secret** belong to the same saved app. Check clock synchronization; do not disable signature checks. | +| The bot does not respond | Invite it to the channel, assign an agent, and check the personal link. For organization workspaces, turn **Socket Mode off** and enable Events with the subscriptions above. Ask the operator to check [gateway readiness](/docs/configuration/channel_gateway#verify-the-gateway). | +| Confirmation, approval, or Stop does nothing | Enable **Interactivity** and save its exact Request URL. The Events URL is a separate callback. | +| Link is awaiting confirmation | Select **Confirm account** in the private Slack message, then send a new request. Mention the bot again to recover the prompt if needed. | +| Permissions are missing after scopes changed | Reconnect through LibreChat and approve the updated grant. Existing tokens do not gain scopes automatically. | + +If an approval becomes unavailable after a server restart, ask an administrator to check the [recovery limits](/docs/configuration/channel_gateway_reference#operational-limits). A stale approval does not execute the tool; check the original run before starting the work again. diff --git a/content/docs/features/agents_api.mdx b/content/docs/features/agents_api.mdx index 5289b5cfc..e666f0fee 100644 --- a/content/docs/features/agents_api.mdx +++ b/content/docs/features/agents_api.mdx @@ -16,6 +16,8 @@ There are three parts: Endpoints, request formats, and responses may still change between releases. +For opt-in asynchronous execution, retained human actions, owner review, and Stop, see [Background Agent Responses](/docs/features/background_responses). [Agent Channels](/docs/features/agent_channels) use that same Responses execution path while managing external identity and delivery separately. + ## Get an API key Open **Settings**, go to **Data & Privacy**, and find **Agent API Keys** under **API keys**. Click **Manage**, then **Create API Key**, give it a name, pick an expiration (7 days up to 1 year, or never), and copy the key right away: it is shown only once. diff --git a/content/docs/features/background_responses.mdx b/content/docs/features/background_responses.mdx new file mode 100644 index 000000000..86db7a758 --- /dev/null +++ b/content/docs/features/background_responses.mdx @@ -0,0 +1,168 @@ +--- +title: Background Agent Responses +description: Start agent requests in the background, check their progress, and review or stop your requests. +icon: Workflow +--- + +Use background responses when your application needs to start an agent request and check its progress later. Submit the request, save the returned response ID, and use that ID to check for updates through the existing [Agents API](/docs/features/agents_api). + +If the agent needs an approval, an answer, or a sign-in, the response includes a review link for the owner. + + +Background execution is disabled by default. Use a LibreChat version that supports background Responses before enabling it. + + +## Enable background execution + +Merge this block into your existing configuration: + +```yaml filename="endpoints / agents" +endpoints: + agents: + remoteApi: + background: + enabled: true + acknowledgementTimeoutMs: 10000 +``` + +`enabled` defaults to `false`. Existing Remote Agents permissions, Agent access, terms acceptance, content checks, and provider/tool policies still apply. + +`acknowledgementTimeoutMs` controls how long the API waits for the worker to acknowledge the request. It defaults to `10000` milliseconds and accepts integers from `100` through `60000`. It does not limit the agent's total execution time. + +Stored background Responses require a MongoDB replica set or another verified transaction-capable database. Standalone MongoDB and FerretDB 2.7 do not support this durable feature; ordinary LibreChat remains available. See the [local replica setup](/docs/configuration/channel_gateway#docker-compose). + +Background submission requires an **Agent API key**, including when ordinary inference also accepts OIDC. A management API machine token is not an execution credential. Configure [Remote Agents permissions](/docs/features/agents_api#setup) separately. + +If your agent needs tool approval or Ask User pauses, configure durable MongoDB checkpoint storage through the existing [`toolApproval`](/docs/configuration/librechat_yaml/object_structure/agents#toolapproval), Ask User, and [`checkpointer`](/docs/configuration/librechat_yaml/object_structure/agents#checkpointer) settings. + +An in-memory checkpointer cannot provide durable resume for these background pauses. Enabling background execution does not enable approval automatically or bypass a deny rule. Requests without a human pause keep their normal execution path. + +Set `DOMAIN_CLIENT` to the trusted public browser URL so generated review links point to your deployment. Do not construct review destinations from incoming Host headers. + +## Submit and poll + +Follow the same response from submission to completion: + +1. Send a background request. +2. Save the response ID returned by the API. +3. Use that ID to check progress and handle any required action. + +### Send a request + +```bash +curl https://chat.example.com/api/agents/v1/responses \ + -H 'Authorization: Bearer YOUR_AGENT_API_KEY' \ + -H 'Content-Type: application/json' \ + -H 'Idempotency-Key: report-request-001' \ + -d '{"model":"AGENT_ID","input":"Summarize the latest report.","background":true,"store":true}' +``` + +The API returns HTTP `202` with a response object when it accepts the background request. Save its ID for the next step. + +Requests with `background: true` require storage: omit `store` or set it to `true`. They reject `store: false` and `stream: true`. To use ordinary synchronous or streaming Responses, omit `background` or set it to `false`. + +If the connection drops before you receive a response, retry the same request with the same `Idempotency-Key`. Choose a new key for new work. + +The key is optional, but omitting it makes each submission a new request. A retry after an uncertain network result can then start duplicate work. When supplied, the key must be nonblank and at most 256 characters. + +### Check progress + +```bash +curl https://chat.example.com/api/agents/v1/responses/RESPONSE_ID \ + -H 'Authorization: Bearer YOUR_AGENT_API_KEY' +``` + +Keep checking the same response ID until it reaches a final status: + +| Status | What to do | +| --- | --- | +| `queued`, `in_progress` | Keep checking. If `required_action` is present, [review it](#review-a-required-action). | +| `completed`, `failed`, `incomplete`, `cancelled` | Read the final result or error. These statuses are terminal. | + +The server rechecks the API key that started the request and current access permissions. A response ID alone does not grant access to read or resume it. + +To continue a supported conversation, pass the returned ID as `previous_response_id` instead of resending the original input. + +### Storage and recovery + +A background response reports a final status after the provider has finished and the conversation history is saved with the response. If storage is temporarily unavailable, the result stays pending for recovery without running the provider again. + +During a rolling upgrade or rollback, keep a compatible worker available to finish pending results. + +Ordinary synchronous and streaming requests have a different storage contract: if optional saving fails, the generated answer can still succeed with `store: false`. Check that returned value before relying on retrieval or continuation. + +## Review a required action + +A public response can include: + +```json +{ + "status": "in_progress", + "required_action": { + "type": "librechat_review", + "kind": "tool_approval", + "action_id": "ACTION_ID", + "expires_at": 1800000000, + "review_url": "https://chat.example.com/responses/RESPONSE_ID/review" + } +} +``` + +An `in_progress` response can be waiting for you, rather than running the model. Check `required_action` for the next step: + +- `kind` is `tool_approval`, `question`, or `oauth`. +- `expires_at` is the expiry time, in Unix seconds. Act only while the action is still present and unexpired. +- Private approval details and provider OAuth URLs are available through the authenticated review flow, rather than this public response. + +Open `review_url` in a browser and sign in as the response owner in the correct tenant. From there, you can inspect the pending tool call, answer a question, or continue an MCP OAuth sign-in. + +Access to the same agent is not enough to approve someone else's request. + +The browser lifecycle uses session authentication, not an Agent API key or a management token: + +| Method | Route | Purpose | +| --- | --- | --- | +| `GET` | `/api/agents/responses/{id}/review` | Read the owner-only review view | +| `POST` | `/api/agents/responses/{id}/review` | Submit the current action decision | +| `POST` | `/api/agents/responses/{id}/cancel` | Request Stop for an owned response | + +Decision submissions must include the current `actionId` and the fields for that action: + +- **Questions:** use `answer`, or `answers` keyed by the presented question identities. +- **Tool approvals:** use `decisions` with the exact `tool_call_id` and an allowed `decision` (`approve`, `reject`, `edit`, or `respond`). Include edited arguments or response text when needed. + +Use the supplied review UI to see which choices and scopes are available. A value listed in the API schema does not grant permission to use an unavailable approval scope. + +After a decision is accepted, the API returns HTTP `202` with `responseId`, `actionId`, `intentId`, and `status` (`queued` or `settled`). Check the review page or response again to see what happened next; acceptance does not mean execution has finished. + +If the submission result is uncertain, do not resubmit it with a different intent or reuse a stale action after a conflict. Before resuming, the server rechecks access to the agent, model, tools, project and files, together with the saved execution context. + +## OAuth recovery limits + +Complete MCP OAuth sign-in through the supplied provider flow. The prompt remains available only to its owner until its deadline. An approval decision cannot replace the provider's OAuth callback. + +A successful sign-in can continue the waiting request while that request's sign-in handler is still active. + +### If the server restarts during sign-in + +A request waiting for sign-in may not resume after a server restart, even if its prompt is still visible. OAuth sign-in handlers are kept in memory; durable question and tool-approval checkpoints use a different mechanism. + +If the saved execution state is missing or no longer matches, the response keeps a non-final status, includes `recovery: "execution_state_unavailable"`, and removes stale actionable prompts. The request has not been confirmed complete or cancelled, and work is not replayed. + +Signing in may save your credentials without resuming the original request. Before retrying: + +1. Check the original request and any external results, such as a tool action that may already have completed. +2. If the execution state remains unknown, ask an administrator to reconcile the held run before clearing it. +3. Avoid reusing an old authorization URL or assuming sign-in restarted the model. + +See [MCP authentication](/docs/features/mcp#sign-in-with-oauth) for the sign-in flow. + +## Stop and recovery + +API-key clients can request cancellation with `POST /api/agents/v1/responses/{id}/cancel`. Owners can use **Stop** in the review UI. Both paths operate on the same durable response; neither starts a replacement execution. + +After requesting Stop, keep checking until the response reports `cancelled` or another final status. It may take time for the provider to stop, checkpoints to be cleaned up, and the final status to be saved. + +Completed tool actions will not be undone. Check their results before repeating work, even if the response was cancelled. + +Revoked source keys, changed channel/account bindings, missing authority, stale checkpoint identities, and changed privileged code targets fail closed. Temporary storage outages can delay terminal publication and cleanup; do not force-delete execution proof or manually replay tools to make the status change. diff --git a/content/docs/features/meta.de.json b/content/docs/features/meta.de.json index f5ae5b04c..c721c1cbc 100644 --- a/content/docs/features/meta.de.json +++ b/content/docs/features/meta.de.json @@ -10,6 +10,8 @@ "agent_plugins", "subagents", "agents_api", + "background_responses", + "agent_channels", "artifacts", "code_interpreter", "pull_requests", diff --git a/content/docs/features/meta.es.json b/content/docs/features/meta.es.json index 0eeed4a73..3e7c2bc54 100644 --- a/content/docs/features/meta.es.json +++ b/content/docs/features/meta.es.json @@ -10,6 +10,8 @@ "agent_plugins", "subagents", "agents_api", + "background_responses", + "agent_channels", "artifacts", "code_interpreter", "pull_requests", diff --git a/content/docs/features/meta.fr.json b/content/docs/features/meta.fr.json index a5293817a..f9c55539a 100644 --- a/content/docs/features/meta.fr.json +++ b/content/docs/features/meta.fr.json @@ -10,6 +10,8 @@ "agent_plugins", "subagents", "agents_api", + "background_responses", + "agent_channels", "artifacts", "code_interpreter", "pull_requests", diff --git a/content/docs/features/meta.id.json b/content/docs/features/meta.id.json index b06ad51a7..0feb398a9 100644 --- a/content/docs/features/meta.id.json +++ b/content/docs/features/meta.id.json @@ -10,6 +10,8 @@ "agent_plugins", "subagents", "agents_api", + "background_responses", + "agent_channels", "artifacts", "code_interpreter", "pull_requests", diff --git a/content/docs/features/meta.it.json b/content/docs/features/meta.it.json index 1e6ccf7ac..d1b66fec1 100644 --- a/content/docs/features/meta.it.json +++ b/content/docs/features/meta.it.json @@ -10,6 +10,8 @@ "agent_plugins", "subagents", "agents_api", + "background_responses", + "agent_channels", "artifacts", "code_interpreter", "pull_requests", diff --git a/content/docs/features/meta.ja.json b/content/docs/features/meta.ja.json index d029e41fb..140509deb 100644 --- a/content/docs/features/meta.ja.json +++ b/content/docs/features/meta.ja.json @@ -10,6 +10,8 @@ "agent_plugins", "subagents", "agents_api", + "background_responses", + "agent_channels", "artifacts", "code_interpreter", "pull_requests", diff --git a/content/docs/features/meta.json b/content/docs/features/meta.json index 184105df9..d13ce9856 100644 --- a/content/docs/features/meta.json +++ b/content/docs/features/meta.json @@ -10,6 +10,8 @@ "agent_plugins", "subagents", "agents_api", + "background_responses", + "agent_channels", "artifacts", "code_interpreter", "pull_requests", diff --git a/content/docs/features/meta.ko.json b/content/docs/features/meta.ko.json index c22242753..b1966d1dc 100644 --- a/content/docs/features/meta.ko.json +++ b/content/docs/features/meta.ko.json @@ -10,6 +10,8 @@ "agent_plugins", "subagents", "agents_api", + "background_responses", + "agent_channels", "artifacts", "code_interpreter", "pull_requests", diff --git a/content/docs/features/meta.nl.json b/content/docs/features/meta.nl.json index 5f9343787..a520d382a 100644 --- a/content/docs/features/meta.nl.json +++ b/content/docs/features/meta.nl.json @@ -10,6 +10,8 @@ "agent_plugins", "subagents", "agents_api", + "background_responses", + "agent_channels", "artifacts", "code_interpreter", "pull_requests", diff --git a/content/docs/features/meta.pl.json b/content/docs/features/meta.pl.json index d4c62d1a6..bcc344623 100644 --- a/content/docs/features/meta.pl.json +++ b/content/docs/features/meta.pl.json @@ -10,6 +10,8 @@ "agent_plugins", "subagents", "agents_api", + "background_responses", + "agent_channels", "artifacts", "code_interpreter", "pull_requests", diff --git a/content/docs/features/meta.pt-BR.json b/content/docs/features/meta.pt-BR.json index 3655d7896..766869701 100644 --- a/content/docs/features/meta.pt-BR.json +++ b/content/docs/features/meta.pt-BR.json @@ -10,6 +10,8 @@ "agent_plugins", "subagents", "agents_api", + "background_responses", + "agent_channels", "artifacts", "code_interpreter", "pull_requests", diff --git a/content/docs/features/meta.tr.json b/content/docs/features/meta.tr.json index a671ba18e..4ec97414b 100644 --- a/content/docs/features/meta.tr.json +++ b/content/docs/features/meta.tr.json @@ -10,6 +10,8 @@ "agent_plugins", "subagents", "agents_api", + "background_responses", + "agent_channels", "artifacts", "code_interpreter", "pull_requests", diff --git a/content/docs/features/meta.vi.json b/content/docs/features/meta.vi.json index 134efb300..9c704be71 100644 --- a/content/docs/features/meta.vi.json +++ b/content/docs/features/meta.vi.json @@ -10,6 +10,8 @@ "agent_plugins", "subagents", "agents_api", + "background_responses", + "agent_channels", "artifacts", "code_interpreter", "pull_requests", diff --git a/content/docs/features/meta.zh.json b/content/docs/features/meta.zh.json index df6d457e9..8814dee95 100644 --- a/content/docs/features/meta.zh.json +++ b/content/docs/features/meta.zh.json @@ -10,6 +10,8 @@ "agent_plugins", "subagents", "agents_api", + "background_responses", + "agent_channels", "artifacts", "code_interpreter", "pull_requests", diff --git a/lib/icons.tsx b/lib/icons.tsx index 1cb2770f0..22dc473ee 100644 --- a/lib/icons.tsx +++ b/lib/icons.tsx @@ -70,9 +70,11 @@ import { FileCode, Plug, MessageSquareText, + MessagesSquare, PanelLeft, CalendarClock, Waves, + Workflow, Braces, Bot, Wrench, @@ -171,9 +173,11 @@ const icons: Record = { FileCode: , Plug: , MessageSquareText: , + MessagesSquare: , PanelLeft: , CalendarClock: , Waves: , + Workflow: , Braces: , Bot: , Wrench: , diff --git a/public/images/features/agent_channels/account-accepted-dark.jpg b/public/images/features/agent_channels/account-accepted-dark.jpg new file mode 100644 index 000000000..3bf887a62 Binary files /dev/null and b/public/images/features/agent_channels/account-accepted-dark.jpg differ diff --git a/public/images/features/agent_channels/account-accepted-light.jpg b/public/images/features/agent_channels/account-accepted-light.jpg new file mode 100644 index 000000000..ff78b8f1e Binary files /dev/null and b/public/images/features/agent_channels/account-accepted-light.jpg differ diff --git a/public/images/features/agent_channels/manual-create-dark.png b/public/images/features/agent_channels/manual-create-dark.png new file mode 100644 index 000000000..0d3ba6111 Binary files /dev/null and b/public/images/features/agent_channels/manual-create-dark.png differ diff --git a/public/images/features/agent_channels/manual-create-light.png b/public/images/features/agent_channels/manual-create-light.png new file mode 100644 index 000000000..70edba128 Binary files /dev/null and b/public/images/features/agent_channels/manual-create-light.png differ diff --git a/public/images/features/agent_channels/org-app-registration-dark.jpg b/public/images/features/agent_channels/org-app-registration-dark.jpg new file mode 100644 index 000000000..6be76243d Binary files /dev/null and b/public/images/features/agent_channels/org-app-registration-dark.jpg differ diff --git a/public/images/features/agent_channels/org-app-registration-light.jpg b/public/images/features/agent_channels/org-app-registration-light.jpg new file mode 100644 index 000000000..dc0f40266 Binary files /dev/null and b/public/images/features/agent_channels/org-app-registration-light.jpg differ diff --git a/public/images/features/agent_channels/org-assignment-dark.jpg b/public/images/features/agent_channels/org-assignment-dark.jpg new file mode 100644 index 000000000..480778278 Binary files /dev/null and b/public/images/features/agent_channels/org-assignment-dark.jpg differ diff --git a/public/images/features/agent_channels/org-assignment-light.jpg b/public/images/features/agent_channels/org-assignment-light.jpg new file mode 100644 index 000000000..300676213 Binary files /dev/null and b/public/images/features/agent_channels/org-assignment-light.jpg differ