@moikapy/lich 0.6.0 → 0.7.1

package/docs/user-guide/gateway.md

@@ -27,37 +27,54 @@ lich gateway                         # defaults to webhook
 
 The gateway is silent after startup: Telegram/Discord/Twitch respond only in chats, channels, or servers the bot can see or has joined, and the webhook only serves HTTP. Telegram media messages arrive as the placeholder text `media not supported yet`; other non-text events are ignored. Telegram `/start` is answered like a plain "hello".
 
+**Security defaults:** the webhook binds loopback only; Telegram/Discord/Twitch default-deny until you configure allowlists; the gateway agent uses a read-only tool subset (no `terminal`, no file writes) unless you override `gateway.tools_enabled`.
+
 ## Setup: webhook
 
-Zero configuration — the server binds `0.0.0.0:$LICH_GATEWAY_PORT` (default 8089).
+Zero configuration for local use — the server binds `127.0.0.1:$LICH_GATEWAY_PORT` (default 8089). Set `LICH_GATEWAY_HOST` only when you intentionally expose the port.
 
 ```sh
 lich gateway webhook
 ```
 
 ```sh
-curl -s -X POST http://localhost:8089/message \
+curl -s -X POST http://127.0.0.1:8089/message \
   -H "content-type: application/json" -d '{"text": "hello"}'
 # -> {"reply":"...","usage":null}
 
-curl -s http://localhost:8089/health
+curl -s http://127.0.0.1:8089/health
 # -> {"status":"ok"}
 ```
 
+To bind a non-loopback address you **must** set a token; otherwise the adapter refuses to start:
+
+```sh
+LICH_GATEWAY_HOST=0.0.0.0 LICH_GATEWAY_TOKEN=s3cret lich gateway webhook
+```
+
 With token auth, every POST must carry the exact `x-lich-token` header; mismatched or missing tokens get `401 {"error":"unauthorized"}`:
 
 ```sh
 LICH_GATEWAY_TOKEN=s3cret lich gateway webhook
-curl -s -X POST http://localhost:8089/message \
+curl -s -X POST http://127.0.0.1:8089/message \
   -H "x-lich-token: s3cret" -H "content-type: application/json" -d '{"text": "hello"}'
 ```
 
-Payload fields (all optional except `text`): `platform` (default `"webhook"`), `chat_id` (default `"default"`), `user_id` (default `"anonymous"`), `text` (required; missing `text` is a `400`). Use distinct `chat_id` values to keep independent conversation memories.
+Payload fields (all optional except `text`): `chat_id` (default `"default"`), `user_id` (default `"anonymous"`), `text` (required; missing `text` is a `400`). A `platform` field in the body is **ignored** — conversations are always keyed as `webhook:<chat_id>`. Use distinct `chat_id` values to keep independent conversation memories.
 
 ## Setup: Telegram
 
 1. Message [@BotFather](https://t.me/BotFather) → `/newbot` → copy the token.
-2. Export it and run:
+2. Allow your user (and optionally chat) ids in config, export the bot token, and run:
+
+```json
+{
+  "gateway": {
+    "allowed_users": { "telegram": ["123456789"] },
+    "allowed_chats": { "telegram": ["123456789"] }
+  }
+}
+```
 
 ```sh
 export LICH_TELEGRAM_BOT_TOKEN=123456:ABC-your-token
@@ -66,14 +83,22 @@ lich gateway telegram
 
 3. Open your bot in Telegram, send a message, get a reply. Media messages arrive as the text `media not supported yet`; the bot replies from there.
 
-Telegram uses long polling (no public URL needed). Replies split at 4096 chars.
+Without `allowed_users` / `allowed_chats` for `telegram`, every inbound message is denied (default-deny). Telegram uses long polling (no public URL needed). Replies split at 4096 chars.
 
 ## Setup: Discord
 
 1. Create an application at the [Discord developer portal](https://discord.com/developers/applications), add a **Bot**, and copy the bot token.
 2. Enable the **Message Content Intent** (Bot settings → Privileged Gateway Intents) — the adapter requests intents `512 | 32768`, which includes message content.
 3. Invite the bot with the `bot` scope (OAuth2 → URL Generator; no extra permissions needed beyond sending messages in target channels).
-4. Export the token (and the bot's application/user id, so leading `<@BOT_ID>` mentions are stripped) and run:
+4. Allow channel and/or user ids in config, export the token (and the bot's application/user id, so leading `<@BOT_ID>` mentions are stripped) and run:
+
+```json
+{
+  "gateway": {
+    "allowed_chats": { "discord": ["123456789012345678"] }
+  }
+}
+```
 
 ```sh
 export LICH_DISCORD_BOT_TOKEN=your-bot-token
@@ -81,14 +106,23 @@ export LICH_DISCORD_BOT_ID=123456789012345678
 lich gateway discord
 ```
 
-5. Send the bot a message (DM or any channel it can read — every non-bot message gets a reply); each channel has its own conversation memory (keyed by `channel_id`). Replies split at 2000 chars. Bot-authored messages are ignored (no loops).
+5. Send the bot a message in an allowed channel; each channel has its own conversation memory (keyed by `channel_id`). Replies split at 2000 chars. Bot-authored messages are ignored (no loops). Without allowlists for `discord`, every inbound message is denied.
 
 **Known limitation:** the Discord adapter has no reconnect resume. If its gateway WebSocket drops, messages sent while offline are missed permanently; the adapter reconnects fresh after 5s. If guaranteed delivery across disconnects matters, run webhook or Telegram instead.
 
 ## Setup: Twitch
 
 1. Generate an OAuth token with the `chat:read` and `chat:edit` scopes (for example via [twitchtokengen](https://twitchtokengen.com)).
-2. Export it, your bot account's nickname, and the channels to join (comma-separated, lowercased by the adapter):
+2. Allow channel names and/or viewer nicks in config, export credentials, and run:
+
+```json
+{
+  "gateway": {
+    "allowed_chats": { "twitch": ["channelone"] },
+    "allowed_users": { "twitch": ["trustedviewer"] }
+  }
+}
+```
 
 ```sh
 export LICH_TWITCH_OAUTH_TOKEN=oauth:abc123...
@@ -97,9 +131,28 @@ export LICH_TWITCH_CHANNELS=channelone,channeltwo
 lich gateway twitch
 ```
 
-3. The bot joins `#channelone` and `#channeltwo` and replies in chat (own messages are ignored). Replies split at 512 chars; IRC PING/PONG is answered automatically.
+3. The bot joins `#channelone` and `#channeltwo` and replies in chat only when the allowlist matches (own messages are ignored). Replies split at 512 chars; IRC PING/PONG is answered automatically.
+
+Only real chat messages count for the allowlist: the adapter strips optional IRC tags and then requires a full `PRIVMSG` line (`^:<nick>!... PRIVMSG #<channel> :<text>`), so Twitch events such as `USERNOTICE` (raids, subs) and `WHISPER` are ignored even if their text contains something that looks like a `PRIVMSG` — they can never impersonate an allowed user or channel.
+
+All three fields (`token`, `nick`, `channels`) are required — a missing one idles the adapter. Without allowlists for `twitch`, every inbound message is denied.
+
+## Allowlists and gateway tools
+
+Public platforms (telegram, discord, twitch) are **default-deny**. Configure at least one of:
+
+| Field | Meaning |
+| --- | --- |
+| `gateway.allowed_users.<platform>` | User ids (Telegram/Discord) or nicks (Twitch) that may talk to the bot. |
+| `gateway.allowed_chats.<platform>` | Chat / channel ids (or Twitch channel names) that may talk to the bot. |
+
+If both lists are set for a platform, a message must match **both**. If only one list is set, the other dimension is unrestricted. Enforcement lives in the shared gateway bus — denied senders get no agent run and no reply.
+
+The gateway agent ignores top-level `tools_enabled` and uses `gateway.tools_enabled`, which defaults to a read-only subset:
+
+`read_file`, `list_dir`, `grep_files`, `fetch_url`, `web_search`, `docs_read`, `docs_search`
 
-All three fields (`token`, `nick`, `channels`) are required — a missing one idles the adapter.
+Set `"gateway": { "tools_enabled": "all" }` (or an explicit name list) only when you intentionally want writes / `terminal` on chat platforms.
 
 ## Running multiple platforms at once
 
@@ -116,8 +169,9 @@ Adapters whose credentials are missing start **idle** (a warning is logged, e.g.
 
 | Variable | Default | Purpose |
 | --- | --- | --- |
+| `LICH_GATEWAY_HOST` | `127.0.0.1` | Webhook bind address. Non-loopback requires `LICH_GATEWAY_TOKEN`. |
 | `LICH_GATEWAY_PORT` | `8089` | Webhook server port (invalid/empty values fall back to 8089). |
-| `LICH_GATEWAY_TOKEN` | unset | If set, POST `/message` requires header `x-lich-token` to match; else 401. |
+| `LICH_GATEWAY_TOKEN` | unset | If set, POST `/message` requires header `x-lich-token` to match; else 401. Required for non-loopback binds. |
 | `LICH_TELEGRAM_BOT_TOKEN` | unset | Bot token from BotFather; adapter idles without it. |
 | `LICH_DISCORD_BOT_TOKEN` | unset | Bot token from the developer portal; adapter idles without it. |
 | `LICH_DISCORD_BOT_ID` | unset | Bot user id; strips a leading `<@id>` mention from messages. |
@@ -143,10 +197,10 @@ Provider/model configuration comes from the same resolution as every mode (`LICH
 Request:
 
 ```json
-{"text": "hello", "platform": "webhook", "chat_id": "default", "user_id": "anonymous"}
+{"text": "hello", "chat_id": "default", "user_id": "anonymous"}
 ```
 
-Only `text` is required. Success (`200`):
+Only `text` is required. Any `platform` field in the body is ignored; the conversation key is always `webhook:<chat_id>`. Success (`200`):
 
 ```json
 {"reply":"Hello! How can I help you today? ...","usage":null}
@@ -165,4 +219,4 @@ Agent-level failures (e.g. every provider failed) return `200` with `reply` set
 
 ### `GET /health`
 
-`200 {"status":"ok"}` unconditionally — the webhook server itself is alive; it does not reflect platform adapters or provider health.
+`200 {"status":"ok"}` unconditionally — the webhook server itself is alive; it does not reflect platform adapters or provider health.

package/docs/user-guide/godot.md

@@ -4,6 +4,8 @@
 
 lich is the AI brain in a separate process. Godot speaks HTTP. This page is the recipe; the file contract and tool list live in [`examples/game_bridge/README.md`](https://github.com/Moikapy/lich/blob/main/examples/game_bridge/README.md). Plugin authoring is the [plugins guide](plugins.md). Platform setup beyond the webhook is the [gateway guide](gateway.md). A TypeScript game backend that embeds the library uses the [library guide](library.md) — Godot itself does not.
 
+Editor MCP and this page are opposite directions. An editor MCP is lich connecting to the editor to build the project — the [Redot guide](redot.md). This page is the game connecting to lich. Godot has no official MCP server. lich does not download a community addon and does not spawn one. A game master is another persona, not an editor tool. Play for both editors is still one `POST /message` per round, then drain `.lich/game/orders.jsonl`. Do not call lich per frame.
+
 ## Architecture
 
 Two tiers:
@@ -24,7 +26,7 @@ flowchart LR
     G --> H[resolve the round]
 ```
 
-A game backend may instead call `run_agent`, which loads `config.plugins`. `create_agent` does not. Godot still reaches that backend over HTTP; it does not import the package. Several personas means several agents behind that HTTP process — the pattern is [`examples/persona_orchestrator`](../../examples/persona_orchestrator/README.md), and the service is the game's. Session replay is the [games guide](games.md).
+A game backend may instead call `run_agent`, which loads `config.plugins`. `create_agent` does not. Godot still reaches that backend over HTTP; it does not import the package. Several personas means several agents behind that HTTP process — the pattern is [`examples/persona_orchestrator`](https://github.com/Moikapy/lich/blob/main/examples/persona_orchestrator/README.md), and the service is the game's. Session replay is the [games guide](games.md).
 
 ## Gateway contract
 

package/docs/user-guide/library.md

@@ -145,7 +145,9 @@ Listed providers form a failover chain tried in order: `rate_limit`/`network` er
 
 ## Custom tool filtering
 
-`tools_enabled` accepts `"all"` (default) or an array of builtin tool names to register; everything else stays unregistered and invisible to the model. The filter does not apply to plugin tools: they register afterward, including the gatekeeper's `git_commit`. `[]` strips every builtin and does not throw.
+`tools_enabled` accepts `"all"` (default) or an array of tool names to register; everything else stays unregistered and invisible to the model. MCP tools, when a named server is `enabled`, use the same allowlist and stay off when the list is `[]` (that empty list does not connect). The filter does not apply to plugin tools: they register afterward, including the gatekeeper's `git_commit` (fail-closed unless `LICH_ALLOW_SELF_COMMIT=1`). `[]` strips every builtin and every MCP tool and does not throw.
+
+`mcp_servers` and `catalog_client_entry` ship in 0.7.0. See the [Redot guide](redot.md).
 
 ```ts
 const agent = create_agent({
@@ -184,7 +186,7 @@ When every configured provider fails, the last `ProviderError` is thrown. Tool f
 
 ## Games
 
-A Godot client does not embed the library. A game backend that does is still one `Agent` per persona, not a second loop. The pattern — factory, history cap, per-conversation queue, `POST /message` → `{reply, usage}` — is [`examples/persona_orchestrator`](../../examples/persona_orchestrator/README.md). The service itself is game-repo work. Session files as a combat log: [games guide](games.md).
+A Godot client does not embed the library. A game backend that does is still one `Agent` per persona, not a second loop. The pattern — factory, history cap, per-conversation queue, `POST /message` → `{reply, usage}` — is [`examples/persona_orchestrator`](https://github.com/Moikapy/lich/blob/main/examples/persona_orchestrator/README.md). The service itself is game-repo work. Session files as a combat log: [games guide](games.md).
 
 ## Session access
 

package/docs/user-guide/plugins.md

@@ -112,7 +112,7 @@ Failures are contained at every layer:
 
 ## Runtime notes
 
-`package.json` `engines.node` is `>=20`. The CLI loads `config.plugins` before the run. A broken entry logs one `plugin load errors` warning and the run continues without that plugin.
+`package.json` `engines.node` is `>=20`. Bare `lich`, one-shot, chat, tui, and gateway load `config.plugins` through `create_agent_with_plugins` before the run. `lich init`, `lich config`, `lich update`, and `lich mcp` do not start an agent. `create_agent` stays plugin-free; `run_agent` loads plugins. A broken entry logs one `plugin load errors` warning and the run continues without that plugin.
 
 `.mjs` and other plain JS (no type syntax) are the form that matches `engines.node` `>=20`. They load on Node and on Bun with no plugin-load warning.
 
@@ -122,7 +122,7 @@ Checked with Node 26.8.2 (`node dist/cli.js`) and Bun 1.3.14 (`bun src/cli.ts`):
 - On Node 20 and Node 22 before 22.18, a `.ts` entry still warns and the run continues without that plugin.
 - Syntax Node cannot strip (for example `enum`) warns and continues. Bun runs that same file with no plugin-load warning. A syntax error warns on both and the run continues.
 
-The combat-commander reference is `examples/game_bridge/game_bridge.plugin.mjs`. Point `config.plugins` at `./examples/game_bridge/game_bridge.plugin.mjs` (relative to `work_dir`). See `examples/game_bridge/README.md`. Embedding it beside a Godot game: [Godot guide](godot.md).
+The combat-commander reference is `examples/game_bridge/game_bridge.plugin.mjs`. Point `config.plugins` at `./examples/game_bridge/game_bridge.plugin.mjs` (relative to `work_dir`). See [`examples/game_bridge/README.md`](https://github.com/Moikapy/lich/blob/main/examples/game_bridge/README.md). Embedding it beside a Godot game: [Godot guide](godot.md).
 
 Plain JS (matches `engines.node` `>=20`):
 

package/docs/user-guide/redot.md

@@ -0,0 +1,93 @@
+# Redot guide
+
+> What you'll learn: how to add an editor MCP server, and why that is the opposite of in-game play.
+
+Editor MCP and in-game play point opposite ways. This page is lich connecting **to** an editor. NPC control, vetoes, and the game master are the game connecting **to** lich: the webhook and [`examples/game_bridge`](https://github.com/Moikapy/lich/blob/main/examples/game_bridge/README.md). That contract is the [Godot guide](godot.md). A game master is another persona, not an editor tool.
+
+The client is general, the same shape as Hermes and Claude: a named list you extend when you need a server. Redot is a catalog entry on that client, not a hard-wired spawner. lich does not ship the engine and does not download an addon.
+
+## Client
+
+`mcp_servers` is a closed record. Omit it and no MCP tools register. Each name is snake_case. Each value is either stdio or loopback HTTP. `enabled` defaults to `false`. Unknown keys are rejected.
+
+```json
+{
+  "mcp_servers": {
+    "notes": {
+      "enabled": true,
+      "command": "/usr/local/bin/notes-mcp",
+      "args": ["--stdio"]
+    }
+  }
+}
+```
+
+stdio is a local binary you named, plus `args`, plus optional `env`. The process is spawned with those argv, never a shell. `npx`, `npm`, `bunx`, `uvx`, `curl`, `wget`, a URL, and shell metacharacters are refused. lich does not run `npx -y` or fetch an addon. Values in `env` are passed to the process and are never logged. `lich mcp add` has no flag for `env`; set that key in the file if you need it. On Bun, the spawned child is not `unref`'d, so one-shot and other short-lived runs wait for the MCP answer instead of exiting while the child is still working; `Agent.close()` (every CLI mode calls it) kills the child.
+
+HTTP is `{ "url": "http://127.0.0.1:9/mcp" }`. The host must be `127.0.0.1` or `localhost`. `0.0.0.0` and any other host are refused. There is no remote MCP in v1.
+
+On connect the client sends `initialize`, then `notifications/initialized`, then `tools/list`. `tools/call` runs only when the model invokes a registered tool. Registered names are `mcp_<server>_<tool>`, so two servers cannot collide. They appear only when that server is `enabled` and `tools_enabled` is `"all"` or lists the prefixed name. `tools_enabled: []` drops them even when the server is enabled, and does not connect. Plugin tools still register, including the gatekeeper's `git_commit`. The commander persona keeps `tools_enabled: []` and the `game_bridge` plugin only — `persona_config` does not copy `mcp_servers`.
+
+This client ships in 0.7.0 (`lich mcp`, `mcp_servers`). From a clone, use `bun src/cli.ts mcp ...`.
+
+## Add a server
+
+Paste an entry, call `catalog_client_entry`, or use the CLI. None of these start a process. New entries stay disabled until you enable them.
+
+```sh
+lich mcp add redot --project-path /home/me/game
+lich mcp enable redot
+lich mcp list
+lich mcp disable redot
+lich mcp remove redot
+```
+
+`lich mcp add redot --project-path /home/me/game` writes a disabled entry whose `command` is `redot` and whose args are `--headless --mcp-server --path` plus that directory. PATH lookup happens at connect, not at add.
+
+`lich mcp add notes --command /usr/local/bin/notes-mcp --arg --stdio` is a custom stdio server. `--url` must be loopback. The command writes through the existing config writer and leaves providers, plugins, and gateway untouched. `lich mcp list` reads this work dir's `.lich/config.json`. A missing `mcp_servers` prints nothing and exits 0.
+
+```ts
+import { catalog_client_entry } from "@moikapy/lich";
+
+catalog_client_entry("redot", { project_path: "/home/me/game" });
+```
+
+That returns a disabled stdio entry. Unknown names and the Godot catalog return an explanation instead of a spawn plan. Catalog files live in `optional-mcps/<name>/manifest.json`. A new server is a new manifest plus a config entry. It is not a new client.
+
+## Redot
+
+Official Redot 26.1+ only. The catalog command is the local `redot` binary. The args are exactly:
+
+```text
+redot --headless --mcp-server --path <project>
+```
+
+Basename must be `redot`. A missing binary tells you to install official Redot 26.1+ from [redotengine.org](https://redotengine.org). lich does not download a build.
+
+```json
+{
+  "mcp_servers": {
+    "redot": {
+      "enabled": true,
+      "command": "/usr/local/bin/redot",
+      "args": ["--headless", "--mcp-server", "--path", "/home/me/game"]
+    }
+  }
+}
+```
+
+`tools/list` is what registers. The official server lists five controllers. The client drops a listed tool named `execute` (`exclude_tools`). It does not hard-allowlist those five names: any other listed tool is registered. Existing `.gd` files stay normal file edits (`edit_file` / `write_file`). Scene edits go through the scene tool. Do not rewrite `.tscn` as text.
+
+| Registered name | Use it for |
+| --- | --- |
+| `mcp_redot_scene_action` | `.tscn` edits: nodes, properties, instances, signals |
+| `mcp_redot_resource_action` | `.tres` files and asset import metadata |
+| `mcp_redot_code_intel` | GDScript validation and engine docs |
+| `mcp_redot_project_config` | Input map, autoloads, settings, run and stop |
+| `mcp_redot_game_control` | Screenshots, clicks, and the live scene tree |
+
+## Play is the other direction
+
+These tools build and inspect the project. They do not queue combat orders. NPC and game-master play still use one `POST /message` per round, then drain `work_dir/.lich/game/orders.jsonl` and refresh `state.json`. Do not call lich per frame.
+
+Godot has no official MCP server. lich does not spawn a community godot-mcp and does not download an Asset Library addon. If you later point a **different** server name at a local binary you already have, that is a normal stdio entry. The catalog name `godot` writes no spawn plan. Play for both editors stays the [Godot guide](godot.md).

package/docs/user-guide/tui.md

@@ -9,12 +9,12 @@ lich         # front door: TUI, plus a first-run setup wizard when no config exi
 lich tui     # same TUI, no wizard. From a clone: bun src/cli.ts tui
 ```
 
-The TUI needs a TTY and a resolvable provider (same resolution as every mode). On startup it prints a dim header from the active theme welcome string, e.g. `⚱ lich v0.5.1 — the agent that will not stay dead · llama3.2 (ollama)`. That banner is the only tagline placement. Quit with `/exit`, `/quit`, `/q`, or Ctrl+C.
+The TUI needs a TTY and a resolvable provider (same resolution as every mode). On startup it prints a dim header from the active theme welcome string, e.g. `⚱ lich v0.7.0 — the agent that will not stay dead · llama3.2 (ollama)`. `{version}` is `LICH_VERSION` from `package.json`. That banner is the only tagline placement. Quit with `/exit`, `/quit`, `/q`, or Ctrl+C.
 
 ## Anatomy
 
 ```
-⚱ lich v0.5.1 — the agent that will not stay dead · llama3.2 (ollama)
+⚱ lich v0.7.0 — the agent that will not stay dead · llama3.2 (ollama)
 mortal › list the files here           <- your input, echoed into the transcript
 ⏺ list_dir({})                        <- live tool-call row (name + args preview)
   ⏷ list_dir: ok (d src/ d test/ ...)  <- result row (ok/error + output preview)

package/examples/game_bridge/README.md

@@ -66,3 +66,5 @@ A round that does not match `state.json` is still appended. The tool output then
 ## Failures
 
 Tools return `{ok: false, error}` and do not throw. Reads skip malformed JSONL lines. The first call creates `.lich/game/` if it is missing. `memory.jsonl` grows forever; only the read is capped.
+
+Editor MCP builds the project. This plugin is the opposite direction: the game connects to lich. NPC and game-master play still drain `.lich/game/orders.jsonl` and the webhook. A game master is another persona, not an editor tool. See the [Redot guide](../../docs/user-guide/redot.md).

package/optional-mcps/godot/manifest.json

@@ -0,0 +1,6 @@
+{
+  "name": "godot",
+  "description": "Godot has no official MCP server. Do not download a community addon.",
+  "transport": "none",
+  "note": "Godot has no official MCP server. lich does not spawn a community addon. Play stays the webhook and examples/game_bridge: the game connects to lich. That is the opposite direction from editor MCP."
+}

package/optional-mcps/redot/manifest.json

@@ -0,0 +1,18 @@
+{
+  "name": "redot",
+  "description": "Official Redot 26.1 MCP server. lich does not ship the engine.",
+  "transport": "stdio",
+  "command": "redot",
+  "args": ["--headless", "--mcp-server", "--path", "${project_path}"],
+  "command_basename": "redot",
+  "args_prefix": ["--headless", "--mcp-server", "--path"],
+  "exclude_tools": ["execute"],
+  "missing_hint": "redot binary not found. Install official Redot 26.1+ from https://redotengine.org",
+  "tools": [
+    "scene_action",
+    "resource_action",
+    "code_intel",
+    "project_config",
+    "game_control"
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moikapy/lich",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "Lich — a TypeScript AI agent harness (library + CLI) inspired by Hermes",
   "type": "module",
   "license": "MIT",
@@ -22,6 +22,7 @@
     "!docs/.vitepress/dist",
     "!docs/.vitepress/cache",
     "examples/game_bridge",
+    "optional-mcps",
     "README.md",
     "CHANGELOG.md"
   ],

package/dist/chunk-6M6OAQGN.js

@@ -1,17 +0,0 @@
-// src/index.ts
-import { readFileSync } from "fs";
-import { fileURLToPath } from "url";
-function read_package_version() {
-  const pkg_path = fileURLToPath(new URL("../package.json", import.meta.url));
-  const pkg = JSON.parse(readFileSync(pkg_path, "utf8"));
-  if (typeof pkg.version !== "string" || pkg.version.length === 0) {
-    throw new Error("package.json is missing version");
-  }
-  return pkg.version;
-}
-var LICH_VERSION = read_package_version();
-
-export {
-  LICH_VERSION
-};
-//# sourceMappingURL=chunk-6M6OAQGN.js.map

package/dist/chunk-6M6OAQGN.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * Public surface of the lich agent harness. Pure re-exports, plus the package version.\n */\nimport { readFileSync } from \"node:fs\";\nimport { fileURLToPath } from \"node:url\";\n\nfunction read_package_version(): string {\n  const pkg_path = fileURLToPath(new URL(\"../package.json\", import.meta.url));\n  const pkg = JSON.parse(readFileSync(pkg_path, \"utf8\")) as { version?: unknown };\n  if (typeof pkg.version !== \"string\" || pkg.version.length === 0) {\n    throw new Error(\"package.json is missing version\");\n  }\n  return pkg.version;\n}\n\nexport const LICH_VERSION = read_package_version();\n\nexport { Agent, create_agent, run_agent, create_agent_with_plugins } from \"./agent/agent.js\";\nexport type { AgentRunOptions, AgentRunResult } from \"./agent/agent.js\";\nexport type { AgentConfig } from \"./agent/config.js\";\nexport { parse_agent_config } from \"./agent/config.js\";\nexport { AgentEmitter } from \"./agent/events.js\";\nexport type { AgentEvent, AgentEventHandler, AgentEvents } from \"./agent/events.js\";\nexport type { LoopOutcome, LoopParams } from \"./agent/loop.js\";\nexport type {\n  ChatOptions,\n  ChatResult,\n  Message,\n  ProviderConfig,\n  ToolCall,\n  ToolDefinition,\n  Usage,\n} from \"./providers/types.js\";\nexport { ProviderError } from \"./providers/types.js\";\nexport { ToolExecutor } from \"./tools/executor.js\";\nexport { ToolRegistry } from \"./tools/registry.js\";\nexport type { Tool, ToolContext, ToolResult } from \"./tools/types.js\";\nexport { register_builtin_tools } from \"./tools/builtin/index.js\";\nexport { HookedToolRunner } from \"./plugins/hooks.js\";\nexport { load_plugins, plugin_errors_summary } from \"./plugins/loader.js\";\nexport type { LoadedPlugin, PluginLoadError } from \"./plugins/loader.js\";\nexport type {\n  AfterToolCallInfo,\n  BeforeToolCallInfo,\n  BeforeToolCallResult,\n  HookContext,\n  Plugin,\n  PluginHooks,\n  RunEndInfo,\n} from \"./plugins/types.js\";"],"mappings":";AAGA,SAAS,oBAAoB;AAC7B,SAAS,qBAAqB;AAE9B,SAAS,uBAA+B;AACtC,QAAM,WAAW,cAAc,IAAI,IAAI,mBAAmB,YAAY,GAAG,CAAC;AAC1E,QAAM,MAAM,KAAK,MAAM,aAAa,UAAU,MAAM,CAAC;AACrD,MAAI,OAAO,IAAI,YAAY,YAAY,IAAI,QAAQ,WAAW,GAAG;AAC/D,UAAM,IAAI,MAAM,iCAAiC;AAAA,EACnD;AACA,SAAO,IAAI;AACb;AAEO,IAAM,eAAe,qBAAqB;","names":[]}