@agent-network-protocol/dsh-anp 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,152 @@
-# Temporary Holding Version
+# DSH ANP
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**ANP discovery and authenticated agent-to-agent calls for DeepSeek Harness (DSH).**
+
+English | [简体中文](README.zh-CN.md)
+
+[Agent Network Protocol](https://github.com/agent-network-protocol/anp) · [Shared identity](https://github.com/agent-network-protocol/anp-identity) · [Three-protocol example server](https://github.com/AgentConnect/service-agent) · [Apache-2.0](LICENSE)
+
+## Why this exists
+
+A personal agent should not need a different account and private key at every service it contacts. DSH ANP lets a DeepSeek Harness agent **reuse a user-created, locally held identity** to discover other agents and call their advertised APIs. The user approves which installed plugin may use that identity and which HTTPS destinations it may contact.
+
+This is one part of a larger interoperable identity flow:
+
+| Protocol | How the shared identity is used | Client |
+| --- | --- | --- |
+| **ANP** | A published `did:wba` identity authenticates individual HTTP requests using local signing capabilities. No OAuth token is required for this path. | **This plugin** |
+| **MCP** | Public CIMD/JWKS metadata identifies the OAuth client; `private_key_jwt` and `client_credentials` can obtain a policy-limited machine access token. | [DSH MCP integration](https://github.com/AgentConnect/dsh-harness-identity) |
+| **PAP 0.3** | The identity authorizes a Delegation and signed `Poppy-Session`; account access, when supported, is a separate explicit authorization. | [DSH PAP](https://github.com/AgentConnect/dsh-pap) |
+
+These are **protocol-specific proofs and permissions**, not interchangeable credentials or a universal bypass of a service's admission policy. Agent private keys stay in local custody, not in this plugin or the destination service.
+
+## What the plugin does
+
+1. `anp_discover({ domain })` reads the public `https://<domain>/.well-known/agent-descriptions` directory, including paginated results.
+2. `anp_describe({ agentRef })` authenticates the request and reads an advertised agent description, including linked information and interfaces.
+3. `anp_read({ resourceRef })` authenticates access to a linked resource. JSON OpenAPI 3.x descriptions yield callable operation references.
+4. `anp_call({ operationRef, path?, query?, body? })` calls an operation declared by the discovered OpenAPI document and signs that exact request.
+
+The agent uses opaque references returned by earlier tools; it does **not** invent URLs or transmit private keys. Unsupported interface types can be discovered but are not executed.
+
+## Requirements and installation
+
+- Node.js **22.13+**, a DSH Host with Cordis 4.1 and a tools registry.
+- The [ANP Identity](https://github.com/agent-network-protocol/anp-identity) shared-identity service installed in the **same Host**.
+- An existing local identity (`storeId`, `identityId`, `did`), with its public identity material published through an identity provider such as [AWiki](https://awiki.me).
+- Explicit user approval for this plugin and its target HTTPS origins.
+
+To install the DSH bundle when the package is available in your package registry:
+
+```sh
+pnpm dsh plugin --profile <profile> add @agent-network-protocol/dsh-anp
+```
+
+Or build and test from source:
+
+```sh
+git clone https://github.com/agent-network-protocol/dsh-anp.git
+cd dsh-anp
+npm ci
+npm run build
+npm test
+```
+
+For a source-pinned Host dependency, install the Git package at a specific full commit SHA; the package's prepare hook builds its exports:
+
+```sh
+npm install '@agent-network-protocol/dsh-anp@git+https://github.com/agent-network-protocol/dsh-anp.git#<full-commit-sha>'
+```
+
+**Installation alone does not create an identity, approve access, or enable signing.** The packaged Cordis bundle starts disabled.
+
+## Configure the DSH Host
+
+After setting up the shared identity service, add the installed plugin consumer to ANP Identity's `allowConsumers` and `userConsumers`, and configure its `httpAllowedOrigins` policy. The identity service and the plugin both enforce destination permissions.
+
+Example Host plugin row (replace placeholders with your existing published identity):
+
+```yaml
+- id: anp
+  name: '@agent-network-protocol/dsh-anp/plugin'
+  config:
+    enabled: true
+    allowedOrigins:
+      - 'https://agent.agent-network-protocol.com'
+    identityRef:
+      storeId: '<existing-store-id>'
+      identityId: '<existing-identity-id>'
+      did: '<existing-did:wba>'
+```
+
+The identity service must separately authorize this **exact consumer name** and the intended HTTPS origin. On its first signed request, the plugin requests permission through the local identity manager. If approval is pending, approve it in the identity manager and retry. Permanent grants can be reused; one-time grants apply to one operation. Revocation is checked on every dispatch.
+
+For an explicitly unrestricted HTTPS destination policy, both the plugin's `allowedOrigins` and ANP Identity's `httpAllowedOrigins['@agent-network-protocol/dsh-anp/plugin']` must contain `'*'`; the consumer must still be user-approved. Prefer exact origins. HTTP, URL credentials, fragments and redirects remain disallowed.
+
+## Try the live ANP service
+
+The [Agent Network Protocol service](https://agent.agent-network-protocol.com/ready) offers a three-protocol example with versioned ANP documentation, messages and public posts. Its [website](https://agent-network-protocol.com/) displays published content; [public posts](https://agent-network-protocol.com/zh/posts) can be viewed in a browser.
+
+Once identity and permissions are configured, ask the agent to run this **tool sequence**:
+
+```text
+anp_discover({ "domain": "agent.agent-network-protocol.com" })
+anp_describe({ "agentRef": "<ref returned by discover>" })
+anp_read({ "resourceRef": "<OpenAPI interface ref returned by describe>" })
+anp_call({ "operationRef": "<post_create operation ref returned by read>",
+           "body": { "content": "Hello from DSH via ANP" } })
+```
+
+The values in angle brackets are **references from previous tool responses**, not literal inputs. You can first use the discovered `protocol_list` / `protocol_get` operation to read versioned documentation, then publish a post with `post_create`. Posting requires the user's approval and a valid signed request. Confirm a successful publication via the [website posts page](https://agent-network-protocol.com/zh/posts).
+
+## Library usage
+
+`AnpClient` accepts an `authenticatedDispatch(Request)` supplied by the Host's
+authorized identity. `publicDispatch` defaults to fetch and is used only for the
+public discovery directory. Transport injection supports isolated HTTPS tests;
+it does not provide an alternative signing or private-key storage implementation.
+
+## Service Agent example
+
+https://agent-network-protocol.com is the project's example Service Agent for
+MCP, ANP and PAP. The example is mentioned in the Agent-visible discovery/status
+tool descriptions. To see ANP in action, discover `agent-network-protocol.com`,
+read the returned descriptions/interfaces, then invoke a read-only discovered
+operation. For PAP, explicitly discover that Company in settings, connect and
+enable the desired operation. MCP uses a separately configured server connection.
+No reference here grants identity access, enables an operation, bypasses protocol
+validation, or sends a request automatically. The website deployment is managed
+by the service operator and is outside this UI change's acceptance scope.
+
+## Architecture and security
+
+```text
+DSH agent
+   | ANP tool request (no credential material)
+   v
+dsh-anp / Cordis tools
+   | authorized HTTP dispatch
+   v
+ANP Identity (same Host) --- local private-key custody
+   | signed HTTPS request
+   v
+Remote ANP Service Agent --- shared document/message/post APIs
+```
+
+- Public discovery uses a separate, unauthenticated transport; description, linked-resource and business requests use the Host-authorized transport.
+- The identity manager grants only the permitted HTTP operation. It does not hand the model a raw signing key, device assertion or OAuth assertion.
+- Allowed origins are HTTPS-only. References are held in the plugin instance and must be rediscovered after reload.
+- Redirects and invalid discovery cycles fail closed. Requests that may have side effects, including POST, are **not automatically retried**.
+- The `AnpClient` library accepts an injected `authenticatedDispatch(Request)` for Host integration and isolated tests; this is not a separate key store or signing implementation.
+
+## Related projects
+
+- [ANP Identity](https://github.com/agent-network-protocol/anp-identity) — native local key custody and the shared DSH identity service (`packages/dsh-anp-identity`).
+- [AWiki User Service](https://github.com/AgentConnect/user-service) — publishes DID, CIMD and JWKS material without receiving the private key.
+- [DSH PAP](https://github.com/AgentConnect/dsh-pap) — PAP 0.3 Client, Delegation/Session and optional account sign-in.
+- [Service Agent](https://github.com/AgentConnect/service-agent) — ANP, MCP and PAP reference server.
+- [DSH Harness Identity](https://github.com/AgentConnect/dsh-harness-identity) — shared-identity-aware DSH Host and MCP OAuth client.
+
+## License
+
+[Apache-2.0](LICENSE).

package/README.zh-CN.md

@@ -0,0 +1,111 @@
+# DSH ANP
+
+**DeepSeek Harness（DSH）的 ANP 智能体发现与身份认证调用插件。**
+
+[English](README.md) | 简体中文
+
+[ANP 协议](https://github.com/agent-network-protocol/anp) · [共享身份底座](https://github.com/agent-network-protocol/anp-identity) · [三协议服务端](https://github.com/AgentConnect/service-agent) · [Apache-2.0](LICENSE)
+
+## 解决什么问题
+
+Personal Agent 不应该在每一个服务或 Service Agent 上重复创建账户和管理私钥。本插件让 DSH 智能体复用一套**用户创建、私钥保留在本地的身份**，按用户授权发现外部智能体、读取描述并调用业务接口。
+
+共享身份通过三种协议复用，但各自使用不同的认证机制：
+
+| 协议 | 身份与授权机制 | 客户端 |
+| --- | --- | --- |
+| **ANP** | 以已发布的 `did:wba` 身份对 HTTP 请求签名，不要求 ANP OAuth Token。 | **本插件** |
+| **MCP** | CIMD/JWKS 公开客户端身份，`private_key_jwt` + `client_credentials` 按服务端策略申请机器 Token。 | [DSH MCP 集成](https://github.com/AgentConnect/dsh-harness-identity) |
+| **PAP 0.3** | 共享身份签发 Delegation，按请求使用 `Poppy-Session`；账户授权是可选且独立的过程。 | [DSH PAP](https://github.com/AgentConnect/dsh-pap) |
+
+复用身份**不等于绕过服务端准入、资源授权和用户操作授权**；三种协议的 Token 和证明材料不能混用。
+
+## 核心能力
+
+| 工具 | 功能 |
+| --- | --- |
+| `anp_discover({domain})` | 获取目标域名下的 `/.well-known/agent-descriptions` 及其分页目录 |
+| `anp_describe({agentRef})` | 使用本地授权身份读取 Agent Description、关联资料和接口 |
+| `anp_read({resourceRef})` | 读取已发现的资料和 OpenAPI 3.x，并生成操作引用 |
+| `anp_call({operationRef, path?, query?, body?})` | 调用 OpenAPI 声明的业务接口并对请求签名 |
+
+调用所需的 `agentRef`、`resourceRef`、`operationRef` 必须来自前一步结果；不会把私钥交给模型。其他接口协议可见，但尚不能直接执行。
+
+## 安装
+
+要求 Node.js **22.13+**、具有 Cordis 4.1 和工具注册表的 DSH Host，以及同一 Host 内已安装的 [ANP Identity](https://github.com/agent-network-protocol/anp-identity)。用户须先建立本地身份，并通过 [AWiki 身份服务](https://awiki.me) 等发布 DID 公共材料。
+
+已有可用 npm 包的情况下，安装 DSH Bundle：
+
+```sh
+pnpm dsh plugin --profile <profile> add @agent-network-protocol/dsh-anp
+```
+
+从源码构建验证：
+
+```sh
+git clone https://github.com/agent-network-protocol/dsh-anp.git
+cd dsh-anp
+npm ci
+npm run build
+npm test
+```
+
+**安装不等于启用。** 插件默认关闭，不会自动创建身份或获得签名授权。
+
+## Host 配置
+
+先在公共身份插件中将 `@agent-network-protocol/dsh-anp/plugin` 加入 `allowConsumers` 与 `userConsumers`，并针对目标域名配置 `httpAllowedOrigins`。之后配置插件：
+
+```yaml
+- id: anp
+  name: '@agent-network-protocol/dsh-anp/plugin'
+  config:
+    enabled: true
+    allowedOrigins:
+      - 'https://agent.agent-network-protocol.com'
+    identityRef:
+      storeId: '<existing-store-id>'
+      identityId: '<existing-identity-id>'
+      did: '<existing-did:wba>'
+```
+
+上述身份引用必须来自已存在、已发布的本地身份。首次请求会申请本地授权；等待批准时应在身份管理器中批准，再重试。长期授权可复用，一次性授权只覆盖对应操作；撤销后调用会被拒绝。建议只允许明确的 HTTPS Origin。
+
+## 使用线上实例验证
+
+线上示例：[三协议服务健康检查](https://agent.agent-network-protocol.com/ready)、[ANP 官网](https://agent-network-protocol.com/)、[公开帖子](https://agent-network-protocol.com/zh/posts)。
+
+配置好身份后，在 DSH 中依次使用：
+
+```text
+anp_discover({ "domain": "agent.agent-network-protocol.com" })
+anp_describe({ "agentRef": "<上一步返回的引用>" })
+anp_read({ "resourceRef": "<上一步返回的 OpenAPI 引用>" })
+anp_call({ "operationRef": "<post_create 对应的操作引用>",
+           "body": { "content": "Hello from DSH via ANP" } })
+```
+
+尖括号中的值需要从实际工具返回结果中取得，**不能直接照抄**。还可以通过发现的 `protocol_list`、`protocol_get` 操作读取 ANP 指定版本、指定语言的文档。发布成功后，在[官网帖子页面](https://agent-network-protocol.com/zh/posts)查看结果。
+
+## 原理和安全边界
+
+```text
+DSH Agent → dsh-anp 工具 → 同一 Host 的 ANP Identity
+                               └ 本地私钥签名
+                         → HTTPS ANP Service Agent
+                         → 共享的文档 / 留言 / 帖子业务
+```
+
+- 公共目录发现不需要签名；读取描述、资源和业务调用使用授权签名通道。
+- 模型不能获得原始私钥、设备断言或 OAuth 断言；所有签名都经由本地身份底座。
+- 限制目标 HTTPS Origin；HTTP、带凭据 URL、片段和重定向均被拒绝。`'*'` 通配允许所有 HTTPS Origin，必须在插件和身份服务两端显式配置并取得用户批准。
+- 引用存放在当前插件实例中；重启后须重新发现。POST 等副作用请求不会自动重试。
+
+## 相关项目
+
+[ANP Identity](https://github.com/agent-network-protocol/anp-identity) · [AWiki User Service](https://github.com/AgentConnect/user-service) · [DSH PAP](https://github.com/AgentConnect/dsh-pap) · [Service Agent](https://github.com/AgentConnect/service-agent) · [DSH Harness Identity](https://github.com/AgentConnect/dsh-harness-identity)
+
+## 许可
+
+[Apache-2.0](LICENSE)。

package/cordis.patch.yml

@@ -0,0 +1,6 @@
+# Configure an existing identity and approved HTTPS origins before enabling.
+- insert:
+    - id: anp
+      name: '@agent-network-protocol/dsh-anp/plugin'
+      config:
+        enabled: false

package/lib/index.d.ts

@@ -0,0 +1,64 @@
+type Json = Record<string, unknown>;
+export type Dispatch = (request: Request) => Promise<Response>;
+export interface AnpClientOptions {
+    /** Exact HTTPS origins, or an explicit '*' to allow any HTTPS origin. */
+    allowedOrigins: string[];
+    authenticatedDispatch: Dispatch;
+    publicDispatch?: Dispatch;
+}
+export declare class AnpError extends Error {
+    readonly code: string;
+    constructor(code: string);
+}
+/** Public references contain no signing capabilities. The Host owns the dispatcher. */
+export declare class AnpClient {
+    private readonly options;
+    private readonly origins;
+    private readonly resources;
+    private readonly operations;
+    constructor(options: AnpClientOptions);
+    private target;
+    private add;
+    private request;
+    discover(domain: string): Promise<{
+        count: number;
+        complete: boolean;
+        agents: {
+            agentRef: string;
+            name: string;
+            url: string;
+        }[];
+    }>;
+    describe(agentRef: string): Promise<{
+        links: {
+            resourceRef: string;
+            kind: string;
+            description?: unknown;
+            protocol?: string;
+        }[];
+        url: string;
+        contentType: string;
+        content: unknown;
+    }>;
+    read(resourceRef: string): Promise<{
+        operations: {
+            operationRef: string;
+            operationId: string;
+            method: string;
+            url: string;
+        }[];
+        url: string;
+        contentType: string;
+        content: unknown;
+    }>;
+    call(operationRef: string, args?: {
+        path?: Json;
+        query?: Json;
+        body?: unknown;
+    }): Promise<{
+        url: string;
+        contentType: string;
+        content: unknown;
+    }>;
+}
+export {};

package/lib/index.js

@@ -0,0 +1,243 @@
+import { randomUUID } from "node:crypto";
+export class AnpError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+    }
+}
+const requireValue = (condition, code = "invalid_document") => {
+    if (!condition)
+        throw new AnpError(code);
+};
+const object = (value) => {
+    requireValue(value !== null && typeof value === "object" && !Array.isArray(value));
+    return value;
+};
+/** Public references contain no signing capabilities. The Host owns the dispatcher. */
+export class AnpClient {
+    options;
+    origins;
+    resources = new Map();
+    operations = new Map();
+    constructor(options) {
+        this.options = options;
+        this.origins = new Set(options.allowedOrigins.map((value) => {
+            if (value === "*")
+                return value;
+            const url = new URL(value);
+            requireValue(url.protocol === "https:" && url.origin === value, "invalid_origin");
+            return url.origin;
+        }));
+    }
+    target(value, base) {
+        const url = new URL(value, base);
+        requireValue(url.protocol === "https:" &&
+            !url.username &&
+            !url.password &&
+            !url.hash &&
+            (this.origins.has("*") || this.origins.has(url.origin)), "origin_not_approved");
+        return url.href;
+    }
+    add(resource) {
+        const entry = [...this.resources].find(([, value]) => value.url === resource.url && value.kind === resource.kind);
+        if (entry)
+            return entry[0];
+        const ref = randomUUID();
+        this.resources.set(ref, resource);
+        return ref;
+    }
+    async request(url, init = {}, signed = true) {
+        const request = new Request(this.target(url), {
+            ...init,
+            redirect: "manual",
+            signal: AbortSignal.timeout(10000),
+            credentials: "omit",
+        });
+        const response = await (signed
+            ? this.options.authenticatedDispatch
+            : (this.options.publicDispatch ?? fetch))(request);
+        requireValue(response.ok && !response.redirected, "http_request_failed");
+        const reader = response.body?.getReader();
+        const chunks = [];
+        let size = 0;
+        if (reader) {
+            try {
+                while (true) {
+                    const part = await reader.read();
+                    if (part.done)
+                        break;
+                    size += part.value.length;
+                    if (size > 4 * 1024 * 1024) {
+                        await reader.cancel();
+                        throw new AnpError("response_too_large");
+                    }
+                    chunks.push(part.value);
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+        }
+        const contentType = response.headers.get("content-type") ?? "text/plain";
+        const text = Buffer.concat(chunks).toString("utf8");
+        return {
+            url,
+            contentType,
+            content: /json/i.test(contentType) ? JSON.parse(text) : text,
+        };
+    }
+    async discover(domain) {
+        requireValue(typeof domain === "string" && !!domain && !/[/?#@\\]/.test(domain), "invalid_domain");
+        let url = this.target(`https://${domain}/.well-known/agent-descriptions`);
+        const visited = new Set();
+        const agents = new Map();
+        while (url) {
+            requireValue(!visited.has(url) && visited.size < 64, "invalid_pagination");
+            visited.add(url);
+            const page = object((await this.request(url, {}, false)).content);
+            requireValue(page["@type"] === "CollectionPage" && Array.isArray(page.items));
+            for (const value of page.items) {
+                const item = object(value);
+                requireValue(typeof item["@id"] === "string" && typeof item.name === "string");
+                const target = this.target(item["@id"], url);
+                agents.set(target, {
+                    agentRef: this.add({ url: target, kind: "agent" }),
+                    name: item.name,
+                    url: target,
+                });
+            }
+            requireValue(page.next === undefined || typeof page.next === "string");
+            url =
+                page.next === undefined
+                    ? undefined
+                    : this.target(page.next, url);
+        }
+        return { count: agents.size, complete: true, agents: [...agents.values()] };
+    }
+    async describe(agentRef) {
+        const resource = this.resources.get(agentRef);
+        requireValue(resource?.kind === "agent", "unknown_agent");
+        const result = await this.request(resource.url);
+        const document = object(result.content);
+        requireValue(document.protocolType === "ANP" && document.type === "AgentDescription");
+        const links = [];
+        for (const [field, kind] of [
+            ["Infomations", "information"],
+            ["interfaces", "interface"],
+        ]) {
+            requireValue(document[field] === undefined || Array.isArray(document[field]));
+            for (const value of document[field] ?? []) {
+                const link = object(value);
+                if (typeof link.url !== "string")
+                    continue;
+                const target = this.target(link.url, resource.url);
+                const protocol = typeof link.protocol === "string" ? link.protocol : undefined;
+                links.push({
+                    resourceRef: this.add({ url: target, kind, protocol }),
+                    kind,
+                    ...(link.description === undefined ? {} : { description: link.description }),
+                    ...(protocol === undefined ? {} : { protocol }),
+                });
+            }
+        }
+        return { ...result, links };
+    }
+    async read(resourceRef) {
+        const resource = this.resources.get(resourceRef);
+        requireValue(resource && resource.kind !== "agent", "unknown_resource");
+        const result = await this.request(resource.url);
+        const operations = [];
+        if (resource.kind === "interface" &&
+            /openapi/i.test(resource.protocol ?? "")) {
+            const spec = object(result.content);
+            requireValue(typeof spec.openapi === "string" && spec.openapi.startsWith("3."));
+            const servers = spec.servers === undefined
+                ? [{ url: new URL(resource.url).origin }]
+                : spec.servers;
+            requireValue(Array.isArray(servers) && servers.length > 0);
+            const base = this.target(String(object(servers[0]).url), resource.url).replace(/\/$/, "");
+            for (const [path, value] of Object.entries(object(spec.paths))) {
+                requireValue(path.startsWith("/") &&
+                    !path.startsWith("//") &&
+                    !/[?#\\]/.test(path));
+                const item = object(value);
+                requireValue(item.servers === undefined && item.$ref === undefined, "unsupported_openapi");
+                for (const method of [
+                    "get",
+                    "post",
+                    "put",
+                    "patch",
+                    "delete",
+                    "head",
+                    "options",
+                ]) {
+                    if (item[method] === undefined)
+                        continue;
+                    const operation = object(item[method]);
+                    requireValue(operation.servers === undefined && operation.$ref === undefined, "unsupported_openapi");
+                    const parameters = [
+                        ...(item.parameters ?? []),
+                        ...(operation.parameters ?? []),
+                    ].map(object);
+                    requireValue(parameters.every((p) => p.$ref === undefined &&
+                        ["path", "query"].includes(String(p.in))), "unsupported_openapi");
+                    const operationRef = randomUUID();
+                    const target = this.target(base + path);
+                    this.operations.set(operationRef, {
+                        url: target,
+                        method: method.toUpperCase(),
+                        parameters,
+                        hasBody: operation.requestBody !== undefined,
+                    });
+                    operations.push({
+                        operationRef,
+                        operationId: String(operation.operationId ?? `${method} ${path}`),
+                        method: method.toUpperCase(),
+                        url: target,
+                    });
+                }
+            }
+        }
+        return { ...result, operations };
+    }
+    async call(operationRef, args = {}) {
+        const operation = this.operations.get(operationRef);
+        requireValue(operation, "unknown_operation");
+        let target = operation.url;
+        for (const [location, supplied] of [
+            ["path", args.path ?? {}],
+            ["query", args.query ?? {}],
+        ]) {
+            for (const key of Object.keys(supplied))
+                requireValue(operation.parameters.some((p) => p.in === location && p.name === key), "unknown_parameter");
+            for (const parameter of operation.parameters.filter((p) => p.in === location)) {
+                const value = supplied[String(parameter.name)];
+                requireValue(value !== undefined || parameter.required !== true, "missing_parameter");
+                if (value === undefined)
+                    continue;
+                requireValue(["string", "number", "boolean"].includes(typeof value), "invalid_parameter");
+                if (location === "path") {
+                    requireValue(value !== "." && value !== "..", "invalid_parameter");
+                    target = target
+                        .replace(`{${parameter.name}}`, encodeURIComponent(String(value)))
+                        .replace(`%7B${parameter.name}%7D`, encodeURIComponent(String(value)));
+                }
+            }
+        }
+        requireValue(!/[{}]/.test(decodeURI(target)), "missing_parameter");
+        const url = new URL(target);
+        for (const [key, value] of Object.entries(args.query ?? {}))
+            url.searchParams.set(key, String(value));
+        requireValue(args.body === undefined || operation.hasBody, "unexpected_body");
+        return this.request(url.href, {
+            method: operation.method,
+            ...(args.body === undefined
+                ? {}
+                : {
+                    headers: { "content-type": "application/json" },
+                    body: JSON.stringify(args.body),
+                }),
+        });
+    }
+}

package/lib/plugin.d.ts

@@ -0,0 +1,14 @@
+import type { Context } from "@deepseek-ai/cordis";
+export declare const name = "@agent-network-protocol/dsh-anp/plugin";
+export declare const inject: string[];
+export interface Config {
+    enabled?: boolean;
+    allowedOrigins: string[];
+    identityRef: {
+        storeId: string;
+        identityId: string;
+        did: string;
+    };
+    grantId?: string;
+}
+export declare function apply(ctx: Context, config: Config): void;

package/lib/plugin.js

@@ -0,0 +1,104 @@
+import { randomUUID } from "node:crypto";
+import { AnpClient, AnpError } from "./index.js";
+export const name = "@agent-network-protocol/dsh-anp/plugin";
+export const inject = ["anpIdentity", "tools"];
+const identityFailures = {
+    provider_incompatible: "identity_provider_incompatible",
+    consumer_forbidden: "identity_consumer_forbidden",
+    operation_not_permitted: "identity_operation_not_permitted",
+    grant_inactive: "identity_authorization_unavailable",
+    grant_conflict: "identity_authorization_unavailable",
+};
+function failureCode(error) {
+    if (error instanceof AnpError)
+        return error.code;
+    if (error && typeof error === "object" && "code" in error && typeof error.code === "string") {
+        return Object.hasOwn(identityFailures, error.code) ? identityFailures[error.code] : "anp_request_failed";
+    }
+    return "anp_request_failed";
+}
+export function apply(ctx, config) {
+    if (!config.enabled)
+        return;
+    const identity = ctx.get("anpIdentity").bindUserConsumer(ctx);
+    let grantId = config.grantId;
+    const pending = new Map();
+    const client = new AnpClient({
+        allowedOrigins: config.allowedOrigins,
+        authenticatedDispatch: async (request) => {
+            if (!grantId) {
+                const key = `${request.method} ${request.url} ${await request.clone().text()}`;
+                const old = pending.get(key);
+                const access = old
+                    ? await identity.getAccessRequest(old)
+                    : await identity.requestAccess({
+                        requestId: `anp-${randomUUID()}`,
+                        identity: config.identityRef,
+                        purpose: `ANP ${request.method} ${new URL(request.url).origin}`,
+                        operation: { action: "http", request },
+                    });
+                if (access.status !== "approved" || !access.grantId) {
+                    if (access.status === "pending")
+                        pending.set(key, access.id);
+                    else
+                        pending.delete(key);
+                    throw new AnpError("identity_authorization_required");
+                }
+                pending.delete(key);
+                if (access.mode === "permanent")
+                    grantId = access.grantId;
+                const authorized = await identity.openAuthorizedIdentity(access.grantId);
+                return authorized.authenticatedHttp.dispatch(request);
+            }
+            return (await identity.openAuthorizedIdentity(grantId)).authenticatedHttp.dispatch(request);
+        },
+    });
+    let stopped = false;
+    ctx.effect(() => () => {
+        stopped = true;
+        pending.clear();
+    });
+    const tools = ctx.get("tools");
+    const register = (toolName, properties, required, run) => tools.register({
+        name: toolName,
+        description: `ANP ${toolName.slice(4)} using discovered references and the locally authorized identity.` + (toolName === "anp_discover" ? " Example Service Agent: https://agent-network-protocol.com supports MCP, ANP and PAP. To demonstrate ANP, use anp_discover with domain agent-network-protocol.com, then read discovered descriptions/interfaces and invoke a read-only example. For PAP, ask the user to discover this Company and enable an operation in PAP settings first. MCP requires a configured server connection. Keep all identity approvals and user permissions." : ""),
+        parameters: {
+            type: "object",
+            properties,
+            required,
+            additionalProperties: false,
+        },
+        output: {
+            schema: { type: "object", additionalProperties: true },
+            render: (_args, value) => [
+                { type: "text", text: JSON.stringify(value) },
+            ],
+        },
+        execute: async (args, execution) => {
+            if (stopped || !execution.agent || execution.signal?.aborted)
+                return { ok: false, error: "unavailable" };
+            try {
+                const value = await run(args);
+                return stopped
+                    ? { ok: false, error: "unavailable" }
+                    : { ok: true, value };
+            }
+            catch (error) {
+                return {
+                    ok: false,
+                    error: failureCode(error),
+                };
+            }
+        },
+    });
+    const string = { type: "string" };
+    register("anp_discover", { domain: string }, ["domain"], (args) => client.discover(String(args.domain)));
+    register("anp_describe", { agentRef: string }, ["agentRef"], (args) => client.describe(String(args.agentRef)));
+    register("anp_read", { resourceRef: string }, ["resourceRef"], (args) => client.read(String(args.resourceRef)));
+    register("anp_call", {
+        operationRef: string,
+        path: { type: "object" },
+        query: { type: "object" },
+        body: {},
+    }, ["operationRef"], (args) => client.call(String(args.operationRef), args));
+}

package/package.json

@@ -1,6 +1,57 @@
 {
   "name": "@agent-network-protocol/dsh-anp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "type": "module",
+  "description": "ANP discovery and authenticated interaction for DeepSeek Harness",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/agent-network-protocol/dsh-anp.git"
+  },
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": "./lib/index.js",
+    "./plugin": "./lib/plugin.js",
+    "./cordis.patch.yml": "./cordis.patch.yml"
+  },
+  "files": [
+    "lib",
+    "README.md",
+    "LICENSE",
+    "cordis.patch.yml",
+    "README.zh-CN.md"
+  ],
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "npm run build && tsx --test tests/*.test.ts",
+    "prepare": "npm run build",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "@deepseek-ai/cordis": "4.1.0"
+  },
+  "devDependencies": {
+    "typescript": "6.0.3",
+    "tsx": "4.20.6",
+    "@types/node": "24.3.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "keywords": [
+    "anp",
+    "deepseek-harness",
+    "dsh-plugin"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  }
+}