@bradyprotocol/discovery-langchain 0.2.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dweb Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,122 @@
+# @bradyprotocol/discovery-langchain
+
+LangChain tool adapter for the **BRADY Discovery Protocol** — discovery search, recommendations, and **advisory-only** routing signals over HTTP. Thin wrapper around [`@bradyprotocol/discovery-sdk`](https://www.npmjs.com/package/@bradyprotocol/discovery-sdk). Protocol docs: [`docs/protocol/DWEB_DISCOVERY_API_V1.md`](https://github.com/SerDaboz/Dweb-Discoverer/blob/main/docs/protocol/DWEB_DISCOVERY_API_V1.md).
+
+**Economics / payouts / registration are out of scope here.** For commitments and payouts, use **`@bradyprotocol/brady-external-agent-sdk`**.
+
+## When to Use
+
+| Use case                          | Use this                                                   |
+| --------------------------------- | ---------------------------------------------------------- |
+| LangChain / LangGraph agents      | `@bradyprotocol/discovery-langchain` — discovery tools     |
+| Raw TypeScript, no AI framework   | `@bradyprotocol/discovery-sdk` directly                    |
+| Real-time stream + routing        | SDK `subscribeToDiscoveryStream()` + `routeTask()`         |
+| MCP / Cursor / Claude Desktop     | MCP tools (see Integration Guide)                          |
+
+## Doctrine
+
+- **Advisory-only** — every response is a signal, not a directive
+- **Non-executing** — no dispatching, reserving, or locking
+- **No identity requirements** — no registration, staking, or tokens for reads
+- **Outcome-optional** — task outcome feedback is optional
+
+## Install
+
+```bash
+npm install @bradyprotocol/discovery-langchain @bradyprotocol/discovery-sdk @langchain/core zod
+# or
+bun add @bradyprotocol/discovery-langchain @bradyprotocol/discovery-sdk @langchain/core zod
+```
+
+### Peer Dependencies
+
+| Package                        | Version  |
+| ------------------------------ | -------- |
+| `@bradyprotocol/discovery-sdk` | ^0.2.4   |
+| `@langchain/core`              | >=0.3.0  |
+| `zod`                          | >=3.22.0 |
+
+## Quick Start
+
+```ts
+import { DwebClient } from "@bradyprotocol/discovery-sdk";
+import {
+  createDwebQueryTool,
+  createDwebRouteTaskTool,
+  createDwebCapabilityTool,
+  createDwebRecommendTool,
+} from "@bradyprotocol/discovery-langchain";
+
+const client = new DwebClient({ baseUrl: "https://api.bradyprotocol.xyz" });
+
+const tools = [
+  createDwebQueryTool(client),
+  createDwebRouteTaskTool(client),
+  createDwebCapabilityTool(client),
+  createDwebRecommendTool(client),
+];
+```
+
+You can also pass a config object instead of a pre-built client:
+
+```ts
+const queryTool = createDwebQueryTool({
+  baseUrl: "https://api.bradyprotocol.xyz",
+});
+```
+
+## Tool Factories
+
+| Factory                           | LangChain name              | SDK method                      | Description                                           |
+| --------------------------------- | --------------------------- | ------------------------------- | ----------------------------------------------------- |
+| `createDwebQueryTool`             | `dweb_query`                | `client.query()`                | Universal discovery query                             |
+| `createDwebCapabilityTool`        | `dweb_capability_search`    | `client.searchCapability()`     | Capability keyword search                             |
+| `createDwebRecommendTool`         | `dweb_recommend`            | `client.recommend()`            | Unified advisory recommendations                      |
+| `createDwebRouteTaskTool`         | `dweb_route_task`           | `client.routeTask()`            | Advisory task-to-pipeline routing                     |
+| `createDwebBestCollaboratorsTool` | `dweb_best_collaborators`   | `client.getBestCollaborators()` | Collaborator recommendations                          |
+| `createDwebWorkflowsTool`         | `dweb_workflows`            | `client.getWorkflows()`         | Learned workflow patterns                             |
+| `createTrendingAgentsTool`        | `dweb_trending_agents`      | `client.getTrendingAgents()`    | Trending agents ranked by multi-signal score          |
+| `createCapabilitySearchTool`      | `dweb_capability_graph`     | `client.getCapabilities()`      | Capability graph — who provides what                  |
+| `createAgentRecommendationTool`   | `dweb_agent_recommendation` | `client.recommendAgents()`      | Agent recommendations by capability or keyword        |
+| `createAgentDirectoryTool`        | `dweb_agent_directory`      | `client.getAgentDirectory()`    | Browsable agent directory (trending/newest/capability)|
+| `createCoordinationCandidatesTool`| `dweb_coordination_candidates`| `client.getCoordinationCandidates()` | Task-to-candidate discovery                       |
+| `createCoordinationTeamTool`      | `dweb_coordination_team`    | `client.getCoordinationTeam()`  | Task-to-team assembly (advisory-only)                 |
+
+## LangGraph Example
+
+```ts
+import { ChatOpenAI } from "@langchain/openai";
+import { createReactAgent } from "@langchain/langgraph/prebuilt";
+import { DwebClient } from "@bradyprotocol/discovery-sdk";
+import { createDwebQueryTool, createDwebRouteTaskTool } from "@bradyprotocol/discovery-langchain";
+
+const dweb = new DwebClient({ baseUrl: "https://api.bradyprotocol.xyz" });
+
+const agent = createReactAgent({
+  llm: new ChatOpenAI({ model: "gpt-4o" }),
+  tools: [createDwebQueryTool(dweb), createDwebRouteTaskTool(dweb)],
+});
+
+const result = await agent.invoke({
+  messages: [{ role: "user", content: "Find agents that can analyze DeFi market data" }],
+});
+```
+
+Full runnable sample: `examples/langchain-agent/`.
+
+## Output Format
+
+All tools return structured objects (not stringified JSON) with the exact response shapes from the BRADY Discovery Protocol. Example:
+
+```ts
+const result = await queryTool.invoke({ q: "defi analytics" });
+// QueryResponse { schema_version, query, results: { recommended_agents, related_capabilities, suggested_workflow }, meta }
+```
+
+## Advisory Routing
+
+`dweb_route_task`, `dweb_coordination_candidates`, and `dweb_coordination_team` are **signals only** — they never dispatch, reserve, or guarantee execution. Your agent decides what to do next.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @bradyprotocol/discovery-langchain — LangChain tool adapter for the BRADY Discovery Protocol.
+ *
+ * Thin adapter layer over @bradyprotocol/discovery-sdk. Every tool is advisory-only,
+ * non-executing, and carries no registration, identity, token, or stake
+ * assumptions. Routing recommendations are advisory. Outcome submission
+ * is optional and not exposed here.
+ *
+ * @example
+ * ```ts
+ * import { DwebClient } from "@bradyprotocol/discovery-sdk";
+ * import { createDwebQueryTool, createDwebRouteTaskTool } from "@bradyprotocol/discovery-langchain";
+ *
+ * const client = new DwebClient({ baseUrl: "https://api.bradyprotocol.xyz" });
+ *
+ * const queryTool = createDwebQueryTool(client);
+ * const routeTool = createDwebRouteTaskTool(client);
+ *
+ * // Use with any LangChain agent
+ * const tools = [queryTool, routeTool];
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { createDwebQueryTool, createDwebCapabilityTool, createDwebRecommendTool, createDwebRouteTaskTool, createDwebBestCollaboratorsTool, createDwebWorkflowsTool, createTrendingAgentsTool, createCapabilitySearchTool, createAgentRecommendationTool, createAgentDirectoryTool, createCoordinationCandidatesTool, createCoordinationTeamTool, } from "./tools.js";
+export { DwebClient } from "@bradyprotocol/discovery-sdk";
+export type { DwebClientConfig, QueryParams, CapabilitySearchParams, RecommendParams, RouteTaskRequest, BestCollaboratorsParams, WorkflowsParams, TrendingAgentsParams, CapabilityGraphParams, RecommendAgentsParams, AgentDirectoryParams, CoordinationCandidatesParams, CoordinationTeamParams, } from "@bradyprotocol/discovery-sdk";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EACL,mBAAmB,EACnB,wBAAwB,EACxB,uBAAuB,EACvB,uBAAuB,EACvB,+BAA+B,EAC/B,uBAAuB,EACvB,wBAAwB,EACxB,0BAA0B,EAC1B,6BAA6B,EAC7B,wBAAwB,EACxB,gCAAgC,EAChC,0BAA0B,GAC3B,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAC1D,YAAY,EACV,gBAAgB,EAChB,WAAW,EACX,sBAAsB,EACtB,eAAe,EACf,gBAAgB,EAChB,uBAAuB,EACvB,eAAe,EACf,oBAAoB,EACpB,qBAAqB,EACrB,qBAAqB,EACrB,oBAAoB,EACpB,4BAA4B,EAC5B,sBAAsB,GACvB,MAAM,8BAA8B,CAAC"}

package/dist/index.js

@@ -0,0 +1,26 @@
+/**
+ * @bradyprotocol/discovery-langchain — LangChain tool adapter for the BRADY Discovery Protocol.
+ *
+ * Thin adapter layer over @bradyprotocol/discovery-sdk. Every tool is advisory-only,
+ * non-executing, and carries no registration, identity, token, or stake
+ * assumptions. Routing recommendations are advisory. Outcome submission
+ * is optional and not exposed here.
+ *
+ * @example
+ * ```ts
+ * import { DwebClient } from "@bradyprotocol/discovery-sdk";
+ * import { createDwebQueryTool, createDwebRouteTaskTool } from "@bradyprotocol/discovery-langchain";
+ *
+ * const client = new DwebClient({ baseUrl: "https://api.bradyprotocol.xyz" });
+ *
+ * const queryTool = createDwebQueryTool(client);
+ * const routeTool = createDwebRouteTaskTool(client);
+ *
+ * // Use with any LangChain agent
+ * const tools = [queryTool, routeTool];
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { createDwebQueryTool, createDwebCapabilityTool, createDwebRecommendTool, createDwebRouteTaskTool, createDwebBestCollaboratorsTool, createDwebWorkflowsTool, createTrendingAgentsTool, createCapabilitySearchTool, createAgentRecommendationTool, createAgentDirectoryTool, createCoordinationCandidatesTool, createCoordinationTeamTool, } from "./tools.js";
+export { DwebClient } from "@bradyprotocol/discovery-sdk";

package/dist/tools.d.ts

@@ -0,0 +1,300 @@
+/**
+ * @bradyprotocol/discovery-langchain — LangChain tool factories for the Dweb Discovery Protocol.
+ *
+ * Each factory wraps a single @bradyprotocol/discovery-sdk method as a LangChain
+ * DynamicStructuredTool. Tools are advisory-only, non-executing, and carry
+ * no registration, identity, token, or stake assumptions.
+ */
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { z } from "zod";
+import { DwebClient } from "@bradyprotocol/discovery-sdk";
+import type { DwebClientConfig } from "@bradyprotocol/discovery-sdk";
+declare const querySchema: z.ZodObject<{
+    q: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    entity_types: z.ZodOptional<z.ZodString>;
+    capabilities: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    q: string;
+    limit?: number | undefined;
+    entity_types?: string | undefined;
+    capabilities?: string | undefined;
+}, {
+    q: string;
+    limit?: number | undefined;
+    entity_types?: string | undefined;
+    capabilities?: string | undefined;
+}>;
+/**
+ * Universal discovery query tool.
+ *
+ * Wraps `client.query(...)` — returns recommended agents, related
+ * capabilities, suggested workflows, and trending matches.
+ */
+export declare function createDwebQueryTool(clientOrConfig: DwebClient | DwebClientConfig): DynamicStructuredTool<typeof querySchema>;
+declare const capabilitySchema: z.ZodObject<{
+    q: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    include_related: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    q: string;
+    limit?: number | undefined;
+    include_related?: string | undefined;
+}, {
+    q: string;
+    limit?: number | undefined;
+    include_related?: string | undefined;
+}>;
+/**
+ * Capability keyword search tool.
+ *
+ * Wraps `client.searchCapability(...)` — returns matching capabilities,
+ * related agents, and co-occurrence intelligence.
+ */
+export declare function createDwebCapabilityTool(clientOrConfig: DwebClient | DwebClientConfig): DynamicStructuredTool<typeof capabilitySchema>;
+declare const recommendSchema: z.ZodObject<{
+    agent_id: z.ZodOptional<z.ZodString>;
+    capability: z.ZodOptional<z.ZodString>;
+    q: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    q?: string | undefined;
+    limit?: number | undefined;
+    agent_id?: string | undefined;
+    capability?: string | undefined;
+}, {
+    q?: string | undefined;
+    limit?: number | undefined;
+    agent_id?: string | undefined;
+    capability?: string | undefined;
+}>;
+/**
+ * Unified advisory recommendation tool.
+ *
+ * Wraps `client.recommend(...)` — composes agents, collaborators,
+ * workflows, and capabilities into a single recommendation response.
+ * At least one of agent_id, capability, or q must be provided.
+ */
+export declare function createDwebRecommendTool(clientOrConfig: DwebClient | DwebClientConfig): DynamicStructuredTool<typeof recommendSchema>;
+declare const routeTaskSchema: z.ZodObject<{
+    task: z.ZodOptional<z.ZodString>;
+    goal: z.ZodOptional<z.ZodString>;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    agent_id: z.ZodOptional<z.ZodString>;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    capabilities?: string[] | undefined;
+    agent_id?: string | undefined;
+    task?: string | undefined;
+    goal?: string | undefined;
+    context?: Record<string, unknown> | undefined;
+}, {
+    capabilities?: string[] | undefined;
+    agent_id?: string | undefined;
+    task?: string | undefined;
+    goal?: string | undefined;
+    context?: Record<string, unknown> | undefined;
+}>;
+/**
+ * Advisory task-to-pipeline routing tool.
+ *
+ * Wraps `client.routeTask(...)` — suggests an execution pipeline for a
+ * task. **Advisory-only**: this tool does NOT execute, dispatch, reserve,
+ * or lock anything. The recommendation is a signal; the calling agent
+ * decides whether and how to act on it.
+ *
+ * At least one of task, goal, capabilities, or agent_id must be provided.
+ */
+export declare function createDwebRouteTaskTool(clientOrConfig: DwebClient | DwebClientConfig): DynamicStructuredTool<typeof routeTaskSchema>;
+declare const bestCollaboratorsSchema: z.ZodObject<{
+    agent_id: z.ZodOptional<z.ZodString>;
+    capability: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    limit?: number | undefined;
+    agent_id?: string | undefined;
+    capability?: string | undefined;
+}, {
+    limit?: number | undefined;
+    agent_id?: string | undefined;
+    capability?: string | undefined;
+}>;
+/**
+ * Best collaborator recommendations tool.
+ *
+ * Wraps `client.getBestCollaborators(...)` — returns collaborator
+ * candidates ranked by trust, coordination quality, and shared capabilities.
+ * At least one of agent_id or capability must be provided.
+ */
+export declare function createDwebBestCollaboratorsTool(clientOrConfig: DwebClient | DwebClientConfig): DynamicStructuredTool<typeof bestCollaboratorsSchema>;
+declare const workflowsSchema: z.ZodObject<{
+    capability: z.ZodOptional<z.ZodString>;
+    agent_id: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    limit?: number | undefined;
+    agent_id?: string | undefined;
+    capability?: string | undefined;
+}, {
+    limit?: number | undefined;
+    agent_id?: string | undefined;
+    capability?: string | undefined;
+}>;
+/**
+ * Learned workflow patterns tool.
+ *
+ * Wraps `client.getWorkflows(...)` — returns multi-agent workflow patterns
+ * extracted from coordination outcome data.
+ * At least one of capability or agent_id must be provided.
+ */
+export declare function createDwebWorkflowsTool(clientOrConfig: DwebClient | DwebClientConfig): DynamicStructuredTool<typeof workflowsSchema>;
+declare const trendingAgentsSchema: z.ZodObject<{
+    window: z.ZodOptional<z.ZodEnum<["1h", "24h", "7d"]>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    limit?: number | undefined;
+    window?: "1h" | "24h" | "7d" | undefined;
+}, {
+    limit?: number | undefined;
+    window?: "1h" | "24h" | "7d" | undefined;
+}>;
+/**
+ * Trending agents tool.
+ *
+ * Wraps `client.getTrendingAgents(...)` — returns agents ranked by a
+ * multi-signal trending score (activity, capability changes, relationship
+ * growth, coordination quality).
+ */
+export declare function createTrendingAgentsTool(clientOrConfig: DwebClient | DwebClientConfig): DynamicStructuredTool<typeof trendingAgentsSchema>;
+declare const capabilityGraphSchema: z.ZodObject<{
+    q: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    q?: string | undefined;
+    limit?: number | undefined;
+}, {
+    q?: string | undefined;
+    limit?: number | undefined;
+}>;
+/**
+ * Capability graph search tool.
+ *
+ * Wraps `client.getCapabilities(...)` — answers "who provides capability X?"
+ * by querying the capability-provider graph.
+ */
+export declare function createCapabilitySearchTool(clientOrConfig: DwebClient | DwebClientConfig): DynamicStructuredTool<typeof capabilityGraphSchema>;
+declare const agentRecommendationSchema: z.ZodObject<{
+    capability: z.ZodOptional<z.ZodString>;
+    q: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    q?: string | undefined;
+    limit?: number | undefined;
+    capability?: string | undefined;
+}, {
+    q?: string | undefined;
+    limit?: number | undefined;
+    capability?: string | undefined;
+}>;
+/**
+ * Agent recommendation tool.
+ *
+ * Wraps `client.recommendAgents(...)` — recommends agents for a given
+ * capability or query, ranked by capability match, reputation, and
+ * recent activity.
+ */
+export declare function createAgentRecommendationTool(clientOrConfig: DwebClient | DwebClientConfig): DynamicStructuredTool<typeof agentRecommendationSchema>;
+declare const agentDirectorySchema: z.ZodObject<{
+    sort: z.ZodOptional<z.ZodEnum<["trending", "newest", "capability", "popularity"]>>;
+    capability: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    limit?: number | undefined;
+    sort?: "capability" | "trending" | "newest" | "popularity" | undefined;
+    capability?: string | undefined;
+}, {
+    limit?: number | undefined;
+    sort?: "capability" | "trending" | "newest" | "popularity" | undefined;
+    capability?: string | undefined;
+}>;
+/**
+ * Agent directory tool — the "App Store" view of registered agents.
+ *
+ * Wraps `client.getAgentDirectory(...)` — returns a browsable directory
+ * of agents sortable by trending score, newest, or capability richness.
+ */
+export declare function createAgentDirectoryTool(clientOrConfig: DwebClient | DwebClientConfig): DynamicStructuredTool<typeof agentDirectorySchema>;
+declare const coordinationCandidatesSchema: z.ZodObject<{
+    task: z.ZodString;
+    capabilities: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    exclude_agent_id: z.ZodOptional<z.ZodString>;
+    min_confidence: z.ZodOptional<z.ZodNumber>;
+    min_trust: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodOptional<z.ZodEnum<["conservative", "balanced", "exploratory"]>>;
+}, "strip", z.ZodTypeAny, {
+    task: string;
+    limit?: number | undefined;
+    capabilities?: string | undefined;
+    exclude_agent_id?: string | undefined;
+    min_confidence?: number | undefined;
+    min_trust?: number | undefined;
+    mode?: "conservative" | "balanced" | "exploratory" | undefined;
+}, {
+    task: string;
+    limit?: number | undefined;
+    capabilities?: string | undefined;
+    exclude_agent_id?: string | undefined;
+    min_confidence?: number | undefined;
+    min_trust?: number | undefined;
+    mode?: "conservative" | "balanced" | "exploratory" | undefined;
+}>;
+/**
+ * Coordination candidates tool — task-to-team discovery.
+ *
+ * Wraps `client.getCoordinationCandidates(...)` — given a task description,
+ * returns ranked agents best suited to collaborate on that task.
+ */
+export declare function createCoordinationCandidatesTool(clientOrConfig: DwebClient | DwebClientConfig): DynamicStructuredTool<typeof coordinationCandidatesSchema>;
+declare const coordinationTeamSchema: z.ZodObject<{
+    task: z.ZodString;
+    capabilities: z.ZodOptional<z.ZodString>;
+    team_size: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    exclude_agent_id: z.ZodOptional<z.ZodString>;
+    min_confidence: z.ZodOptional<z.ZodNumber>;
+    min_trust: z.ZodOptional<z.ZodNumber>;
+    mode: z.ZodOptional<z.ZodEnum<["conservative", "balanced", "exploratory"]>>;
+    require_proven_collaboration: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    task: string;
+    limit?: number | undefined;
+    capabilities?: string | undefined;
+    exclude_agent_id?: string | undefined;
+    min_confidence?: number | undefined;
+    min_trust?: number | undefined;
+    mode?: "conservative" | "balanced" | "exploratory" | undefined;
+    team_size?: number | undefined;
+    require_proven_collaboration?: boolean | undefined;
+}, {
+    task: string;
+    limit?: number | undefined;
+    capabilities?: string | undefined;
+    exclude_agent_id?: string | undefined;
+    min_confidence?: number | undefined;
+    min_trust?: number | undefined;
+    mode?: "conservative" | "balanced" | "exploratory" | undefined;
+    team_size?: number | undefined;
+    require_proven_collaboration?: boolean | undefined;
+}>;
+/**
+ * Coordination team assembly tool — best small team for a task.
+ *
+ * Wraps `client.getCoordinationTeam(...)` — given a task description,
+ * assembles teams of agents that collectively cover the task's capability
+ * requirements, with coverage analysis and gap identification.
+ * **Advisory-only**: recommendations only; does not execute, dispatch, or assign work.
+ */
+export declare function createCoordinationTeamTool(clientOrConfig: DwebClient | DwebClientConfig): DynamicStructuredTool<typeof coordinationTeamSchema>;
+export {};
+//# sourceMappingURL=tools.d.ts.map

package/dist/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"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"}

package/dist/tools.js

@@ -0,0 +1,396 @@
+/**
+ * @bradyprotocol/discovery-langchain — LangChain tool factories for the Dweb Discovery Protocol.
+ *
+ * Each factory wraps a single @bradyprotocol/discovery-sdk method as a LangChain
+ * DynamicStructuredTool. Tools are advisory-only, non-executing, and carry
+ * no registration, identity, token, or stake assumptions.
+ */
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { z } from "zod";
+import { DwebClient } from "@bradyprotocol/discovery-sdk";
+/* ------------------------------------------------------------------ */
+/*  Shared helper                                                      */
+/* ------------------------------------------------------------------ */
+function resolveClient(clientOrConfig) {
+    if (clientOrConfig instanceof DwebClient)
+        return clientOrConfig;
+    return new DwebClient(clientOrConfig);
+}
+/* ------------------------------------------------------------------ */
+/*  1. Query                                                           */
+/* ------------------------------------------------------------------ */
+const querySchema = z.object({
+    q: z.string().describe("Natural-language discovery query"),
+    limit: z.number().int().positive().optional().describe("Max results to return"),
+    entity_types: z
+        .string()
+        .optional()
+        .describe("Comma-separated entity types to filter (e.g. 'agent,capability')"),
+    capabilities: z.string().optional().describe("Comma-separated capabilities to filter by"),
+});
+/**
+ * Universal discovery query tool.
+ *
+ * Wraps `client.query(...)` — returns recommended agents, related
+ * capabilities, suggested workflows, and trending matches.
+ */
+export function createDwebQueryTool(clientOrConfig) {
+    const client = resolveClient(clientOrConfig);
+    return new DynamicStructuredTool({
+        name: "dweb_query",
+        description: "Search the Dweb Discovery Protocol for agents, capabilities, and workflows. " +
+            "Returns advisory recommendations — signals, not directives.",
+        schema: querySchema,
+        func: async (input) => client.query(input),
+    });
+}
+/* ------------------------------------------------------------------ */
+/*  2. Capability Search                                               */
+/* ------------------------------------------------------------------ */
+const capabilitySchema = z.object({
+    q: z.string().describe("Capability keyword search query"),
+    limit: z.number().int().positive().optional().describe("Max results to return"),
+    include_related: z
+        .string()
+        .optional()
+        .describe("Set to 'true' to include related/co-occurring capabilities"),
+});
+/**
+ * Capability keyword search tool.
+ *
+ * Wraps `client.searchCapability(...)` — returns matching capabilities,
+ * related agents, and co-occurrence intelligence.
+ */
+export function createDwebCapabilityTool(clientOrConfig) {
+    const client = resolveClient(clientOrConfig);
+    return new DynamicStructuredTool({
+        name: "dweb_capability_search",
+        description: "Search for agent capabilities in the Dweb protocol by keyword. " +
+            "Returns matching capabilities with agent counts and co-occurrence data.",
+        schema: capabilitySchema,
+        func: async (input) => client.searchCapability(input),
+    });
+}
+/* ------------------------------------------------------------------ */
+/*  3. Recommend                                                       */
+/* ------------------------------------------------------------------ */
+const recommendSchema = z.object({
+    agent_id: z.string().optional().describe("Agent ID to get recommendations for"),
+    capability: z.string().optional().describe("Capability to get recommendations for"),
+    q: z.string().optional().describe("Natural-language recommendation query"),
+    limit: z.number().int().positive().optional().describe("Max results to return"),
+});
+/**
+ * Unified advisory recommendation tool.
+ *
+ * Wraps `client.recommend(...)` — composes agents, collaborators,
+ * workflows, and capabilities into a single recommendation response.
+ * At least one of agent_id, capability, or q must be provided.
+ */
+export function createDwebRecommendTool(clientOrConfig) {
+    const client = resolveClient(clientOrConfig);
+    return new DynamicStructuredTool({
+        name: "dweb_recommend",
+        description: "Get unified advisory recommendations from the Dweb protocol. " +
+            "Combines agent, collaborator, workflow, and capability signals. " +
+            "Provide at least one of: agent_id, capability, or q.",
+        schema: recommendSchema,
+        func: async (input) => client.recommend(input),
+    });
+}
+/* ------------------------------------------------------------------ */
+/*  4. Route Task (advisory-only)                                      */
+/* ------------------------------------------------------------------ */
+const routeTaskSchema = z.object({
+    task: z.string().optional().describe("Task description to route"),
+    goal: z.string().optional().describe("High-level goal for the task"),
+    capabilities: z.array(z.string()).optional().describe("Required capabilities for the task"),
+    agent_id: z.string().optional().describe("Preferred agent ID"),
+    context: z.record(z.string(), z.unknown()).optional().describe("Additional context for routing"),
+});
+/**
+ * Advisory task-to-pipeline routing tool.
+ *
+ * Wraps `client.routeTask(...)` — suggests an execution pipeline for a
+ * task. **Advisory-only**: this tool does NOT execute, dispatch, reserve,
+ * or lock anything. The recommendation is a signal; the calling agent
+ * decides whether and how to act on it.
+ *
+ * At least one of task, goal, capabilities, or agent_id must be provided.
+ */
+export function createDwebRouteTaskTool(clientOrConfig) {
+    const client = resolveClient(clientOrConfig);
+    return new DynamicStructuredTool({
+        name: "dweb_route_task",
+        description: "Get an advisory routing recommendation for a task from the Dweb protocol. " +
+            "ADVISORY ONLY — does NOT execute, dispatch, reserve, or lock anything. " +
+            "Returns suggested agents, pipeline steps, collaborators, and confidence. " +
+            "Provide at least one of: task, goal, capabilities, or agent_id.",
+        schema: routeTaskSchema,
+        func: async (input) => client.routeTask(input),
+    });
+}
+/* ------------------------------------------------------------------ */
+/*  5. Best Collaborators (optional)                                   */
+/* ------------------------------------------------------------------ */
+const bestCollaboratorsSchema = z.object({
+    agent_id: z.string().optional().describe("Agent ID to find collaborators for"),
+    capability: z.string().optional().describe("Capability to find collaborators for"),
+    limit: z.number().int().positive().optional().describe("Max results to return"),
+});
+/**
+ * Best collaborator recommendations tool.
+ *
+ * Wraps `client.getBestCollaborators(...)` — returns collaborator
+ * candidates ranked by trust, coordination quality, and shared capabilities.
+ * At least one of agent_id or capability must be provided.
+ */
+export function createDwebBestCollaboratorsTool(clientOrConfig) {
+    const client = resolveClient(clientOrConfig);
+    return new DynamicStructuredTool({
+        name: "dweb_best_collaborators",
+        description: "Find the best collaborator agents from the Dweb protocol. " +
+            "Returns candidates ranked by trust, coordination quality, and shared capabilities. " +
+            "Provide at least one of: agent_id or capability.",
+        schema: bestCollaboratorsSchema,
+        func: async (input) => client.getBestCollaborators(input),
+    });
+}
+/* ------------------------------------------------------------------ */
+/*  6. Workflows (optional)                                            */
+/* ------------------------------------------------------------------ */
+const workflowsSchema = z.object({
+    capability: z.string().optional().describe("Capability to find workflow patterns for"),
+    agent_id: z.string().optional().describe("Agent ID to find workflow patterns for"),
+    limit: z.number().int().positive().optional().describe("Max results to return"),
+});
+/**
+ * Learned workflow patterns tool.
+ *
+ * Wraps `client.getWorkflows(...)` — returns multi-agent workflow patterns
+ * extracted from coordination outcome data.
+ * At least one of capability or agent_id must be provided.
+ */
+export function createDwebWorkflowsTool(clientOrConfig) {
+    const client = resolveClient(clientOrConfig);
+    return new DynamicStructuredTool({
+        name: "dweb_workflows",
+        description: "Discover learned multi-agent workflow patterns from the Dweb protocol. " +
+            "Returns patterns with success rates, frequency, and evidence depth. " +
+            "Provide at least one of: capability or agent_id.",
+        schema: workflowsSchema,
+        func: async (input) => client.getWorkflows(input),
+    });
+}
+/* ------------------------------------------------------------------ */
+/*  7. Trending Agents (Phase 9)                                       */
+/* ------------------------------------------------------------------ */
+const trendingAgentsSchema = z.object({
+    window: z
+        .enum(["1h", "24h", "7d"])
+        .optional()
+        .describe("Time window for trending data (default: 24h)"),
+    limit: z.number().int().positive().optional().describe("Max agents to return"),
+});
+/**
+ * Trending agents tool.
+ *
+ * Wraps `client.getTrendingAgents(...)` — returns agents ranked by a
+ * multi-signal trending score (activity, capability changes, relationship
+ * growth, coordination quality).
+ */
+export function createTrendingAgentsTool(clientOrConfig) {
+    const client = resolveClient(clientOrConfig);
+    return new DynamicStructuredTool({
+        name: "dweb_trending_agents",
+        description: "Get trending agents from the Dweb protocol ranked by multi-signal score " +
+            "(activity velocity, capability changes, relationship growth, coordination quality).",
+        schema: trendingAgentsSchema,
+        func: async (input) => client.getTrendingAgents(input),
+    });
+}
+/* ------------------------------------------------------------------ */
+/*  8. Capability Graph Search (Phase 9)                               */
+/* ------------------------------------------------------------------ */
+const capabilityGraphSchema = z.object({
+    q: z.string().optional().describe("Keyword filter to search capabilities"),
+    limit: z.number().int().positive().optional().describe("Max capabilities to return"),
+});
+/**
+ * Capability graph search tool.
+ *
+ * Wraps `client.getCapabilities(...)` — answers "who provides capability X?"
+ * by querying the capability-provider graph.
+ */
+export function createCapabilitySearchTool(clientOrConfig) {
+    const client = resolveClient(clientOrConfig);
+    return new DynamicStructuredTool({
+        name: "dweb_capability_graph",
+        description: "Search the Dweb capability graph to find which agents provide a given capability. " +
+            "Returns capabilities with their provider agents.",
+        schema: capabilityGraphSchema,
+        func: async (input) => client.getCapabilities(input),
+    });
+}
+/* ------------------------------------------------------------------ */
+/*  9. Agent Recommendations (Phase 9)                                 */
+/* ------------------------------------------------------------------ */
+const agentRecommendationSchema = z.object({
+    capability: z.string().optional().describe("Capability to find agents for"),
+    q: z.string().optional().describe("Keyword search for agents"),
+    limit: z.number().int().positive().optional().describe("Max agents to return"),
+});
+/**
+ * Agent recommendation tool.
+ *
+ * Wraps `client.recommendAgents(...)` — recommends agents for a given
+ * capability or query, ranked by capability match, reputation, and
+ * recent activity.
+ */
+export function createAgentRecommendationTool(clientOrConfig) {
+    const client = resolveClient(clientOrConfig);
+    return new DynamicStructuredTool({
+        name: "dweb_agent_recommendation",
+        description: "Get agent recommendations from the Dweb protocol for a given capability or query. " +
+            "Agents are ranked by capability match, ecosystem reputation, and recent activity. " +
+            "Provide at least one of: capability or q.",
+        schema: agentRecommendationSchema,
+        func: async (input) => client.recommendAgents(input),
+    });
+}
+/* ------------------------------------------------------------------ */
+/*  10. Agent Directory (Phase 9)                                      */
+/* ------------------------------------------------------------------ */
+const agentDirectorySchema = z.object({
+    sort: z
+        .enum(["trending", "newest", "capability", "popularity"])
+        .optional()
+        .describe("Sort order (default: trending)"),
+    capability: z.string().optional().describe("Filter agents by capability"),
+    limit: z.number().int().positive().optional().describe("Max agents to return"),
+});
+/**
+ * Agent directory tool — the "App Store" view of registered agents.
+ *
+ * Wraps `client.getAgentDirectory(...)` — returns a browsable directory
+ * of agents sortable by trending score, newest, or capability richness.
+ */
+export function createAgentDirectoryTool(clientOrConfig) {
+    const client = resolveClient(clientOrConfig);
+    return new DynamicStructuredTool({
+        name: "dweb_agent_directory",
+        description: "Browse the Dweb agent directory — an App Store-like view of registered agents. " +
+            "Sortable by trending score, newest, or capability richness.",
+        schema: agentDirectorySchema,
+        func: async (input) => client.getAgentDirectory(input),
+    });
+}
+/* ------------------------------------------------------------------ */
+/*  11. Coordination Candidates (Phase 10)                             */
+/* ------------------------------------------------------------------ */
+const coordinationCandidatesSchema = z.object({
+    task: z.string().describe("Task or goal description to find collaborators for"),
+    capabilities: z.string().optional().describe("Comma-separated required capabilities"),
+    limit: z.number().int().positive().optional().describe("Max candidates to return"),
+    exclude_agent_id: z.string().optional().describe("Agent ID to exclude from results (e.g. self)"),
+    min_confidence: z
+        .number()
+        .min(0)
+        .max(1)
+        .optional()
+        .describe("Slice 8 - Minimum candidate score 0-1; filters below threshold"),
+    min_trust: z
+        .number()
+        .int()
+        .min(0)
+        .max(100)
+        .optional()
+        .describe("Slice 8 - Minimum trust_score 0-100"),
+    mode: z
+        .enum(["conservative", "balanced", "exploratory"])
+        .optional()
+        .describe("Slice 8 - conservative=stricter; exploratory=more permissive"),
+});
+/**
+ * Coordination candidates tool — task-to-team discovery.
+ *
+ * Wraps `client.getCoordinationCandidates(...)` — given a task description,
+ * returns ranked agents best suited to collaborate on that task.
+ */
+export function createCoordinationCandidatesTool(clientOrConfig) {
+    const client = resolveClient(clientOrConfig);
+    return new DynamicStructuredTool({
+        name: "dweb_coordination_candidates",
+        description: "Find agents best suited to collaborate on a task using the Dweb protocol. " +
+            "Given a task description, returns ranked coordination candidates with " +
+            "match reasoning, trust scores, coordination signals, best_for label, " +
+            "selection_summary, strengths, weaknesses, and optional tradeoff_summary. " +
+            "Slice 8: min_confidence, min_trust, mode. Slice 9: marketplace comparison. Slice 10: primary_recommendation, decision_summary, recommended_first. Slice 11: handoff_summary.",
+        schema: coordinationCandidatesSchema,
+        func: async (input) => client.getCoordinationCandidates(input),
+    });
+}
+/* ------------------------------------------------------------------ */
+/*  12. Coordination Team (Phase 10.2)                                 */
+/* ------------------------------------------------------------------ */
+const coordinationTeamSchema = z.object({
+    task: z.string().describe("Task or goal description to assemble a team for"),
+    capabilities: z.string().optional().describe("Comma-separated required capabilities"),
+    team_size: z
+        .number()
+        .int()
+        .min(2)
+        .max(5)
+        .optional()
+        .describe("Desired team size (2–5, default: 3)"),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(5)
+        .optional()
+        .describe("Max alternative teams to return (1–5, default: 3)"),
+    exclude_agent_id: z.string().optional().describe("Agent ID to exclude from results (e.g. self)"),
+    min_confidence: z
+        .number()
+        .min(0)
+        .max(1)
+        .optional()
+        .describe("Slice 8 - Minimum team confidence 0-1"),
+    min_trust: z
+        .number()
+        .int()
+        .min(0)
+        .max(100)
+        .optional()
+        .describe("Slice 8 - Minimum member trust_score 0-100"),
+    mode: z
+        .enum(["conservative", "balanced", "exploratory"])
+        .optional()
+        .describe("Slice 8 - conservative=stricter; exploratory=more permissive"),
+    require_proven_collaboration: z
+        .boolean()
+        .optional()
+        .describe("Slice 8 - Only teams with pairwise collaboration history"),
+});
+/**
+ * Coordination team assembly tool — best small team for a task.
+ *
+ * Wraps `client.getCoordinationTeam(...)` — given a task description,
+ * assembles teams of agents that collectively cover the task's capability
+ * requirements, with coverage analysis and gap identification.
+ * **Advisory-only**: recommendations only; does not execute, dispatch, or assign work.
+ */
+export function createCoordinationTeamTool(clientOrConfig) {
+    const client = resolveClient(clientOrConfig);
+    return new DynamicStructuredTool({
+        name: "dweb_coordination_team",
+        description: "Advisory-only — assemble the best small team of agents for a task using the Dweb protocol. " +
+            "Returns assembled teams with per-member roles, coverage analysis, alternate " +
+            "candidates (with why_not_higher), confidence, guidance, best_for, " +
+            "selection_summary, strengths, weaknesses, and optional tradeoff_summary. " +
+            "Slice 8: min_confidence, min_trust, mode. Slice 9: marketplace comparison. Slice 10: primary_recommendation, decision_summary, recommended_first. Slice 11: handoff_summary, engage_first_member.",
+        schema: coordinationTeamSchema,
+        func: async (input) => client.getCoordinationTeam(input),
+    });
+}

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@bradyprotocol/discovery-langchain",
+  "version": "0.2.5",
+  "description": "LangChain tool adapter for the BRADY Discovery Protocol — wraps @bradyprotocol/discovery-sdk",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SerDaboz/Dweb-Discoverer.git",
+    "directory": "packages/langchain"
+  },
+  "homepage": "https://bradyprotocol.xyz",
+  "bugs": {
+    "url": "https://github.com/SerDaboz/Dweb-Discoverer/issues"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "prepublishOnly": "bun run build",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src/",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\""
+  },
+  "peerDependencies": {
+    "@bradyprotocol/discovery-sdk": "^0.2.4",
+    "@langchain/core": ">=0.3.0",
+    "zod": ">=3.22.0"
+  },
+  "devDependencies": {
+    "@bradyprotocol/discovery-sdk": "workspace:*",
+    "@langchain/core": "^1.1.20",
+    "typescript": "^5.6.0",
+    "vitest": "^4.0.0",
+    "prettier": "^3.8.0",
+    "zod": "^3.25.0"
+  },
+  "keywords": [
+    "dweb",
+    "langchain",
+    "agent",
+    "tools",
+    "discovery",
+    "web3",
+    "decentralized"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  }
+}