@inline-chat/hermes-agent-adapter
v1.2.6
Published
Hermes Agent platform adapter for Inline, with a native Python plugin and bundled Inline realtime sidecar.
Maintainers
Readme
@inline-chat/hermes-agent-adapter
Inline platform plugin for Hermes Agent.
This package installs an external Hermes platform plugin named inline and a
supervised Node sidecar that uses @inline-chat/realtime-sdk for Inline
realtime transport.
Implemented Hermes-native surfaces:
- realtime inbound messages, replies, and action callbacks
- outbound text, markdown, opt-in edit-message streaming, deletes, typing, media uploads, and reply threads
- Discord-style native Hermes
inlinetool for bounded chat/message/history/search/thread, reaction, pin, and agent-authored button-message actions - clarify prompts, command approvals, slash confirmations, and model picker buttons
- Hermes slash commands synced into Inline's native
/bot command menu - DM/group access policy controls compatible with Hermes gateway allowlists
- installer, doctor, dry-run, and live
test-sendprobes
Feature Support
Supported:
- Install, status, doctor, dry-run, and live
test-sendcommands. - External Hermes platform registration as
inline. INLINE_TOKEN,INLINE_BOT_TOKEN,platforms.inline.token, andinline.tokenauth paths, including simple${ENV_NAME}config references.- Supervised loopback Node sidecar using the Inline realtime SDK.
- Realtime inbound messages, catch-up, replies to bot messages, and action callbacks.
- Inbound SDK receipts remain pending until Python handles the event. Temporary routing-metadata and authorization failures retry before deduplication or effects, preserving per-chat order while other chats can progress. Lost acknowledgement responses retry only the acknowledgement. Agent-button preflight retries are bounded, then show a retry prompt so an unavailable button cannot indefinitely block the shared action cursor. Shutdown leaves unresolved receipts available for catch-up; this is an at-least-once handoff, not a durable exactly-once guarantee for model turns or external effects.
- Outbound text, Markdown parsing, opt-in edit-message streaming, long-message splitting, edits, deletes, typing, and presence.
- Inline reply threads per chat (Auto or On, in DMs and groups, set with
/threads, the agent settings, or by asking the agent), one thread per conversation, explicit/followand/unfollowdialog relevance controls, parent chat metadata, parent/thread prompt fallback, and thread-specific skill bindings. - Native Hermes
inlinetool for current-chat/thread reads, bounded history and search, exact message lookup, button-message sends, editing/deleting bot-owned messages, reactions, pin/unpin/list pins, reply-thread creation, top-level thread/chat creation outside the current conversation, and avatar presence/status. - Cached, privacy-safe sender names/usernames plus chat/thread IDs, selective reply/thread/observed context, and parent-thread context, with first-name/username Markdown mention guidance and current chat/thread links.
- OpenClaw-style entity summaries for live turns and tool-fetched history, including mentions, text links, thread links, thread-title links, code/pre blocks, bot commands, and group mentions as untrusted Hermes context.
- DM and group policies, user allowlists, group sender allowlists, mention requirements, strict mention mode, allowed chats, and free-response chats.
- Native Inline
/command-menu sync for Hermes slash commands, including/threads,/follow,/unfollow,/inline_sync,/inline_version, and/update; typed slash commands continue to work even if menu sync is disabled or rejected. - Inline-native buttons for clarify prompts, command approvals, slash confirmations, and model selection.
- Agent-created
send_message/edit_messagebutton rows with opaque callback data. A callback is acknowledged after its target and access checks succeed, then enters Hermes as a normal turn naming the source message and exact action fields. The normal response edits that source message and clears omitted buttons; the agent can instead calledit_messagewith replacement buttons and finish withNO_REPLYso the explicit edit remains authoritative. - Message widgets: sandboxed HTML (charts, diagrams, mockups, small pickers) through the
inlinetool'ssend_widgetaction, or an<iframe title="…" id="…" height="…">HTML</iframe>block in a Markdown reply. Long replies are split around widgets, never inside one, with at most one widget per message; a widget longer than the 4,000-character chunk goes alone, up to Inline's 100,000-character limit. Streaming previews hide a widget until its closing tag arrives.send_widgetreturns Inline's reason when the server rejects a widget. A viewer'sinline.action(name, payload)call becomes a turn naming the widget ID, call name, and untrusted JSON payload, and the answer replies below the widget instead of replacing it. Call names and payloads need realtime SDK 0.0.22 or later; with an older bundled SDK, the turn names only the widget. - Outbound local photo, video, voice, and document uploads with configurable size caps.
- Inbound photo, video, voice, and document summaries, with URL-backed media cached locally for Hermes when available.
- Opt-in reactions (
reaction_triggers) and lifecycle/system events as synthetic Hermes messages that need no reply and keep the conversation's cached agent. - Cron or standalone sends through
INLINE_HOME_CHANNELandhermes send --to inline:<chat-id>. - Hermes-native
typing_indicatorandgateway_restart_notificationtoggles, with plugin-owned YAML bridge coverage for external-plugin compatibility. - Detailed and Friendly output (the bot's Output setting in Inline; see Output below): a live, collapsible progress message for each turn, or short updates instead.
Unsupported or intentionally limited:
- Multiple Inline accounts in one Hermes process. Run separate Hermes instances for separate tokens.
- Inline member, space, and admin tools beyond bounded current-chat/thread message access.
- Full Inline rich-text span conversion. Outbound formatting uses Inline's bounded Markdown surface; rich entities are summarized for the agent instead of converted into Hermes-specific spans. Parsing is enabled by default, while disabling it preserves the supplied syntax literally.
- Native animated draft streaming. Inline can stream by sending one preview message and editing it, but this edit-based streaming path is off by default like Discord and Slack.
- Ephemeral in-channel private replies. Private notices are sent as DMs when a user id is available.
- Live voice sessions or calls. Voice file messages are supported, but realtime audio is not.
- Media without a usable Inline CDN/local URL. Those messages still produce text summaries, but Hermes may not receive a local file path.
- Progress for turns Hermes starts on its own. Scheduled (cron) turns and late background sub-agent results post only their answer.
Release 1.2.6
Hermes keeps its cached agent and warm prompt cache from one Inline message to
the next. The triggering message ID, a mentioned Inline Agent and other
per-message details now ride the message instead of the system prompt, which
had changed on every turn. Reactions are opt-in through reaction_triggers
(INLINE_REACTION_TRIGGERS), following Hermes' Slack convention: off by
default, true for any emoji on the bot's own messages, or an emoji list for
those emoji on any message. With system_events on and reaction_triggers
unset, every reaction is still delivered. Reaction and system-event turns join
the conversation they belong to, need no reply, and keep its system prompt. A
mentioned Inline Agent's skill is named on every mention, so it can load after
the conversation's first message too.
Release 1.2.5
Hermes status lines (context pressure, compression, provider fallback) no
longer count as the answer: they fold into Detailed progress instead of closing
it early with "Worked for", and post silently in Friendly mode or outside a
turn. In Friendly mode, an answer Hermes delivered as an update between tools
is posted again as the answer, so it notifies, and the silent copy is removed.
Hermes' busy notice for a message sent mid-turn posts silently, and a Friendly
answer no longer waits on another chat's progress. Output mode changes made in
the apps or with inline bots settings apply from the bot's next turn, within
about 15 seconds. When the mode lookup fails in a new chat, the bot's last known
default applies instead of Detailed.
Release 1.2.4
Progress no longer notifies or adds unread badges. Hermes' "⏳ Working" heartbeat, and commentary between tool calls outside Detailed mode, post silently; with an Inline server from 2026-11-20 or later they also skip unread. Approval prompts, messages with buttons, and the answer still notify. The sidecar's error telemetry keeps at most 256 deduplication entries. 1.2.3 was tagged but never published.
Release 1.2.2
The Agent Settings sheet can open while Hermes is handling a message in the same chat or while all ordinary message handlers are busy. The sidecar reserves four SDK handler slots for settings requests and changes. Requests in the same chat retain their order.
Release 1.2.1
Messages containing Unicode line or paragraph separators now reach the gateway
intact. A stalled inbound reader reconnects and receives its outstanding
deliveries. The authenticated sidecar health response includes their kind, age
in milliseconds, and write count under result.inbound.pending. Chat access
updates preserve order within their chat and the user cursor while other chats
continue receiving messages.
npm install -g @inline-chat/[email protected]
inline-hermes install --forceRestart the Hermes gateway to load the installed adapter.
Release 1.2.0
Work shows in two output modes, Detailed and Friendly, chosen per chat in
Inline's agent settings; Detailed no longer repeats the still-working notice.
The plugin manifest declares its activity hooks, and the bundled sidecar speaks
the focus status protocol. Tested on Hermes 0.23.0.
npm install -g @inline-chat/[email protected]
inline-hermes install --forceRelease 1.1.0
Command approvals show Allow and Deny buttons again on every supported Hermes. A
tap answers only the request its card was sent for, and on Hermes versions with
approvals.approvers only the people that setting allows can answer. Hermes now
writes the card, so a long command arrives in full before its buttons. Gateways
with many Inline bots no longer hang during startup or keep the old process alive
on restart. Scheduled posts can mention their recipient with cron_mention_prefix
(see Scheduled mentions below). The agent settings show how full the session's
context window is, which Inline's composer draws as its context circle. When a
later part of a long reply is refused, the parts already sent are no longer posted
again as a plain-text copy. Tested on Hermes 0.23.0.
npm install -g @inline-chat/[email protected]
inline-hermes install --forceRelease 1.0.0
A major release with breaking changes. Bots join a thread through its first
message, and later mentions get one answer. Leading mentions and replies decide
who a message is for. Reply threads are Auto or On per chat, DMs included, with
one thread per conversation. Each Hermes 0.22 profile keeps its own bot, state
and sidecar. Agents can follow, unfollow and manage chats, and they show Working
while they work. Status and doctor report whether messages reach the agent. See
"Upgrading to 1.0" in the Hermes docs for every
change. Hermes 0.22.6 and later need 1.0.0: they refuse every message from
earlier adapters with "Hermes refused this message (invalid_params)". Pinned
realtime SDK 0.0.20.
npm install -g @inline-chat/[email protected]
inline-hermes install --forceInstall
npm install -g @inline-chat/hermes-agent-adapter
inline-hermes install
hermes plugins enable inline-platform
hermes gateway setupWhen installation runs as root but the Hermes home belongs to its service user, the installer automatically aligns the plugin directory ownership with that service user. Use the same service user and Hermes home when applying manual npm updates.
Select Inline in the messaging-platform picker. The default path is: go to Inline → Settings → Bots → Create a new bot, then paste its token. See the Inline bot creation guide. The optional CLI path can install/sign in to the Inline CLI and create the bot from the terminal. Both paths securely save the token and configure access.
Coding Agent Setup Prompt
For an existing server or Umbrel installation, follow the remote Hermes setup guide. Run setup in the existing container as its service user with the same persisted Hermes home and profile. The guide includes a copyable coding-agent prompt, persistent installation paths, browser approval over SSH, and live verification.
After signing in with inline login --browser --no-open, the CLI can configure
the channel without putting tokens in command arguments:
inline agents setup --target hermes --dry-run --non-interactive --json
inline agents setup --target hermes --non-interactive --jsonAdd --profile NAME for an existing named profile. Preserve the existing
models, memory, skills, and channels. Do not read or print .env files or
secrets. A dry-run or credential probe is not proof of a live reply; verify
the running gateway and a final response in Inline.
For local development:
cd plugins/hermes-agent
bun run build
node dist/install.js install --link --hermes-home ~/.hermes
cd ~/dev/hermes-agent
uv run ./hermes plugins enable inline-platformCheck an installation:
inline-hermes doctor --json
hermes inline status --json --probe
hermes gateway status
inline-hermes --versionHermes publishes its installed skill catalog to Inline on gateway connect.
Running Hermes' /reload-skills now republishes both the native command menu
and skill catalog through the adapter's live refresh hook. From an authorized
Inline chat, /inline_sync is the direct recovery command for the same full
republish. After it succeeds, open or reopen Inline's Skilled Agent editor to
load it. /inline_version reports the loaded plugin and Hermes versions, the
installed/updated filesystem timestamp when available, and the last
in-process catalog-sync result without exposing paths, tokens, or config.
The Inline CLI can drive Hermes setup without putting the bot token in argv:
inline agents setup --target hermes --non-interactive --jsonFor other orchestrators, the plugin also exposes a token-free machine contract. The token is accepted only on stdin and is saved through Hermes's credential helper:
printf '%s\n' "$INLINE_BOT_TOKEN" | hermes inline setup \
--non-interactive --token-stdin --owner-user-id 123 \
--access owner --json
hermes inline status --json --probedoctor verifies required plugin files, the Node executable used for the
sidecar, the installed sidecar bundle hash, and whether Hermes config enables
the external plugin with plugins.enabled: [inline-platform]. It detects
Inline credentials from the current environment, Hermes config, or the managed
credential store used by hermes gateway setup, without printing token values.
It honors INLINE_NODE_BIN and fails if that explicit path is missing, not
executable, older than Node 20, or cannot report a Node version. It also fails
if a copied plugin has drifted from the package bundle.
Confirm Hermes sees the plugin:
cd ~/dev/hermes-agent
uv run ./hermes plugins list --plain --no-bundledExpected local output includes:
enabled user 1.0.0 inline-platformUpdate Or Reinstall
After upgrading the npm package, refresh the installed Hermes plugin copy:
npm install -g @inline-chat/hermes-agent-adapter@latest
inline-hermes install --force
inline-hermes --version
inline-hermes doctor --jsoninstall --force replaces the copied plugin files under
~/.hermes/plugins/inline or refreshes a dev symlink target. It does not edit
config.yaml, tokens, or other Hermes state. If doctor reports a sidecar hash
mismatch, rerun the same command after rebuilding or upgrading the package.
Compatibility
- Hermes Agent: requires the external user plugin registry and native platform
plugin loader available in Hermes Agent
>=0.21.3. This package was validated against Hermes Agent0.23.0from source commit2bd378ed1b8d6bf2192cb26e0a55ff3091e6bd19(tagv0.23.0), and installs on the minimum0.21.3. Hermes0.22.6and later refuse every message from adapters before1.0.0; upgrade as in Release 1.0.0 above. - CI checks the minimum supported Hermes release, newest stable source, and upstream
main, including a full inbound turn through Hermes' production gateway. A six-hour scheduled check also tests the published npmlatestadapter.inline-hermes doctorrequires successful host loading and compatibility validation; unavailable Hermes diagnostics no longer count as healthy. - Node.js:
>=20is required for the bundled sidecar. Hermes-managed Node 22, system Node, or an explicitINLINE_NODE_BINpath all work. - Inbound recovery retries without waiting for another message or reconnect. Independent chats are consumed concurrently; same-chat order and delivery acknowledgements are preserved. Sender provenance lookups start with a short timeout and expand up to the existing SDK ceiling after timeouts; deferred inputs stay recoverable. Stream replacement wakes pending backpressure writes.
- The 1.2.6 sidecar bundles
@inline-chat/[email protected]and protocol0.0.17. The catalog and npm package ship the same sidecar. - Live sends require a valid Inline user or bot token in
INLINE_TOKEN,INLINE_BOT_TOKEN,platforms.inline.token, orinline.token.
Use hermes plugins list --plain --no-bundled to verify external plugin
registration. Other Hermes channel listings may be limited to bundled platforms
depending on the Hermes version, but hermes send --to inline:<chat-id> ...
and the gateway path load the external plugin through Hermes' platform registry
after hermes plugins enable inline-platform.
Maintainer Preflight
Before publishing, run:
bun run release:preflightThis creates an isolated registry-dependency stage, runs the full package
check, packs one read-only tarball, and runs npm publish --dry-run against
those exact bytes. It prints the artifact path, SHA-256, and file list so the
trusted-publishing workflow can hash-check and publish the same artifact.
Maintainers should also run the manual live-test and publish checklist in
plugins/hermes-agent/RELEASE.md.
Smoke Test
Dry-run mode validates target parsing and package wiring without a token:
inline-hermes test-send --dry-run --to chat:123 --text "Inline Hermes dry-run" --jsonWith a valid Inline bot or user token in the environment or Hermes config,
test-send starts the bundled sidecar on a loopback port, waits for realtime
readiness, sends one message, and shuts the sidecar down:
export INLINE_TOKEN="<token>"
inline-hermes test-send --to chat:123 --text "Inline Hermes test"Use --json for automation. Tokens are read from INLINE_TOKEN,
INLINE_BOT_TOKEN, platforms.inline.token, or inline.token; the CLI
intentionally does not accept token arguments. If the token is expired or
revoked, the JSON issues array includes the server connection reason, for
example SESSION_REVOKED.
Configure
Set an Inline token in the Hermes gateway environment:
export INLINE_TOKEN="<token>"Then enable the platform in Hermes config:
platforms:
inline:
enabled: trueOutput: Detailed or Friendly
Each bot has an Output setting in Inline (the bot's chat settings), with a
per-chat override. The adapter reads it at the start of every turn (cached for
30 seconds per chat) and declares the OUTPUT_MODE capability so Inline offers
the setting. An unset setting means Detailed.
- Detailed: while Hermes works, one progress message ("Working · 1m 4s") shows each step as a row: commands with their output tail and exit code, files read and searched, edits with their diff, web searches, plans, sub-agents with their own steps nested inside, and approvals waiting on someone. Hermes' commentary between tool calls appears inside it too, and its "still working" notice is left out since the timer already shows it. When the answer is ready the message collapses to "Worked for 1m 4s" and the answer follows as its own message. A message someone sends mid-turn ends the progress message there; later work starts a new one.
- Friendly: no progress message. Hermes' commentary between tool calls posts as short updates, Hermes' "⏳ Working — 3 min" notice keeps a long turn visibly alive (removed once the turn succeeds), then the answer.
Approvals, questions and errors look the same in both modes. Output tails are capped at 2,000 characters and diffs at 8,000, and values that look like secrets are hidden. Row titles come from the tool, never from its output.
This runs entirely on Hermes' public plugin hooks (pre_tool_call,
post_tool_call, subagent_start/subagent_stop,
pre_approval_request/post_approval_response) and its interim-message
contract. Turns Hermes starts on its own, such as scheduled (cron) runs, have no
processing hooks and post only their answer.
The old experimental timeline is gone: INLINE_EXPERIMENTAL_AGENT_ACTIVITY is
ignored and logs a warning when enabled.
Inline's display defaults keep Hermes' own tool-progress bubbles off
(tool_progress: off) and turn on interim_assistant_messages, which the
Output setting then shows as Detailed commentary or Friendly updates. Explicit
Hermes display settings still take precedence: turning tool_progress on adds
Hermes' own progress bubbles on top of Detailed output, and turning
interim_assistant_messages off hides commentary in both modes. Token streaming
remains opt-in through both streaming.enabled: true and
display.platforms.inline.streaming: true.
Hermes-native sends and scheduled deliveries accept Inline's explicit target
forms: a bare positive ID or chat:ID for a chat, thread:ID for a routable
reply thread, and user:ID for a direct user target. IDs are validated as
positive signed 64-bit integers before delivery. The parser hooks activate on
Hermes versions that expose the native plugin target-resolution contract.
Hermes also accepts a top-level inline: block for plugin-owned settings, but
platforms.inline matches the shape used by most Hermes platform docs and is
the safest form to copy into ~/.hermes/config.yaml.
If you intentionally keep the token in config.yaml instead of the gateway
environment, set platforms.inline.token directly. The adapter also accepts
inline.token and simple ${ENV_NAME} references in either token field,
resolving them from the process environment at runtime. Environment variables
remain the preferred production path for secrets.
Access control follows Hermes' native platform model:
| Setting | Purpose |
| --- | --- |
| INLINE_ALLOWED_USERS | Comma-separated Inline user ids allowed to DM the bot. Setting this also makes the adapter treat DMs as allowlisted unless INLINE_DM_POLICY is set. |
| INLINE_ALLOW_ALL_USERS=true | Explicit Hermes gateway allow-all switch for Inline. Use only for trusted/dev deployments. |
| INLINE_DM_POLICY=open|allowlist|disabled | Controls direct-message intake. allowlist requires INLINE_ALLOWED_USERS or config allow_from. |
| INLINE_GROUP_POLICY=open|allowlist|disabled | Controls group intake. allowlist requires INLINE_GROUP_ALLOW_FROM. |
| INLINE_GROUP_ALLOW_FROM | Comma-separated Inline user ids allowed to invoke the bot from group chats. |
| INLINE_REQUIRE_MENTION | Requires an @mention in groups by default. Replies to the bot and dialogs already marked FOLLOWING are accepted without one. Hermes never wakes on words such as its name; only structured Inline mentions, replies, followed dialogs and commands count. |
| INLINE_STRICT_MENTION | Requires an @mention on every group turn, including replies to the bot and followed threads. Defaults to false. |
| INLINE_ALLOWED_CHATS | Comma-separated group/thread chat ids where the bot may respond. Parent chat ids also match their Inline reply threads. DMs are not filtered. Empty means no chat restriction. |
| INLINE_FREE_RESPONSE_CHATS | Comma-separated group/thread chat ids where no mention is required. Parent chat ids also match their Inline reply threads. Useful for dedicated agent rooms. |
| INLINE_REPLY_THREADS | Retired in 1.0; the default is always Auto: answers stay in the chat, and a thread starts only when someone asks for one. Turn On per chat (DM or group) with /threads on, the agent settings, or by asking the agent. on here is read as Auto with a warning, so a new tab's first message never gets a thread; off reads as Auto. Existing threads always keep their conversation. |
| INLINE_CONTEXT_BACKFILL | Automatic context mode. selective is the default, off disables automatic history windows, and always restores recent-history backfill on every turn. |
| INLINE_THREAD_CONTEXT_LIMIT | Max current chat/thread messages for selective thread or mention-gap context. Must be 0 through 100; defaults to 30. |
| INLINE_REPLY_CONTEXT_LIMIT | Max messages in the anchored window around a replied-to Inline message. Must be 0 through 50; defaults to 10. |
| INLINE_OBSERVED_CONTEXT_LIMIT | Max unmentioned group messages kept in the observed-context buffer. Must be 0 through 100; defaults to 20. |
| INLINE_OBSERVE_UNMENTIONED_MESSAGES | Buffers unmentioned group messages that pass chat/user policy but do not wake the bot. Defaults to true; set to false to disable. |
| INLINE_CONTEXT_HISTORY_LIMIT | Legacy compatibility shortcut. 0 maps to INLINE_CONTEXT_BACKFILL=off; 1 through 20 maps to always with that thread-context limit. Prefer the explicit settings above. |
| INLINE_SETTINGS_PATH | JSON settings file for per-chat /threads overrides. /threads shows native Auto/On buttons; reset clears the chat override back to the global default. Defaults next to INLINE_STATE_PATH; .env-like paths are refused. |
| INLINE_SYSTEM_EVENTS | Delivers Inline lifecycle events such as edits, deletes, and participant changes as synthetic messages. Defaults to false. With it on and INLINE_REACTION_TRIGGERS unset, every reaction is delivered too. |
| INLINE_REACTION_TRIGGERS | Which reactions start a Hermes turn, like Hermes' Slack reaction_triggers. Unset or false: none (the default). true: any emoji on the bot's own messages. A list such as 👍,✅: those emoji on any message. A reaction turn needs no reply. |
| INLINE_REACTIONS | Shows 👀 while Hermes handles an inbound message, then ✅ on success or ❌ on failure. Cancellation clears the working marker. Defaults to false. |
| INLINE_CRON_MENTION_PREFIX | Opt-in Inline Markdown mention prepended once to scheduled gateway text deliveries, for example [@You](inline://user?id=42). Defaults to empty. See Scheduled mentions. |
| INLINE_PARSE_MARKDOWN | Controls whether supported outbound Inline Markdown is parsed. Defaults to true; false preserves the supplied syntax literally. |
| INLINE_SYNC_COMMANDS | Syncs Hermes slash commands into Inline's native / bot command menu on gateway connect. Defaults to true. |
| INLINE_COMMAND_LIMIT | Caps native Inline bot command sync. Must be 1 through 100; defaults to 100. |
| INLINE_MEDIA_MAX_MB | Maximum inbound media download size for URL-backed Inline attachments. Defaults to 25. |
| INLINE_UPLOAD_MAX_MB | Maximum outbound local file upload size. The Python adapter and Node sidecar both enforce it before upload bytes are read. Defaults to 300. |
| INLINE_STATE_PATH | Persistent Inline SDK state file. Defaults to one file per profile and bot under the profile's inline/ folder. The default profile reuses the older shared ~/.hermes/inline/sdk-state.json once; other profiles catch up from now. |
| INLINE_RPC_TIMEOUT_MS | Realtime RPC timeout for the Node sidecar. |
| INLINE_CONNECT_TIMEOUT_MS | Adapter startup timeout while waiting for the sidecar to become realtime-ready. Defaults to 20000. |
| INLINE_CONNECT_RETRY_INITIAL_MS | Initial sidecar retry delay after realtime startup failure. Defaults to 1000. |
| INLINE_CONNECT_RETRY_MAX_MS | Maximum sidecar retry delay after repeated realtime startup failures. Defaults to 15000. |
| INLINE_SIDECAR_PORT | Fixed loopback port for the sidecar. Must be 1 through 65535. Defaults to a free port per adapter, so several profiles can share one gateway; 8794 when INLINE_SIDECAR_AUTOSTART=false. |
| INLINE_SIDECAR_BIND | Sidecar bind host. Must be loopback: 127.0.0.1, localhost, or ::1. Defaults to 127.0.0.1. |
| INLINE_HERMES_SENTRY_DSN | Explicitly enables adapter and sidecar error reporting to the configured collector. Reporting is disabled when unset. |
| INLINE_PLUGIN_TELEMETRY | Set to off, 0, or false to disable explicitly configured plugin error reporting. DO_NOT_TRACK=1 is also honored. |
| platforms.inline.typing_indicator | Hermes-native toggle for Inline typing/presence while a turn is running. Defaults to true; set to false to keep busy threads visually quiet. |
| platforms.inline.gateway_restart_notification | Hermes-native toggle for gateway online/restarted notices. Defaults to true. |
Policy is evaluated in three ordered stages: access, then wake, then delivery. Access checks the chat and sender policy and is a hard gate; a mention, reply, callback, or command never grants access to a blocked chat or actor. Wake decides whether an allowed group turn invokes Hermes: free-response chats wake normally, while mention-gated chats require an explicit mention unless a configured reply-to-bot or followed-thread exception applies. Delivery keeps existing child-thread conversations in place; in a chat set to On a top-level message gets its answer in a reply thread, and in Auto it stays in the chat unless someone asks for a thread. A thread under the bot's DM stays that DM for its person: DM access, no mention needed, and one session (dm:<dm>:<thread>, like a Slack DM thread). Anyone else in that thread keeps group rules.
open controls intake; it does not grant permission to use the bot. After
Inline's sender and group/thread restrictions pass, the adapter asks Hermes'
registered authorization callback before executing local commands, creating
reply threads, downloading media, collecting context, or exposing runtime
settings. This uses the same pairing and profile-aware authorization as native
Hermes adapters. An unapproved sender reaches Hermes' pairing or rejection
flow with a minimal text event and no preceding adapter mutations or media work.
Pairing approval does not override an explicit Inline allowlist, disabled
policy, or excluded group. DMs remain exempt from allowed_chats.
Child-thread authorization preserves both the child and parent chat IDs so
Hermes can select the correct profile. If required group metadata is unavailable,
the adapter denies the operation instead of guessing a profile. Controls that
change the parent's reply-thread mode also require access to that parent, and
follow Hermes' own slash-command access: when allow_admin_from or
group_allow_admin_from is set, only admins and people allowed to run
threads (user_allowed_commands) can change it, from /threads, the settings
card, or by asking the agent;
thread-local model and following settings remain available to an authorized
child-thread user.
Equivalent Hermes YAML can use allow_from, allowed_users,
group_allow_from, dm_policy, group_policy, require_mention,
strict_mention, allowed_chats, free_response_chats, reply_threads,
context_backfill, thread_context_limit, reply_context_limit,
observed_context_limit, observe_unmentioned_messages, settings_path,
system_events, reaction_triggers, and reactions under the Inline platform config. Operational settings such
as base_url, parse_markdown, media_max_mb, upload_max_mb,
state_path, sidecar_port, connect_timeout_ms, sync_commands,
cron_mention_prefix, and command_limit can also be set there.
Prefer Hermes YAML for behavioral settings. Environment variables remain supported for compatibility and secret-backed deployment inputs.
Use a JSON list for mention regexes that contain commas, for example
["hermes\\b[:,]?"].
Inline also supports Hermes' native thread/channel prompt and skill bindings. Use raw Inline chat/thread ids for these bindings. Inline reply-thread chats are checked first, then their parent chat id:
platforms:
inline:
channel_prompts:
"123": "Treat this Inline thread as the customer escalation room."
channel_skill_bindings:
- id: "123"
skills: ["support-triage", "incident-report"]Inline-native button callbacks, including approvals, clarify choices,
model pickers, and thread controls, use the same local restrictions and Hermes
authorization callback. Pairing-approved users can use them without a second
Inline allowlist. A denial, error, or unknown result from a registered callback
blocks the action. Only standalone adapters without a registered callback use
explicit Inline/global allowlists or allow-all settings as a fallback; open
alone never authorizes controls. Settings requests from unauthorized users show
an access guide without runtime or model information.
Adapter-owned controls use system: action IDs and stay in these deterministic
handlers. Agent-authored callbacks use agent: IDs and follow the ordinary
message intake policy because they are conversational input, not approval or
gateway-control input. Callback data is always presented to the model as
untrusted data and cannot become a Hermes slash command.
On gateway startup, the adapter derives the Inline / menu from Hermes'
declarative local command registry plus Hermes' central slash-command registry,
normalizes names to Inline Bot API constraints
(^[a-z0-9_]+$, max 32 characters), and calls setMyCommands. If Inline
rejects the full list with BOT_COMMANDS_TOO_MUCH, the adapter retries with a
smaller prefix. Menu sync failures are logged as warnings and do not prevent
message transport; /commands remains the full fallback list. In chats with
multiple bots, Inline may insert /command@botusername to disambiguate a menu
choice. Hermes accepts that form only when the suffix matches its own username,
then removes the suffix before command dispatch; commands addressed to another
bot are ignored.
Plugin updates are managed on the Hermes host. For a catalog installation, use
hermes plugins update inline-platform after a new reviewed catalog pin is
available, then restart the gateway. For an npm installation:
npm install -g @inline-chat/hermes-agent-adapter@latest
inline-hermes install --forceRestart the gateway after refreshing the plugin. Version 0.0.19 removes the
in-chat updater so the same plugin can comply with the catalog's exact-commit
trust policy. Hermes's own /update command is unchanged.
Run /follow in an Inline group or reply thread to opt into eligible
unmentioned activity waking Hermes, and /unfollow to opt out; mentions and
replies still reach it. The agent can do the same itself with the inline
tool's set_follow_mode action. A message that starts by mentioning someone
else isn't for Hermes, even if it mentions Hermes later, and a reply to another
person or bot doesn't wake it unless it mentions Hermes.
The model-callable inline tool keeps reply and top-level creation separate:
create_thread creates a reply subthread under the current or explicit parent
chat, while create_chat creates a new top-level destination. create_chat
requires a title, defaults to private, accepts optional participant user IDs or
a parent space ID, and requires both space_id and explicit is_public: true
for space-wide visibility. It returns the new chat ID so Hermes can link it in
the normal reply. Omitted or empty private participants create a conversation
accessible only to the connected account. Include intended human participants
explicitly; owning the bot does not grant membership in its private conversations.
When a person asks for a private chat, create_chat adds them automatically;
pass include_requester: false for a deliberately bot-only chat. A thread that
create_thread starts from the current message hangs off that message only in
its own chat; another parent needs an explicit parent_message_id.
add_participants, update_chat (title or emoji) and delete_chat manage
chats through the same server operations as the apps, so the server decides
what the bot may change. delete_chat always needs an explicit chat_id.
The plugin id is inline, which is intentionally the same id an eventual
bundled Hermes adapter should use.
Scheduled mentions
To bring scheduled text posts back into your Inline sidebar, configure a mention for the person who should receive them, then restart the Hermes gateway:
platforms:
inline:
cron_mention_prefix: "[@You](inline://user?id=42)"Replace 42 with that person's Inline user ID. This setting applies to this
profile's scheduled gateway text deliveries; set it to "" to disable it,
including when INLINE_CRON_MENTION_PREFIX is exported. A structured mention
can reopen an eligible recipient's closed thread. Their notification settings
still apply.
The adapter uses Hermes' job_id delivery metadata to identify scheduled posts.
It adds the prefix before splitting a long post and skips an existing leading
prefix. cron.delivery.notify: false suppresses the added prefix and sends the
text silently, using Inline's existing notification opt-out. Ordinary replies
do not get a prefix, and the selected destination stays the same. Markdown
parsing must be enabled (the default); with parse_markdown: false the setting
is ignored with a warning, preserving the caller's literal text.
Hermes currently omits cron identity from standalone/CLI fallback and media-only sends. Those deliveries remain unchanged. Media accompanied by scheduled text gets the mention in the text post. The required upstream metadata extension is described in Hermes upstream seams.
Shared transcripts in groups and threads
To share one conversation transcript among admitted participants in a group
or thread, add these keys at the root of the config.yaml used by the Hermes
gateway process, outside platforms.inline.extra:
group_sessions_per_user: false
thread_sessions_per_user: falseHermes defaults group_sessions_per_user to true (groups split by sender)
and thread_sessions_per_user to false (threads shared). These settings
affect every messaging platform governed by that gateway configuration.
For separate profile gateways, configure each gateway's profile separately.
With a multiplexed gateway, do not assume a secondary profile's values control
its sessions; this adapter does not qualify per-profile session-policy overrides.
Distinct Hermes profile/gateway namespaces keep separate conversation sessions. Swapping a bot token within one profile does not create a new transcript namespace. These flags select shared sessions; they do not merge existing histories, import all Inline history, grant permissions, or change access, mention, or bot wake rules. Restart the gateway through its existing process manager after editing.
Error Reporting And Privacy
The Inline adapter and its supervised sidecar keep error reporting disabled
unless the operator sets INLINE_HERMES_SENTRY_DSN to an explicit collector.
When enabled, reports include the raw exception type and message, traceback
paths, line/function locations, plugin release,
operation name, runtime, OS, and architecture so maintainers can diagnose
failures in subsequent releases.
Reports do not attach Inline or Hermes message events, request bodies, user/chat/account identifiers, breadcrumbs, source context, or stack locals. Known token, password, authorization, sidecar credential, and secret-shaped values are redacted before upload. Inline's Sentry project also enables default server-side data scrubbing and IP-address scrubbing. Because dependency exception messages are preserved for diagnosis, they can still contain values the dependency itself chose to place in an error.
Remove INLINE_HERMES_SENTRY_DSN, set INLINE_PLUGIN_TELEMETRY=off, or set
DO_NOT_TRACK=1 to disable both adapter and sidecar reporting. Reporting is
best-effort, has a two-second network deadline, and never changes plugin success
or failure behavior.
Troubleshooting
Run inline-hermes doctor --json first. It checks the installed plugin path,
required files, Node executable, source/installed sidecar bundle hashes, and
whether an Inline token is available to Hermes.
plugin is not installed: runinline-hermes install.Hermes plugin 'inline-platform' is not enabled: runhermes plugins enable inline-platform.installed sidecar bundle does not match: re-runinline-hermes install --forceafter upgrading this package.node executable was not detected,INLINE_NODE_BIN does not exist, ormust be Node.js >=20: install Node.js 20+ or setINLINE_NODE_BINto the Node executable Hermes should use.SESSION_REVOKEDduringtest-send: the Inline token reached the realtime service but was rejected. Re-authenticate or rotate the bot/user token and retry.sidecar was not ready: inspect the JSONhealthandlogsfields fromtest-send --json; token, base URL, or realtime startup failures are exposed there with retry diagnostics.INLINE_SIDECAR_BIND must be loopback: remove the override or set it to127.0.0.1,localhost, or::1. The sidecar intentionally refuses externally reachable bind addresses even though its HTTP API is token-gated.
