@hanphone/dsh-a2a 0.1.0 → 0.3.0

package/README.md

@@ -1,36 +1,65 @@
 # dsh-a2a
 
-Agent2Agent (A2A) Protocol v1.0 dual-end plugin for [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness).
+Agent2Agent (A2A) Protocol v1.0.1 dual-end plugin for [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) — **English** · [中文](README.zh.md)
 
-> **English** | [中文](README.zh.md)
+`@hanphone/dsh-a2a` is an independent, open-source A2A plugin that turns a
+DeepSeek Harness profile into a multi-faced agent-to-agent citizen: it can
+simultaneously serve **multiple inbound A2A servers**, each bound to its own
+agent preset with its own endpoint, AgentCard, declared skills and auth, and
+connect to **multiple outbound A2A servers**, each with its own preset, whose
+remote skills appear as model tools. Every server instance is created,
+started, stopped, edited and removed entirely from the GUI — no config-file
+editing.
 
-`@hanphone/dsh-a2a` turns a DeepSeek Harness profile into a first-class A2A agent:
-
-- **Inbound server** — AgentCard derived from the live tool registry, JSON-RPC + SSE, durable task store, pluggable session/subagent executors, and a policy gate (`a2a/inbound-task`) with audit.
-- **Outbound client** — a persisted multi-agent AgentCard registry, remote skills mapped to model tools (`a2a__<name>__<skill>`), sync calls with per-agent timeout.
-- **GUI dashboard** — an **A2A 连接** settings page in the Harness Web UI: toggle the inbound server, manage outbound agents, view and cancel tasks — no config files required.
-
-Design decisions are recorded in [docs/architecture.md](docs/architecture.md). Current scope is P0 of that document.
+Architecture and design decisions: [docs/architecture.md](docs/architecture.md).
 
 ## Features
 
-- **A2A v1.0 protocol surface** — `SendMessage`, `SendStreamingMessage`, `GetTask`, `ListTasks`, `CancelTask`, `GetExtendedAgentCard`, `SubscribeToTask` over JSON-RPC; SSE streaming with catch-up frames.
-- **Dynamic AgentCard** — skills derived from the live `ctx.tools` registry (explicit id list, loud failure on missing referents) plus a built-in `chat` skill so a fresh install is immediately exercisable.
-- **Durable task store** — tasks live in the `a2a` storage domain (JSON backend by default, SQLite per deployment choice); task ids are server-generated and survive restarts.
-- **Executors** — `session` (one DSH session per `contextId`) and `subagent` (delegates to `ctx.subagents`, streams tool-call artifacts back) as built-in implementations.
-- **Governed inbound** — every inbound task passes through the `a2a/inbound-task` waterfall, so policy plugins can veto or audit before execution.
-- **Auth by environment variable** — inbound bearer token is referenced by env-var name (`authTokenEnv`), never stored in config as plaintext.
-- **Install-and-use** — both halves are enabled by default after `dsh plugin add`; no manual patch required to start.
+- **A2A v1.0.1 protocol surface, aligned with the official spec** —
+  `SendMessage`, `SendStreamingMessage`, `GetTask`, `ListTasks`, `CancelTask`,
+  `GetExtendedAgentCard`, `SubscribeToTask` over JSON-RPC; SSE streaming with
+  catch-up frames; official `TASK_STATE_*` / `ROLE_*` enums and AgentCard
+  structure (including `supportedInterfaces`, `capabilities`, full error-code
+  table).
+- **Multiple inbound servers** — one per persona. Each instance gets its own
+  endpoint (`/a2a/<id>`), AgentCard route, authentication env, and skill
+  declarations.
+- **Per-instance agent preset** — every inbound server binds an agent preset
+  (e.g. `ptc`, `standard`, `minimal`, …); inbound tasks execute in sessions
+  composed from that preset through the standard `agentPresets` resolve+mount
+  path.
+- **Creator-declared skill declarations** — the AgentCard's skills are the
+  text the creator entered (id/name/description per skill); when left empty at
+  creation, the default is the bound preset's display name (built-in `chat`
+  otherwise). The v0.2 tool white-list derivation is removed.
+- **Multiple outbound servers** — each connection has its own remote URL,
+  auth env, timeout and optional preset; enabled instances map remote skills
+  to `a2a__<name>__<skill>` model tools.
+- **Durable task store** — tasks live in the `a2a` storage domain (JSON
+  backend by default, SQLite per deployment choice); server-generated ids
+  survive restarts, and each task records the inbound server it arrived
+  through.
+- **Executors** — `session` (one DSH session per `contextId`) and `subagent`
+  (delegates to `ctx.subagents`, streams tool-call artifacts back).
+- **Governed inbound** — every inbound task passes through the
+  `a2a/inbound-task` waterfall so policy plugins can veto or audit.
+- **Inbound connection monitoring** — the dashboard shows which remote peers
+  are talking to each instance and can close a peer.
+- **Auth by environment variable** — each instance's bearer token is
+  referenced by env-var name (`authTokenEnv`), never stored as plaintext.
+- **Minimal plugin config** — instances are created through the GUI and live
+  in the domain; the plugin `Config` only carries host-level defaults
+  (`baseUrl`, `subagentProvider`, `defaultTimeoutMs`).
 
 ## Installation
 
-### From npm (published)
+### From npm
 
 ```sh
 dsh plugin --profile web add @hanphone/dsh-a2a
 ```
 
-This works for any profile name (`web`, custom profiles, etc.):
+Any profile name works (`web`, custom profiles, headless etc.):
 
 ```sh
 dsh plugin --profile <name> add @hanphone/dsh-a2a
@@ -42,72 +71,85 @@ dsh plugin --profile <name> add @hanphone/dsh-a2a
 cd dsh-a2a
 pnpm build
 npm pack
-dsh plugin --profile <name> add <path-to>/hanphone-dsh-a2a-0.1.0.tgz
+dsh plugin --profile <name> add <path-to>/hanphone-dsh-a2a-<version>.tgz
 ```
 
 ## Quick start
 
 1. **Install** — `dsh plugin --profile web add @hanphone/dsh-a2a`.
-2. **Restart the GUI** — the browser half is scanned at host startup, so restart `pnpm dsh web` (or your profile launcher) once after installing.
-3. **Open Settings → A2A 连接** — you will see the inbound server status, the outbound agent list, and the task list.
+2. **Restart the GUI** — the browser half is scanned at host startup, so
+   restart once after installing (`pnpm dsh web` or your profile launcher).
+3. **Open Settings → A2A 连接** — create your first inbound server (pick a
+   preset, declare skills, optionally set an auth env). It is enabled
+   immediately and publishes its own endpoint and AgentCard.
 
-The inbound server listens on the profile's webServer (default `http://127.0.0.1:3080`):
+Each inbound server listens on the profile's webServer:
 
 ```sh
-curl http://127.0.0.1:3080/.well-known/agent-card.json
+# the created instance's AgentCard (see the GUI for the exact id)
+curl http://127.0.0.1:3080/a2a/<id>/agent-card.json
 ```
 
-Send a task (the built-in `chat` skill):
+Send a task to an instance (its declared `chat` skill):
 
 ```sh
-curl -X POST http://127.0.0.1:3080/a2a \
+curl -X POST http://127.0.0.1:3080/a2a/<id> \
   -H "content-type: application/json" \
   -d '{"jsonrpc":"2.0","id":"1","method":"SendMessage","params":{"message":{"role":"user","parts":[{"text":"hello"}],"metadata":{"skill":"chat"}}}}'
 ```
 
 ## GUI dashboard
 
-The browser half registers an **A2A 连接** page under Settings. From it you can, without touching any file:
+The browser half registers an **A2A 连接** page under Settings. From it you
+can, without touching any file:
 
-- toggle the inbound server (`server.enable` / `server.disable`),
-- list, add, enable/disable, refresh, and remove outbound agents,
-- view and cancel inbound tasks.
+- **入站 Servers** — create inbound servers (name/description/version, agent
+  preset picker, auth env, skill-declaration textarea), start/stop, edit, and
+  remove them; each row shows its endpoint, preset, declared skills and live
+  AgentCard URL.
+- **出站 Servers** — add outbound connections (name, remote AgentCard URL,
+  preset picker, bearer env, timeout), start/stop, refresh, and remove them;
+  each row shows connection state and tool registration counts.
+- **任务** — view and cancel inbound tasks (each task carries its source
+  server).
+- **入站连接** — see which remote peers are talking to the instances and
+  close one.
 
-All dashboard traffic goes through the **loopback-only** `/a2a/api` route on the profile's webServer — remote peers can never drive it.
+All dashboard traffic goes through the **loopback-only** `/a2a/api` route —
+remote peers can never drive it.
 
 ## Configuration
 
-The dashboard covers the day-to-day operations. Values the dashboard does not edit (name/description, baseUrl, `authTokenEnv`, skills, executors, toolPrefix) are configured through the profile's user patch layer (`$DSH_HOME/profiles/<name>/cordis.patch.yml`) — the reserve path:
+The GUI covers instance management day-to-day. The plugin `Config` only has
+host-level defaults, set through the profile's user patch layer
+(`$DSH_HOME/profiles/<name>/cordis.patch.yml`) if you want to override them:
 
 ```yaml
 - id: a2a
   config:
-    server:
-      enabled: true
-      name: My DSH Agent
-      description: A DeepSeek Harness agent exposed over A2A v1.0
-      version: 0.1.0
-      baseUrl: http://127.0.0.1:<port>   # omit to derive from the webServer address
-      endpointPath: /a2a
-      authTokenEnv: A2A_INBOUND_TOKEN    # optional; an env var NAME, never the token
-      skills:
-        ids: []                          # explicit tool ids to expose; chat is built-in
-        exclude: []
-      executors:
-        chat: session                    # or subagent (needs the subagent seam)
-      subagentProvider: in-process
-    client:
-      toolPrefix: a2a
-      agents: []                         # or declare agents declaratively
+    baseUrl: http://127.0.0.1:<port>   # omit to derive from the webServer address
+    subagentProvider: in-process
+    defaultTimeoutMs: 60000            # default outbound connection timeout
 ```
 
+Instances are **not** configured via patches — they are created in the GUI and
+persisted in the `a2a` domain (`inbound_servers` / `outbound_servers` tables).
+
 ### Required host services
 
-Base-backed profiles mount them all: `webServer` (`@deepseek-ai/dsh-host-webserver`), the storage stack (`@deepseek-ai/dsh-storage` + `@deepseek-ai/dsh-storage-domain`), the tools registry (`@deepseek-ai/dsh-tools`), and an agent loop (`@deepseek-ai/dsh-agent` + `@deepseek-ai/dsh-agent-loop`; the subagent executor additionally needs `@deepseek-ai/dsh-subagent`).
+Base-backed profiles mount them all: `webServer` (`@deepseek-ai/dsh-host-webserver`),
+the storage stack (`@deepseek-ai/dsh-storage` + `@deepseek-ai/dsh-storage-domain`),
+the tools registry (`@deepseek-ai/dsh-tools`), an agent loop
+(`@deepseek-ai/dsh-agent` + `@deepseek-ai/dsh-agent-loop`), and agent presets
+(`@deepseek-ai/dsh-agent-presets`; the preset pickers and preset-bound session
+composition need it). The subagent executor additionally needs
+`@deepseek-ai/dsh-subagent`.
 
 ### Storage backend
 
-The task store lives in the `a2a` storage domain. The base composition routes storage through the `json` backend; to use SQLite, route the domain and add the backend in the same patch layer:
+The task and instance stores live in the `a2a` storage domain. The base
+composition routes storage through the `json` backend; to use SQLite, route
+the domain and add the backend in the same patch layer:
 
 ```yaml
 - id: storage-domain
@@ -122,38 +164,31 @@ The task store lives in the `a2a` storage domain. The base composition routes st
         path: /absolute/path/to/a2a.sqlite
 ```
 
-### Outbound agents (file-declared, optional — the GUI manages the same list)
-
-```yaml
-- id: a2a
-  config:
-    client:
-      toolPrefix: a2a
-      agents:
-        - name: my-remote-agent
-          agentCardUrl: https://remote.example/.well-known/agent-card.json
-          bearerTokenEnv: A2A_REMOTE_TOKEN   # optional; env var NAME
-          enabled: true
-          timeoutMs: 60000
-```
-
-Each enabled remote agent's skills become model tools named `a2a__<name>__<skill>` (normalized, collision-hashed). The registry persists across restarts.
-
 ## CLI
 
-A `/a2a` chat command mirrors the dashboard:
+A `/a2a` chat command mirrors the dashboard (a text backup to the GUI):
 
 ```
-a2a status | enable | disable | card | agents |
-    agent add|remove|enable|disable|refresh |
+a2a status | presets | peers |
+    inbound list|create|remove|enable|disable |
+    outbound list|create|remove|enable|disable|refresh |
     tasks | task get|cancel <id> | help
 ```
 
 ## How it works
 
-- **Inbound** — `POST /a2a` (JSON-RPC) and `GET /.well-known/agent-card.json`; the AgentCard is derived from the live tool registry. Tasks flow through `a2a/inbound-task` → executor → task store, with SSE frames streamed to subscribers.
-- **Outbound** — a persisted `agents` table in the `a2a` domain; `A2AClient` discovers an AgentCard, and each skill registers as a tool.
-- **Dashboard** — the browser half (React, `settings.section`) reads/writes the loopback-only `/a2a/api` route.
+- **Inbound** — an `InboundServerManager` owns every instance: one preset-bound
+  session pool + `A2AServer` + routes per instance. Each instance persists in
+  the `inbound_servers` table and serves its own endpoint + AgentCard. Tasks
+  flow through `a2a/inbound-task` → executor → task store, with SSE frames
+  streamed to subscribers.
+- **Outbound** — an `OutboundServerManager` owns every connection: one
+  `OutboundAgentRegistry` with an isolated agent store per instance,
+  persisted in the `outbound_servers` table. `A2AClient` discovers an
+  AgentCard, and each skill registers as a tool.
+- **Dashboard** — the browser half (React, `settings.section`) reads/writes
+  the loopback-only `/a2a/api` route; the host half feeds it snapshots of
+  inbound/outbound server views and the preset roster (`/a2a/api/presets`).
 
 See [docs/architecture.md](docs/architecture.md) for the full design.
 
@@ -161,19 +196,24 @@ See [docs/architecture.md](docs/architecture.md) for the full design.
 
 ```
 src/
-  api.ts             # loopback dashboard API (/a2a/api)
-  index.ts           # Cordis plugin entry (apply)
-  protocol.ts        # A2A v1.0 protocol constants + types
-  jsonrpc.ts         # JSON-RPC framing
-  server/            # inbound half: store, card, a2a-server, routes, executors
-  outbound/          # outbound half: A2AClient, registry, tools
-  client/            # browser half: settings dashboard (React)
-  service.ts         # ctx.a2a service facade
-  commands.ts        # /a2a chat command
+  api.ts                  # loopback dashboard API (/a2a/api, /a2a/api/presets)
+  index.ts                # Cordis plugin entry (apply)
+  protocol.ts             # A2A v1.0.1 protocol constants + types
+  jsonrpc.ts              # JSON-RPC framing
+  servers/                # multi-instance managers
+    inbound-manager.ts    #   inbound server instances (CRUD, routes, lifecycle)
+    outbound-manager.ts   #   outbound connection instances (CRUD, tools)
+  server/                 # single-instance internals: store, card, a2a-server,
+                          #   routes, executors, inbound-registry
+  outbound/               # outbound internals: A2AClient, registry, tools
+  client/                 # browser half: settings dashboard (React)
+  service.ts              # ctx.a2a service facade
+  commands.ts             # /a2a chat command
 tests/
-  unit/              # protocol, framing, card, store, registry, server, client, api
-  composition/       # apply() on a real Cordis Context with stub host services
-cordis.patch.yml     # bundle patch (mounts the plugin, enabled by default)
+  unit/                   # protocol, framing, card, store, registry, server,
+                          #   client, api, inbound-registry, identity
+  composition/            # apply() on a real Cordis Context with stub host services
+cordis.patch.yml          # bundle patch (mounts the plugin; instances are GUI-managed)
 ```
 
 ## Development
@@ -187,9 +227,15 @@ pnpm test        # vitest run (unit + composition suites)
 pnpm build       # tsc + tsdown → lib/index.js (host) + lib/client.js (browser)
 ```
 
-## Known limitations
+## Acknowledgements
 
-OAuth 2.0 / per-client credentials, gRPC binding, push notifications, `INPUT_REQUIRED` ↔ approval, and passive outbound result injection are listed as P1 or explicitly-not-doing in [docs/architecture.md](docs/architecture.md). They are documented gaps, not a roadmap.
+This plugin was inspired by and developed alongside
+[ryubyte/dsh-a2a](https://github.com/ryubyte/dsh-a2a), an earlier A2A plugin
+for DeepSeek Harness. That project's design — dual-end scope, AgentCard
+advertisement, and the settings-dashboard pattern — set the direction this
+implementation follows. Our protocol layer, task store, and executor seam are
+independent implementations; the GUI management model owes a direct debt to
+ryubyte's connection dashboard.
 
 ## License
 

package/README.zh.md

@@ -1,36 +1,34 @@
 # dsh-a2a
 
-Agent2Agent（A2A）v1.0 双端插件，用于 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness)。
+Agent2Agent（A2A）v1.0.1 双端插件，用于 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) — [English](README.md) · **中文**
 
-> [English](README.md) | **中文**
+`@hanphone/dsh-a2a` 是一个独立开源的 A2A 插件，把 DeepSeek Harness profile 变成多面手 A2A 一等公民：能**同时对外发布多个入站 A2A server**，每个绑定一个自己的 agent preset、拥有独立端点 / AgentCard / 技能宣告 / 鉴权；也能**同时接入多个出站 A2A server**，每个独立 preset，远端技能映射为模型工具。所有 server 实例的创建、启停、编辑、删除全部在 GUI 完成——无需改任何配置文件。
 
-`@hanphone/dsh-a2a` 把 DeepSeek Harness profile 变成 A2A 一等公民：
-
-- **入站服务端** —— 从实时工具注册表派生的 AgentCard、JSON-RPC + SSE、持久化任务存储、可插拔的会话/子代理执行器，以及带审计的策略门禁（`a2a/inbound-task`）。
-- **出站客户端** —— 持久化的多 Agent 注册表，远程技能映射为模型工具（`a2a__<name>__<skill>`），带每 agent 超时的同步调用。
-- **GUI 面板** —— Harness Web UI 设置中的 **A2A 连接** 页：开关入站服务端、管理出站 agent、查看与取消任务——无需改任何配置文件。
-
-设计决策见 [docs/architecture.md](docs/architecture.md)。当前范围为该文档中的 P0。
+架构与设计决策：[docs/architecture.md](docs/architecture.md)。
 
 ## 功能
 
-- **A2A v1.0 协议面** —— JSON-RPC 上的 `SendMessage`、`SendStreamingMessage`、`GetTask`、`ListTasks`、`CancelTask`、`GetExtendedAgentCard`、`SubscribeToTask`；SSE 流式带补发帧。
-- **动态 AgentCard** —— 技能从实时 `ctx.tools` 注册表派生（显式 id 清单，缺失引用大声失败），外加内置 `chat` 技能，装完即可直接验证。
-- **持久化任务存储** —— 任务存于 `a2a` 存储域（默认 json 后端，可按部署切 SQLite）；任务 id 服务端生成且跨重启存活。
-- **执行器** —— `session`（每个 `contextId` 一个 DSH 会话）与 `subagent`（委托 `ctx.subagents`，把工具调用过程流式回传）两种内置实现。
-- **受治理的入站** —— 每个入站任务都经过 `a2a/inbound-task` waterfall，策略插件可在执行前否决或审计。
-- **环境变量鉴权** —— 入站 Bearer token 只以环境变量名（`authTokenEnv`）引用，不以明文落配置。
-- **装完即用** —— `dsh plugin add` 后两端默认启用，无需手动 patch。
+- **A2A v1.0.1 协议面，对齐官方规范** — JSON-RPC 上的 `SendMessage`、`SendStreamingMessage`、`GetTask`、`ListTasks`、`CancelTask`、`GetExtendedAgentCard`、`SubscribeToTask`；SSE 流式带补发帧；官方 `TASK_STATE_*` / `ROLE_*` 枚举与 AgentCard 结构（含 `supportedInterfaces`、`capabilities`、完整错误码表）。
+- **多入站 server** — 每实例一个"人格"：独立端点（`/a2a/<id>`）、AgentCard 路由、鉴权 env、技能宣告。
+- **每实例 agent preset** — 每个入站 server 绑定一个 agent preset（如 `ptc`、`standard`、`minimal`、…）；入站任务在按该 preset 组装的会话中执行（标准 `agentPresets` resolve+mount 路径）。
+- **创建者输入技能宣告** — AgentCard 技能即创建者输入的文字（每个技能 id/name/description）；创建留空时默认取所绑 preset 展示名（否则内置 `chat`）。v0.2 工具白名单派生机制已删除。
+- **多出站 server** — 每个连接独立远端 URL、鉴权 env、超时与可选 preset；启用实例把远端技能映射为 `a2a__<name>__<skill>` 模型工具。
+- **持久化任务存储** — 任务存于 `a2a` 存储域（默认 json 后端，可按部署切 SQLite）；服务端生成 id 跨重启存活，每个任务记录来源入站实例。
+- **执行器** — `session`（每个 `contextId` 一个 DSH 会话）与 `subagent`（委托 `ctx.subagents`，工具调用过程流式回传）。
+- **受治理入站** — 每个入站任务经过 `a2a/inbound-task` waterfall，策略插件可否决或审计。
+- **入站连接监控** — 面板展示每个实例的对端连接，可关闭某个对端。
+- **环境变量鉴权** — 每个实例的 Bearer token 只以环境变量名（`authTokenEnv`）引用，不落明文。
+- **最小插件配置** — 实例经 GUI 创建并存于域中；插件 `Config` 只承载宿主级默认值（`baseUrl`、`subagentProvider`、`defaultTimeoutMs`）。
 
 ## 安装
 
-### 从 npm 发布版安装
+### 从 npm
 
 ```sh
 dsh plugin --profile web add @hanphone/dsh-a2a
 ```
 
-任意 profile 名均可：
+任意 profile 名均可（`web`、自定义 profile、headless 等）：
 
 ```sh
 dsh plugin --profile <name> add @hanphone/dsh-a2a
@@ -42,25 +40,26 @@ dsh plugin --profile <name> add @hanphone/dsh-a2a
 cd dsh-a2a
 pnpm build
 npm pack
-dsh plugin --profile <name> add <path-to>/hanphone-dsh-a2a-0.1.0.tgz
+dsh plugin --profile <name> add <path-to>/hanphone-dsh-a2a-<version>.tgz
 ```
 
 ## 快速开始
 
-1. **安装** —— `dsh plugin --profile web add @hanphone/dsh-a2a`。
-2. **重启 GUI** —— 浏览器端插件表在 host 启动时扫描，装完请重启一次 `pnpm dsh web`（或对应 profile 启动命令）。
-3. **打开 设置 → A2A 连接** —— 会看到入站服务端状态、出站 agent 列表与任务列表。
+1. **安装** — `dsh plugin --profile web add @hanphone/dsh-a2a`。
+2. **重启 GUI** — 浏览器端插件表在 host 启动时扫描，装完请重启一次（`pnpm dsh web` 或对应 profile 启动命令）。
+3. **打开 设置 → A2A 连接** — 创建第一个入站 server（选 preset、填技能宣告、可选鉴权 env）。创建即时启用并发布自己的端点与 AgentCard。
 
-入站服务端监听在 profile 的 webServer 上（默认 `http://127.0.0.1:3080`）：
+每个入站 server 监听在 profile 的 webServer 上：
 
 ```sh
-curl http://127.0.0.1:3080/.well-known/agent-card.json
+# 所建实例的 AgentCard（确切 id 见 GUI）
+curl http://127.0.0.1:3080/a2a/<id>/agent-card.json
 ```
 
-发一个任务（内置 `chat` 技能）：
+向实例发任务（其宣告的 `chat` 技能）：
 
 ```sh
-curl -X POST http://127.0.0.1:3080/a2a \
+curl -X POST http://127.0.0.1:3080/a2a/<id> \
   -H "content-type: application/json" \
   -d '{"jsonrpc":"2.0","id":"1","method":"SendMessage","params":{"message":{"role":"user","parts":[{"text":"hello"}],"metadata":{"skill":"chat"}}}}'
 ```
@@ -69,45 +68,34 @@ curl -X POST http://127.0.0.1:3080/a2a \
 
 浏览器端在设置中注册 **A2A 连接** 页。无需改文件即可：
 
-- 开关入站服务端（`server.enable` / `server.disable`），
-- 列出、添加、启用/停用、刷新、删除出站 agent，
-- 查看与取消入站任务。
+- **入站 Servers** — 创建入站 server（名称/描述/版本、agent preset 选择器、鉴权 env、技能宣告表单），启停、编辑、删除；每行显示端点、preset、宣告技能与实时 AgentCard URL。
+- **出站 Servers** — 添加出站连接（名称、远端 AgentCard URL、preset 选择器、Bearer env、超时），启停、刷新、删除；每行显示连接状态与工具注册数。
+- **任务** — 查看与取消入站任务（每个任务携带来源 server）。
+- **入站连接** — 查看哪些远程对端在调用各实例，可关闭某个对端。
 
-所有面板流量都走 profile webServer 上的**仅回环** `/a2a/api` 路由——远程对端永远无法驱动它。
+所有面板流量走 profile webServer 上的**仅回环** `/a2a/api` 路由——远程对端永远无法驱动它。
 
 ## 配置
 
-面板覆盖日常操作。面板不编辑的项（name/description、baseUrl、`authTokenEnv`、skills、executors、toolPrefix）通过 profile 用户 patch 层（`$DSH_HOME/profiles/<name>/cordis.patch.yml`）配置——保留方式：
+GUI 覆盖日常实例管理。插件 `Config` 只有宿主级默认值，如需覆盖可经 profile 用户 patch 层（`$DSH_HOME/profiles/<name>/cordis.patch.yml`）设置：
 
 ```yaml
 - id: a2a
   config:
-    server:
-      enabled: true
-      name: My DSH Agent
-      description: A DeepSeek Harness agent exposed over A2A v1.0
-      version: 0.1.0
-      baseUrl: http://127.0.0.1:<port>   # 省略则从 webServer 地址派生
-      endpointPath: /a2a
-      authTokenEnv: A2A_INBOUND_TOKEN    # 可选；环境变量名，绝不写 token 明文
-      skills:
-        ids: []                          # 暴露的显式工具 id；chat 为内置
-        exclude: []
-      executors:
-        chat: session                    # 或 subagent（需要 subagent 接缝）
-      subagentProvider: in-process
-    client:
-      toolPrefix: a2a
-      agents: []                         # 或声明式列出 agent
+    baseUrl: http://127.0.0.1:<port>   # 省略则从 webServer 地址派生
+    subagentProvider: in-process
+    defaultTimeoutMs: 60000            # 出站连接默认超时
 ```
 
+实例**不**经 patch 配置——它们在 GUI 中创建并持久化于 `a2a` 域（`inbound_servers` / `outbound_servers` 表）。
+
 ### 所需宿主服务
 
-base 类 profile 全部挂载：`webServer`（`@deepseek-ai/dsh-host-webserver`）、存储栈（`@deepseek-ai/dsh-storage` + `@deepseek-ai/dsh-storage-domain`）、工具注册表（`@deepseek-ai/dsh-tools`）、agent 循环（`@deepseek-ai/dsh-agent` + `@deepseek-ai/dsh-agent-loop`；subagent 执行器还需要 `@deepseek-ai/dsh-subagent`）。
+base 类 profile 全部挂载：`webServer`（`@deepseek-ai/dsh-host-webserver`）、存储栈（`@deepseek-ai/dsh-storage` + `@deepseek-ai/dsh-storage-domain`）、工具注册表（`@deepseek-ai/dsh-tools`）、agent 循环（`@deepseek-ai/dsh-agent` + `@deepseek-ai/dsh-agent-loop`）、agent presets（`@deepseek-ai/dsh-agent-presets`；preset 选择器与 preset 化会话组装需要它）。subagent 执行器还需要 `@deepseek-ai/dsh-subagent`。
 
 ### 存储后端
 
-任务存储位于 `a2a` 存储域。base 组合默认走 `json` 后端；要切 SQLite，在同一 patch 层路由域并加后端：
+任务与实例存储位于 `a2a` 存储域。base 组合默认走 `json` 后端；要切 SQLite，在同一 patch 层路由域并加后端：
 
 ```yaml
 - id: storage-domain
@@ -122,38 +110,22 @@ base 类 profile 全部挂载：`webServer`（`@deepseek-ai/dsh-host-webserver`
         path: /absolute/path/to/a2a.sqlite
 ```
 
-### 出站 agent（文件声明，可选——GUI 管理同一列表）
-
-```yaml
-- id: a2a
-  config:
-    client:
-      toolPrefix: a2a
-      agents:
-        - name: my-remote-agent
-          agentCardUrl: https://remote.example/.well-known/agent-card.json
-          bearerTokenEnv: A2A_REMOTE_TOKEN   # 可选；环境变量名
-          enabled: true
-          timeoutMs: 60000
-```
-
-每个启用远程 agent 的技能会注册为 `a2a__<name>__<skill>` 模型工具（规范化、冲突哈希）。注册表跨重启持久化。
-
 ## CLI
 
-`/a2a` 聊天命令与面板对应：
+`/a2a` 聊天命令与面板对应（GUI 的文字备用路线）：
 
 ```
-a2a status | enable | disable | card | agents |
-    agent add|remove|enable|disable|refresh |
+a2a status | presets | peers |
+    inbound list|create|remove|enable|disable |
+    outbound list|create|remove|enable|disable|refresh |
     tasks | task get|cancel <id> | help
 ```
 
 ## 工作原理
 
-- **入站** —— `POST /a2a`（JSON-RPC）与 `GET /.well-known/agent-card.json`；AgentCard 从实时工具注册表派生。任务流经 `a2a/inbound-task` → 执行器 → 任务存储，SSE 帧推送给订阅者。
-- **出站** —— `a2a` 域中的持久化 `agents` 表；`A2AClient` 发现 AgentCard，每个技能注册为一个工具。
-- **面板** —— 浏览器端（React，`settings.section`）经仅回环 `/a2a/api` 路由读写。
+- **入站** — `InboundServerManager` 拥有每个实例：每实例 = preset 化会话池 + `A2AServer` + 路由。实例持久化于 `inbound_servers` 表，各自服务独立端点与 AgentCard。任务流经 `a2a/inbound-task` → 执行器 → 任务存储，SSE 帧推送给订阅者。
+- **出站** — `OutboundServerManager` 拥有每个连接：每实例一个带独立 agent 存储的 `OutboundAgentRegistry`，实例持久化于 `outbound_servers` 表。`A2AClient` 发现 AgentCard，每个技能注册为一个工具。
+- **面板** — 浏览器端（React，`settings.section`）经仅回环 `/a2a/api` 路由读写；host 端喂给它入站/出站 server 视图与 preset 名单（`/a2a/api/presets`）。
 
 完整设计见 [docs/architecture.md](docs/architecture.md)。
 
@@ -161,19 +133,24 @@ a2a status | enable | disable | card | agents |
 
 ```
 src/
-  api.ts             # 回环面板 API (/a2a/api)
-  index.ts           # Cordis 插件入口 (apply)
-  protocol.ts        # A2A v1.0 协议常量与类型
-  jsonrpc.ts         # JSON-RPC 帧
-  server/            # 入站半区：store、card、a2a-server、routes、executors
-  outbound/          # 出站半区：A2AClient、registry、tools
-  client/            # 浏览器半区：设置面板 (React)
-  service.ts         # ctx.a2a 服务 facade
-  commands.ts        # /a2a 聊天命令
+  api.ts                  # 回环面板 API (/a2a/api、/a2a/api/presets)
+  index.ts                # Cordis 插件入口 (apply)
+  protocol.ts             # A2A v1.0.1 协议常量与类型
+  jsonrpc.ts              # JSON-RPC 帧
+  servers/                # 多实例管理器
+    inbound-manager.ts    #   入站 server 实例（CRUD、路由、生命周期）
+    outbound-manager.ts   #   出站连接实例（CRUD、工具）
+  server/                 # 单实例内部件：store、card、a2a-server、
+                          #   routes、executors、inbound-registry
+  outbound/               # 出站内部件：A2AClient、registry、tools
+  client/                 # 浏览器半区：设置面板 (React)
+  service.ts              # ctx.a2a 服务 facade
+  commands.ts             # /a2a 聊天命令
 tests/
-  unit/              # protocol、framing、card、store、registry、server、client、api
-  composition/       # 在真实 Cordis Context 上以 stub 宿主服务跑 apply()
-cordis.patch.yml     # bundle patch（挂载插件，默认启用）
+  unit/                   # protocol、framing、card、store、registry、server、
+                          #   client、api、inbound-registry、identity
+  composition/            # 在真实 Cordis Context 上以 stub 宿主服务跑 apply()
+cordis.patch.yml          # bundle patch（挂载插件；实例由 GUI 管理）
 ```
 
 ## 开发
@@ -186,9 +163,9 @@ pnpm test        # vitest run（单元 + 组合套件）
 pnpm build       # tsc + tsdown → lib/index.js（host）+ lib/client.js（浏览器）
 ```
 
-## 已知限制
+## 致谢
 
-OAuth 2.0 / 每客户端凭据、gRPC 绑定、push notifications、`INPUT_REQUIRED` ↔ 审批、被动出站结果注入，在 [docs/architecture.md](docs/architecture.md) 中列为 P1 或明确不做。它们是已记录的空缺，不是路线图。
+本项目受 [ryubyte/dsh-a2a](https://github.com/ryubyte/dsh-a2a) 启发并与其并行开发——那是 DeepSeek Harness 上更早的 A2A 插件。其设计——双端范围、AgentCard 宣告、设置面板模式——为本文实现指明了方向。我们的协议层、任务存储与执行器接缝均为独立实现；GUI 管理模型则直接承袭了 ryubyte 的连接面板。
 
 ## 许可证
 

package/cordis.patch.yml

@@ -1,11 +1,8 @@
 # @hanphone/dsh-a2a bundle patch: mount the plugin as one row, enabled by
-# default (install-and-use; turn either half off through the GUI dashboard or
-# an overlay patch on this row).
+# default. v1.0 instances are NOT patch-configured — inbound/outbound server
+# instances are created, preset-bound, and enabled/disabled entirely from the
+# GUI (persisted in the a2a domain); this row only mounts the plugin core.
 - insert:
     - id: a2a
       name: '@hanphone/dsh-a2a'
-      config:
-        server:
-          enabled: true
-        client:
-          agents: []
+      config: {}