@nelsonlongxiang/dsh-open-a2a-net 0.5.13

package/lib/types/index.d.ts

@@ -0,0 +1,113 @@
+/**
+ * A2A node extension (decentralized topology): registers the `a2a_teams` and
+ * `a2a_route` model tools over verified peer agent cards and direct peer
+ * routes, publishes this node's card and joined session teams, and dispatches
+ * inbound direct routes into live agent sessions.
+ * @module @nelsonlongxiang/dsh-open-a2a-net
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import s from '@deepseek-ai/schemastery';
+export type * from './types.ts';
+export { A2aClient } from './a2a-client.ts';
+export type { A2aClientOptions, A2aFetch, A2aSchedule } from './a2a-client.ts';
+export declare const name = "a2a";
+export declare const inject: string[];
+/** One signed zone delegation published on this node's agent card. */
+export interface DelegateConfig {
+    /** The delegated name; resolves zone-relatively at route time. */
+    readonly name: string;
+    /** Base URL of the zone the name resolves in. */
+    readonly url: string;
+    /** Base64 SPKI DER binding to the target zone's card key; `''` leaves the delegation unbound. */
+    readonly publicKey: string;
+}
+/** Deployment-varying A2A node facts; every field has a declared default. */
+export interface Config {
+    /** `X-API-Key` value sent on peer requests and required by the control routes; empty disables the header. */
+    readonly apiKey: string;
+    /**
+     * This node's caller label. `''` (the default) derives `dsh-host-<8 hex>`
+     * from a per-home node id created on first use, so two deployments mounting
+     * defaults do not collide while a persisted home keeps the label stable
+     * across restarts.
+     */
+    readonly session: string;
+    /** Team name this node exposes for direct routing. */
+    readonly team: string;
+    /**
+     * Publish this node's `/.well-known/agent-card.json` on the shared web
+     * server (peer discovery). Requires the web server in the composition;
+     * the card carries this node's team, capabilities, referral list, and
+     * joined session teams so peers find it without a central directory.
+     */
+    readonly announce: boolean;
+    /** Human-facing name published on the agent card. */
+    readonly agentName: string;
+    /**
+     * Base URLs of seed peer nodes. `a2a_teams` lists teams discovered from
+     * the peers' agent cards and `a2a_route` connects to the owning peer's
+     * `/a2a/direct` endpoint. The list is a seed set: referral URLs learned
+     * from fetched cards join a bounded, quality-scored peer store persisted
+     * at `<dsh-home>/a2a/peers.json`.
+     */
+    readonly peers: string[];
+    /**
+     * Zone delegation records published (signed) on this node's agent card:
+     * each entry publishes `name` as resolvable in the zone at `url`, so a
+     * route for `name` walks the delegation chain (at most 5 hops, cycles
+     * fail closed).
+     */
+    readonly delegates: DelegateConfig[];
+    /**
+     * Harness home slice for the node keypair and peer store; `''` (the
+     * default) uses the process DSH home. The Ed25519 key lives at
+     * `<home>/a2a/node-key.pem` and is generated on first announce; a
+     * persisted key keeps the node's card identity stable across restarts.
+     */
+    readonly dshHome: string;
+    /**
+     * Agent-card validity. Announce re-signs at TTL/4 so three lost refreshes
+     * still leave a live card; a node silent for one TTL disappears from every
+     * peer's discovery without manual eviction.
+     */
+    readonly cardTtlMs: number;
+    /**
+     * Enable per-session A2A nodes: each live top-level session can join the
+     * network explicitly — label `<session>-<agentId8>`, team
+     * `<team>/<agentId8>`, node facts carrying the session title and a
+     * recent-activity excerpt. Joining is opt-in through the sidebar control's
+     * host routes; joined teams ride this node's card and dispatch through
+     * its `/a2a/direct` endpoint.
+     */
+    readonly sessionNodes: boolean;
+    /**
+     * Wake every cold joined session's agent when the plugin mounts (dev boxes
+     * and always-on collaboration hosts that restart often: the network state
+     * returns without opening each session). Each wake materializes a full
+     * agent — log replay plus composed preset world — so the default stays
+     * off for deployments that would rather pay on demand (wake-on-route and
+     * the sidebar's wake button remain available).
+     */
+    readonly wakeJoinedOnBoot: boolean;
+    /**
+     * `final` reply budget: how long an inbound direct route waits for the
+     * session's next assistant message before answering with a timeout
+     * notice. Without it a session that never idles (or never produces text)
+     * leaves the caller hanging until `routeTimeoutMs` expires.
+     */
+    readonly flushTimeoutMs: number;
+    /**
+     * `a2a_route` execution budget: how long a call may plausibly wait for a
+     * remote session's reply (default 30 minutes).
+     */
+    readonly routeTimeoutMs: number;
+}
+/** Schemastery configuration for the A2A client plugin row. */
+export declare const Config: s<Config>;
+/**
+ * Register the outbound peer tools, the direct-route endpoint, and (when
+ * composed) the announced card and session-node control surface.
+ * @param ctx - registrant context carrying the tool registry and timer.
+ * @param config - deployment's A2A node facts.
+ */
+export declare function apply(ctx: Context, config: Config): void;

package/lib/types/invariant.d.ts

@@ -0,0 +1,8 @@
+/** Package-owned invariant companion. @module @nelsonlongxiang/dsh-open-a2a-net/invariant */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "a2a-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/** Register this package's invariant companion. */
+export declare const apply: (ctx: Context) => Promise<() => void>;

package/lib/types/joined-store.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Persisted session-node join intent (`<dsh-home>/a2a/joined.json`). A join
+ * is a user gesture over a durable session, but the node it mounts lives and
+ * dies with the session's Agent instance — page reloads and host restarts
+ * dispose Agents, which silently dropped every join. The store keeps the
+ * intent across those lifecycles: the plugin remounts the node whenever the
+ * session's Agent comes back, until the user leaves (the only intent
+ * remover; disposal alone never unpersists).
+ * @module @nelsonlongxiang/dsh-open-a2a-net/joined-store
+ */
+/**
+ * Hard cap on remembered join intents. Ids of deleted sessions linger
+ * harmlessly (no Agent ever comes back for them); the cap bounds the file,
+ * keeping the most recent intents (peer-store's bound rationale).
+ */
+export declare const JOIN_CAP = 64;
+/** The persisted intent document (whole-file read/write, small by design). */
+export interface JoinedSnapshot {
+    readonly sessions: readonly string[];
+}
+/**
+ * Bounded set of session ids whose user joined them to the A2A network,
+ * with whole-file persistence. Pure of any registry knowledge: callers ask
+ * {@link has} when an Agent appears and record {@link add} / {@link remove}
+ * on the join and leave operations.
+ */
+export declare class JoinedSessions {
+    private readonly path;
+    /** Session ids, most recently joined first. */
+    private ids;
+    /**
+     * @param path - persistence file (`<dsh-home>/a2a/joined.json`); empty = no persistence.
+     */
+    constructor(path: string);
+    /**
+     * Whether the session's join intent is remembered.
+     * @param id - the session id to check.
+     * @returns whether the intent is present.
+     */
+    has(id: string): boolean;
+    /**
+     * Every remembered join intent, most recently joined first.
+     * @returns the remembered session ids.
+     */
+    list(): readonly string[];
+    /**
+     * Remember one join intent, most-recent first, bounded by {@link JOIN_CAP}
+     * (the oldest intent beyond the cap is forgotten).
+     * @param id - the joined session id.
+     */
+    add(id: string): void;
+    /**
+     * Forget one join intent (the leave operation; a no-op when absent).
+     * @param id - the session id whose intent is removed.
+     */
+    remove(id: string): void;
+    /** Load a persisted snapshot on construction, if present. */
+    private restore;
+    /** Persist the intent set (no-op when no path was configured). */
+    private persist;
+}

package/lib/types/peer-store.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Bounded, quality-scored peer store (GNUnet hostlist semantics, slice 2).
+ * The configured peer list is a seed set, not the network: referral URLs
+ * learned from fetched cards join the store, are bounded and quality-scored,
+ * and persist across restarts. Failed fetches degrade a peer; a bad peer that
+ * keeps failing is evicted, while seeds stay for the lifetime of the config
+ * that named them. Design basis:
+ * .agents/notes/proposed/feature/2026-08-16-gnunet-prior-art-for-a2a-topology.md.
+ * @module @nelsonlongxiang/dsh-open-a2a-net/peer-store
+ */
+/** Hard cap on tracked peers, seeds included (hostlist bound: 30). */
+export declare const PEER_CAP = 30;
+/** Initial quality score of a seed or newly offered peer. */
+export declare const INITIAL_SCORE = 10000;
+/** Quality penalty on a failed fetch. */
+export declare const FAILURE_PENALTY = 100;
+/** Quality reward on a successful fetch. */
+export declare const SUCCESS_REWARD = 100;
+/** Score floor: at or below this a non-seed peer is evicted. */
+export declare const EVICTION_FLOOR = 0;
+/** One tracked peer. */
+export interface PeerRecord {
+    readonly url: string;
+    score: number;
+    readonly seed: boolean;
+}
+/** The persisted store document (whole-file read/write, small by design). */
+export interface PeerStoreSnapshot {
+    readonly peers: readonly PeerRecord[];
+}
+/**
+ * Bounded, quality-scored peer collection with whole-file persistence.
+ * Pure of any network: the caller drives fetch outcomes through
+ * {@link noteFailure} / {@link noteSuccess} and feeds referral URLs through
+ * {@link offer}.
+ */
+export declare class PeerStore {
+    private readonly path;
+    private readonly cap;
+    private readonly peers;
+    /**
+     * @param seeds - the configured seed URLs; always retained (never evicted).
+     * @param path - persistence file (`<dsh-home>/a2a/peers.json`); empty = no persistence.
+     * @param cap - peer bound, seeds included (default {@link PEER_CAP}).
+     */
+    constructor(seeds: readonly string[], path: string, cap?: number);
+    /**
+     * Every tracked peer URL: seeds first (in first-tracked order), then
+     * offered peers by score descending (equal scores keep first-tracked order).
+     * @returns the ordered peer URLs.
+     */
+    list(): readonly string[];
+    /** Whether the store has room for one more peer. */
+    private hasRoom;
+    /**
+     * Offer a referral URL learned from a fetched card. Bounded: an unknown
+     * URL only joins when under the cap; a known URL changes nothing.
+     * @param url - the referred card URL.
+     * @returns whether the peer is tracked (freshly joined or already known).
+     */
+    offer(url: string): boolean;
+    /**
+     * Drop one tracked peer outright — a self-referral (a peer listing this
+     * node's own URL back at it) must not linger as a tracked peer. Seeds are
+     * config-owned and stay.
+     * @param url - the peer to forget.
+     */
+    drop(url: string): void;
+    /**
+     * Note a failed fetch of one peer. A non-seed's score drops; an
+     * at-or-below-floor peer is evicted, so a bad referral disappears rather
+     * than degrading forever. Seeds are config-owned and never penalized.
+     * @param url - the peer that failed.
+     */
+    noteFailure(url: string): void;
+    /**
+     * Note a successful fetch of one peer.
+     * @param url - the peer that answered with a verified card.
+     */
+    noteSuccess(url: string): void;
+    /**
+     * The current quality score of one tracked peer, for state reporting.
+     * @param url - the peer URL.
+     * @returns the score, or undefined when the peer is not tracked.
+     */
+    score(url: string): number | undefined;
+    /** Load a persisted snapshot on construction, if present. */
+    private restore;
+    /** Persist the current peer set (no-op when no path was configured). */
+    private persist;
+}

package/lib/types/types.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Wire and configuration vocabulary for the A2A client extension.
+ * @module @nelsonlongxiang/dsh-open-a2a-net/types
+ */
+/** One peer node's agent card — the decentralized discovery record. */
+export interface A2aPeerCard {
+    /** Human-facing peer name. */
+    readonly name: string;
+    /** The team this peer exposes. */
+    readonly team: string;
+    /** The peer's session id (diagnostics and signing identity). */
+    readonly session: string;
+    /** Capability flags the peer published, verbatim. */
+    readonly capabilities: unknown;
+    /** Epoch ms after which the card is stale; enforced at every parse. */
+    readonly expiresAt: number;
+    /**
+     * Card URLs of other nodes the publisher knows (discovery referrals).
+     * Unsigned and optional: a referral is fetched and verified as its own
+     * card before it is trusted, so its integrity is checked at that fetch,
+     * not by this card's signature.
+     */
+    readonly peers?: readonly string[];
+    /**
+     * Joined session teams this peer currently dispatches. Unsigned and
+     * optional: served fresh at read time, each entry is a team name the
+     * peer's `/a2a/direct` endpoint routes to that session, with the
+     * session's title and recent-activity excerpt as facts.
+     */
+    readonly sessionTeams?: readonly A2aSessionTeamInfo[];
+    /**
+     * The publishing host's LAN IPv4. Unsigned and optional: served fresh, it
+     * lets peers group and tell machines apart in a same-team fleet.
+     */
+    readonly lanIp?: string;
+    /** Base64 SPKI DER of the signing node's Ed25519 public key. */
+    readonly publicKey: string;
+    /**
+     * Zone records delegating names to other zones. Signed with the card: a
+     * record is an authority claim over the name (GNS DELEGATE semantics),
+     * unlike the unsigned `peers` referral hints.
+     */
+    readonly records?: readonly ZoneRecord[];
+    /** Base64 Ed25519 signature over the card's committed fields. */
+    readonly signature: string;
+}
+/** One joined session team advertised on a peer's card. */
+export interface A2aSessionTeamInfo {
+    /** Session team name (`<team>/<agentId8>`); the route target. */
+    readonly team: string;
+    /** The session's title at read time. */
+    readonly name: string;
+    /** One-line excerpt of the session's newest user or assistant text. */
+    readonly description: string;
+    /** The session's working directory, when the publishing node shares it. */
+    readonly workspace?: string;
+}
+/**
+ * One zone record: a delegation of a name into another zone. The delegating
+ * zone's card signature commits the record, so only the zone key holder can
+ * publish or retire the name.
+ */
+export interface ZoneRecord {
+    readonly type: 'delegate';
+    /** The delegated name; resolves zone-relatively. */
+    readonly name: string;
+    /** Base URL of the zone the name resolves in. */
+    readonly url: string;
+    /**
+     * Expected base64 SPKI public key of the target zone's card. When bound,
+     * a target card whose key differs fails resolution closed.
+     */
+    readonly publicKey?: string;
+}
+/** Canonical `a2a_route` success value. */
+export interface A2aRouteOk {
+    readonly ok: true;
+    readonly team: string;
+    /** Reply text the remote team produced. */
+    readonly reply: string;
+    /** The answering peer's task id (diagnostics). */
+    readonly task_id: string;
+    /** Context id for continuing this conversation in a later `a2a_route` call. */
+    readonly context_id: string;
+    readonly task_status: string;
+}
+/** Canonical `a2a_route` failure value. */
+export interface A2aRouteError {
+    readonly ok: false;
+    /** Peer or transport failure text. */
+    readonly error: string;
+    /** A2A JSON-RPC-style code when the peer supplied one. */
+    readonly code?: number;
+    readonly task_id?: string;
+}
+/** Canonical `a2a_route` value: success or explicit failure. */
+export type A2aRouteResult = A2aRouteOk | A2aRouteError;

package/lib/types/zone.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Zone-relative name resolution over agent cards (GNUnet semantics, slice 3).
+ * A name resolves in a zone: the zone's own team matches first, then its
+ * signed delegate records, recursively. The walk is bounded by a hard depth
+ * cap and by visited-URL cycle detection — both fail closed with a reason,
+ * never a hang. Design basis:
+ * .agents/notes/proposed/feature/2026-08-16-gnunet-prior-art-for-a2a-topology.md.
+ * @module @nelsonlongxiang/dsh-open-a2a-net/zone
+ */
+import type { A2aPeerCard } from './types.ts';
+/** Hard delegation-walk bound in hops (GNS `loop_threshold`). */
+export declare const ZONE_DEPTH_CAP = 5;
+/** Why a resolution failed; every failure mode is closed. */
+export type ZoneResolutionReason = 'not-found' | 'depth' | 'cycle' | 'key-mismatch' | 'unreachable';
+/** The resolution outcome: the owning zone, or the closed-failure reason. */
+export type ZoneResolution = {
+    readonly ok: true;
+    readonly url: string;
+    readonly card: A2aPeerCard;
+} | {
+    readonly ok: false;
+    readonly reason: ZoneResolutionReason;
+    readonly detail: string;
+};
+/**
+ * Fetch one zone's verified card; returns undefined when unreachable or the
+ * card fails verification. The caller owns scoring and referral intake.
+ */
+export type ZoneCardFetch = (url: string) => Promise<A2aPeerCard | undefined>;
+/**
+ * Resolve one name starting from a zone's base URL.
+ * @param fetchCard - verified-card fetch for one zone URL.
+ * @param startUrl - base URL of the zone the name resolves in.
+ * @param name - the zone-relative name (a team name).
+ * @returns the resolved zone URL with its verified card, or the closed-failure reason.
+ */
+export declare function resolveZone(fetchCard: ZoneCardFetch, startUrl: string, name: string): Promise<ZoneResolution>;

package/lib/types.js

@@ -0,0 +1,5 @@
+/**
+ * Wire and configuration vocabulary for the A2A client extension.
+ * @module @nelsonlongxiang/dsh-open-a2a-net/types
+ */
+export {};

package/lib/zone.js

@@ -0,0 +1,55 @@
+/**
+ * Zone-relative name resolution over agent cards (GNUnet semantics, slice 3).
+ * A name resolves in a zone: the zone's own team matches first, then its
+ * signed delegate records, recursively. The walk is bounded by a hard depth
+ * cap and by visited-URL cycle detection — both fail closed with a reason,
+ * never a hang. Design basis:
+ * .agents/notes/proposed/feature/2026-08-16-gnunet-prior-art-for-a2a-topology.md.
+ * @module @nelsonlongxiang/dsh-open-a2a-net/zone
+ */
+/** Hard delegation-walk bound in hops (GNS `loop_threshold`). */
+export const ZONE_DEPTH_CAP = 5;
+/**
+ * Resolve one name starting from a zone's base URL.
+ * @param fetchCard - verified-card fetch for one zone URL.
+ * @param startUrl - base URL of the zone the name resolves in.
+ * @param name - the zone-relative name (a team name).
+ * @returns the resolved zone URL with its verified card, or the closed-failure reason.
+ */
+export async function resolveZone(fetchCard, startUrl, name) {
+    if (name === '')
+        return { ok: false, reason: 'not-found', detail: 'empty name' };
+    return walk(fetchCard, startUrl, name, undefined, new Set([startUrl]), 0);
+}
+/**
+ * One delegation hop. The zone's own team is authoritative for the name;
+ * a delegate record hands the name to another zone.
+ * @param fetchCard - verified-card fetch for one zone URL.
+ * @param url - the zone being consulted.
+ * @param name - the zone-relative name.
+ * @param expectedKey - base64 SPKI key the consulted card must present when the delegating record bound one.
+ * @param visited - zone URLs already consulted (cycle detection).
+ * @param depth - delegations already walked.
+ * @returns the resolved zone, or the closed-failure reason.
+ */
+async function walk(fetchCard, url, name, expectedKey, visited, depth) {
+    if (depth > ZONE_DEPTH_CAP) {
+        return { ok: false, reason: 'depth', detail: `delegation walk exceeded ${String(ZONE_DEPTH_CAP)} hops at ${url}` };
+    }
+    const card = await fetchCard(url);
+    if (card === undefined)
+        return { ok: false, reason: 'unreachable', detail: url };
+    if (expectedKey !== undefined && card.publicKey !== expectedKey) {
+        return { ok: false, reason: 'key-mismatch', detail: `${url} does not present the delegating zone's bound key` };
+    }
+    if (card.team === name)
+        return { ok: true, url, card };
+    const delegate = (card.records ?? []).find(record => record.name === name);
+    if (delegate === undefined)
+        return { ok: false, reason: 'not-found', detail: `zone ${url} publishes no ${name}` };
+    if (visited.has(delegate.url)) {
+        return { ok: false, reason: 'cycle', detail: `delegation cycle through ${delegate.url}` };
+    }
+    visited.add(delegate.url);
+    return walk(fetchCard, delegate.url, name, delegate.publicKey, visited, depth + 1);
+}

package/package.json

@@ -0,0 +1,157 @@
+{
+  "name": "@nelsonlongxiang/dsh-open-a2a-net",
+  "version": "0.5.13",
+  "description": "Open A2A network plugin for DeepSeek Harness: signed agent cards, decentralized peer/zone discovery, direct routing model tools, and joinable session nodes with a sidebar control",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./client": {
+      "types": "./lib/types/client/index.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "images",
+    "README_zh.md",
+    "cordis.patch.yml",
+    "README.md"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-slots",
+        "@deepseek-ai/dsh-client-ui-sidebar"
+      ]
+    }
+  },
+  "scripts": {
+    "prepare": "pnpm build",
+    "build": "tsc -p tsconfig.json && tsc -p tsconfig.client.json && tsdown",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.client.json --noEmit",
+    "test": "vitest run",
+    "test:build-layout": "vitest run tests/build-layout.spec.ts",
+    "verify": "pnpm typecheck && pnpm build && pnpm test && pnpm test:build-layout"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": ">=4.0.1",
+    "@deepseek-ai/cordis-plugin-loader": ">=1.0.2",
+    "@deepseek-ai/cordis-plugin-timer": ">=1.1.3",
+    "@deepseek-ai/dsh-agent": ">=0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-locale": ">=0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-runtime": ">=0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-ui-primitives": ">=0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-ui-sidebar": ">=0.1.0-rc.6",
+    "@deepseek-ai/dsh-client-ui-slots": ">=0.1.0-rc.6",
+    "@deepseek-ai/dsh-home-paths": ">=0.1.0-rc.6",
+    "@deepseek-ai/dsh-host-apiproxy": ">=0.1.0-rc.6",
+    "@deepseek-ai/dsh-host-webserver": ">=0.1.0-rc.6",
+    "@deepseek-ai/dsh-invariants": ">=0.1.0-rc.6",
+    "@deepseek-ai/dsh-llm": ">=0.1.0-rc.6",
+    "@deepseek-ai/dsh-session": ">=0.1.0-rc.6",
+    "@deepseek-ai/dsh-session-persistence": ">=0.1.0-rc.6",
+    "@deepseek-ai/dsh-session-title": ">=0.1.0-rc.6",
+    "@deepseek-ai/dsh-tools": ">=0.1.0-rc.6",
+    "@deepseek-ai/schemastery": ">=3.18.1",
+    "react": "^18.2.0"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/cordis": {
+      "optional": true
+    },
+    "@deepseek-ai/cordis-plugin-loader": {
+      "optional": true
+    },
+    "@deepseek-ai/cordis-plugin-timer": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-agent": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-client-locale": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-client-runtime": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-client-ui-primitives": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-client-ui-sidebar": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-client-ui-slots": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-home-paths": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-host-apiproxy": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-host-webserver": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-invariants": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-llm": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-session": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-session-persistence": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-session-title": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-tools": {
+      "optional": true
+    },
+    "@deepseek-ai/schemastery": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@deepseek-ai/dsh-system-prompt": "0.1.0-rc.6",
+    "@testing-library/react": "^16.3.0",
+    "@types/node": "^24.13.3",
+    "@types/react": "~18.3.1",
+    "@types/react-dom": "^18.3.7",
+    "clsx": "^2.1.1",
+    "jsdom": "^26.1.0",
+    "lightningcss": "^1.33.0",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "tsdown": "0.22.2",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.8"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitee.com/NelsonLongXiang/dsh-open-a2a-net.git"
+  }
+}