npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2026 – Pkg Stats / Ryan Hefner

@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.

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 inline tool 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-send probes

Feature Support

Supported:

  • Install, status, doctor, dry-run, and live test-send commands.
  • External Hermes platform registration as inline.
  • INLINE_TOKEN, INLINE_BOT_TOKEN, platforms.inline.token, and inline.token auth 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 /follow and /unfollow dialog relevance controls, parent chat metadata, parent/thread prompt fallback, and thread-specific skill bindings.
  • Native Hermes inline tool 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_message button 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 call edit_message with replacement buttons and finish with NO_REPLY so the explicit edit remains authoritative.
  • Message widgets: sandboxed HTML (charts, diagrams, mockups, small pickers) through the inline tool's send_widget action, 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_widget returns Inline's reason when the server rejects a widget. A viewer's inline.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_CHANNEL and hermes send --to inline:<chat-id>.
  • Hermes-native typing_indicator and gateway_restart_notification toggles, 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 --force

Restart 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 --force

Release 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 --force

Release 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 --force

Install

npm install -g @inline-chat/hermes-agent-adapter
inline-hermes install
hermes plugins enable inline-platform
hermes gateway setup

When 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 --json

Add --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-platform

Check an installation:

inline-hermes doctor --json
hermes inline status --json --probe
hermes gateway status
inline-hermes --version

Hermes 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 --json

For 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 --probe

doctor 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-bundled

Expected local output includes:

enabled      user     1.0.0    inline-platform

Update 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 --json

install --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 Agent 0.23.0 from source commit 2bd378ed1b8d6bf2192cb26e0a55ff3091e6bd19 (tag v0.23.0), and installs on the minimum 0.21.3. Hermes 0.22.6 and later refuse every message from adapters before 1.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 npm latest adapter. inline-hermes doctor requires successful host loading and compatibility validation; unavailable Hermes diagnostics no longer count as healthy.
  • Node.js: >=20 is required for the bundled sidecar. Hermes-managed Node 22, system Node, or an explicit INLINE_NODE_BIN path 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 protocol 0.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, or inline.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:preflight

This 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" --json

With 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: true

Output: 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 --force

Restart 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: false

Hermes 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: run inline-hermes install.
  • Hermes plugin 'inline-platform' is not enabled: run hermes plugins enable inline-platform.
  • installed sidecar bundle does not match: re-run inline-hermes install --force after upgrading this package.
  • node executable was not detected, INLINE_NODE_BIN does not exist, or must be Node.js >=20: install Node.js 20+ or set INLINE_NODE_BIN to the Node executable Hermes should use.
  • SESSION_REVOKED during test-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 JSON health and logs fields from test-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 to 127.0.0.1, localhost, or ::1. The sidecar intentionally refuses externally reachable bind addresses even though its HTTP API is token-gated.