bigtool-ts 0.1.0

package/dist/graph/agent.d.ts

@@ -0,0 +1,214 @@
+/**
+ * Agent factory module.
+ *
+ * This module provides the main entry point for creating LangGraph agents
+ * with dynamic tool discovery capabilities.
+ *
+ * @module graph/agent
+ */
+import type { BaseChatModel } from "@langchain/core/language_models/chat_models";
+import type { StructuredTool } from "@langchain/core/tools";
+import type { CompiledStateGraph } from "@langchain/langgraph";
+import type { ToolSource, SearchIndex } from "../types.js";
+import { type ToolDiscoveryState } from "./state.js";
+/**
+ * Configuration options for createAgent.
+ *
+ * Controls the LLM, tool sources, search behavior, and caching.
+ *
+ * @example Minimal configuration
+ * ```typescript
+ * const options: CreateAgentOptions = {
+ *   llm: new ChatOpenAI({ model: 'gpt-4o' }),
+ *   tools: [myTool1, myTool2],
+ *   search: new OramaSearch(),
+ * };
+ * ```
+ *
+ * @example Full configuration
+ * ```typescript
+ * const options: CreateAgentOptions = {
+ *   llm: new ChatOpenAI({ model: 'gpt-4o' }),
+ *   sources: [
+ *     new LocalSource(utilityTools),
+ *     new MCPSource(githubClient),
+ *   ],
+ *   search: new OramaSearch({ mode: 'hybrid', embeddings }),
+ *   pinnedTools: [helpTool],
+ *   systemPrompt: 'You are a helpful coding assistant.',
+ *   searchLimit: 10,
+ *   searchThreshold: 0.3,
+ *   cacheSize: 200,
+ * };
+ * ```
+ */
+export interface CreateAgentOptions {
+    /**
+     * The LLM to use for the agent.
+     *
+     * Must support tool binding (bindTools method).
+     */
+    llm: BaseChatModel;
+    /**
+     * Tools to register.
+     *
+     * Can be either an array of StructuredTool instances or
+     * an array of ToolSource instances. If StructuredTools are
+     * provided, they are wrapped in a LocalSource automatically.
+     */
+    tools?: StructuredTool[] | ToolSource[];
+    /**
+     * Tool sources to register.
+     *
+     * Alternative to `tools` for when you have pre-configured
+     * sources. Can be used together with `tools`.
+     */
+    sources?: ToolSource[];
+    /**
+     * Search index implementation.
+     *
+     * Required. Use OramaSearch for most cases.
+     */
+    search: SearchIndex;
+    /**
+     * Tools that are always available.
+     *
+     * These tools bypass search and are always in the LLM's context.
+     * Use for frequently-needed tools to avoid search overhead.
+     */
+    pinnedTools?: StructuredTool[];
+    /**
+     * System prompt to prepend to conversations.
+     *
+     * Added as a SystemMessage at the start of the message list
+     * if not already present.
+     */
+    systemPrompt?: string;
+    /**
+     * Maximum tools returned per search.
+     *
+     * @default 5
+     */
+    searchLimit?: number;
+    /**
+     * Minimum search score threshold (0-1).
+     *
+     * Results with scores below this are filtered out.
+     *
+     * @default 0
+     */
+    searchThreshold?: number;
+    /**
+     * Maximum tools to cache in the loader.
+     *
+     * Uses LRU eviction when limit is reached.
+     *
+     * @default 100
+     */
+    cacheSize?: number;
+}
+/**
+ * The compiled agent graph type.
+ *
+ * This is the return type of createAgent and createToolDiscoveryGraph.
+ * Can be invoked with messages to run the agent.
+ */
+export type CompiledToolDiscoveryGraph = CompiledStateGraph<ToolDiscoveryState, Partial<ToolDiscoveryState>, "__start__" | "agent" | "search" | "execute">;
+/**
+ * Creates a LangGraph agent with dynamic tool discovery.
+ *
+ * This is the main entry point for bigtool-ts. It creates a complete
+ * agent graph that can discover and use tools based on user requests.
+ *
+ * ## How It Works
+ *
+ * The agent follows this workflow:
+ *
+ * 1. **Agent Node**: LLM receives the conversation plus available tools
+ *    (search_tools + pinned + previously discovered tools)
+ *
+ * 2. **Routing**: Based on the LLM's response:
+ *    - If it calls `search_tools` → go to Search Node
+ *    - If it calls other tools → go to Execute Node
+ *    - If no tool calls → END
+ *
+ * 3. **Search Node**: Executes the search query, updates state with
+ *    discovered tool IDs, returns to Agent Node
+ *
+ * 4. **Execute Node**: Runs the called tools, returns results to
+ *    Agent Node
+ *
+ * @param options - Configuration options for the agent
+ * @returns Promise resolving to the compiled agent graph
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { createAgent, OramaSearch } from '@repo/bigtool-ts';
+ * import { ChatOpenAI } from '@langchain/openai';
+ *
+ * const agent = await createAgent({
+ *   llm: new ChatOpenAI({ model: 'gpt-4o' }),
+ *   tools: [calculatorTool, weatherTool, searchTool],
+ *   search: new OramaSearch(),
+ * });
+ *
+ * const result = await agent.invoke({
+ *   messages: [{ role: 'user', content: 'What is the weather in NYC?' }]
+ * });
+ * ```
+ *
+ * @example With MCP and pinned tools
+ * ```typescript
+ * const agent = await createAgent({
+ *   llm: new ChatOpenAI({ model: 'gpt-4o' }),
+ *   sources: [
+ *     new MCPSource(githubClient, { namespace: 'github' }),
+ *     new MCPSource(slackClient, { namespace: 'slack' }),
+ *   ],
+ *   search: new OramaSearch({ mode: 'hybrid', embeddings }),
+ *   pinnedTools: [helpTool],
+ *   systemPrompt: 'You are a DevOps assistant.',
+ *   searchLimit: 10,
+ * });
+ * ```
+ *
+ * @throws Error if LLM does not support tool binding
+ */
+export declare function createAgent(options: CreateAgentOptions): Promise<CompiledToolDiscoveryGraph>;
+/**
+ * Creates the tool discovery graph for advanced composition.
+ *
+ * This is functionally identical to createAgent but named to clarify
+ * its use as a subgraph in larger LangGraph workflows.
+ *
+ * Use this when you want to integrate tool discovery into an existing
+ * LangGraph workflow rather than using the full agent standalone.
+ *
+ * @param options - Configuration options (same as createAgent)
+ * @returns Promise resolving to the compiled discovery graph
+ *
+ * @example Embedding in a larger workflow
+ * ```typescript
+ * import { createToolDiscoveryGraph, OramaSearch } from '@repo/bigtool-ts';
+ * import { StateGraph } from '@langchain/langgraph';
+ *
+ * // Create the discovery subgraph
+ * const discoveryGraph = await createToolDiscoveryGraph({
+ *   llm: new ChatOpenAI({ model: 'gpt-4o' }),
+ *   tools: myTools,
+ *   search: new OramaSearch(),
+ * });
+ *
+ * // Integrate into your main workflow
+ * const mainGraph = new StateGraph(MyAnnotation)
+ *   .addNode('preprocess', preprocessNode)
+ *   .addNode('discover', discoveryGraph)
+ *   .addNode('postprocess', postprocessNode)
+ *   .addEdge('preprocess', 'discover')
+ *   .addEdge('discover', 'postprocess');
+ * ```
+ *
+ * @see {@link createAgent} for standalone agent usage
+ */
+export declare function createToolDiscoveryGraph(options: CreateAgentOptions): Promise<CompiledToolDiscoveryGraph>;
+//# sourceMappingURL=agent.d.ts.map

package/dist/graph/agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../src/graph/agent.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AACjF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAA2B,MAAM,aAAa,CAAC;AACpF,OAAO,EAA2B,KAAK,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAgB9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,GAAG,EAAE,aAAa,CAAC;IAEnB;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,cAAc,EAAE,GAAG,UAAU,EAAE,CAAC;IAExC;;;;;OAKG;IACH,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC;IAEvB;;;;OAIG;IACH,MAAM,EAAE,WAAW,CAAC;IAEpB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,cAAc,EAAE,CAAC;IAE/B;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,MAAM,MAAM,0BAA0B,GAAG,kBAAkB,CACzD,kBAAkB,EAClB,OAAO,CAAC,kBAAkB,CAAC,EAC3B,WAAW,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,CAC7C,CAAC;AAuBF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,wBAAsB,WAAW,CAC/B,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,0BAA0B,CAAC,CAsFrC;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,0BAA0B,CAAC,CAGrC"}

package/dist/graph/agent.js

@@ -0,0 +1,196 @@
+/**
+ * Agent factory module.
+ *
+ * This module provides the main entry point for creating LangGraph agents
+ * with dynamic tool discovery capabilities.
+ *
+ * @module graph/agent
+ */
+import { StateGraph, START, END } from "@langchain/langgraph";
+import { ToolDiscoveryAnnotation } from "./state.js";
+import { createAgentNode, createSearchNode, createExecuteNode, routeNode, } from "./nodes.js";
+import { createSearchToolsTool } from "./search-tool.js";
+import { DefaultToolCatalog } from "../catalog/index.js";
+import { DefaultToolLoader } from "../loader/index.js";
+import { LocalSource } from "../sources/local.js";
+// ═══════════════════════════════════════════════════════════════════
+// IMPLEMENTATION
+// ═══════════════════════════════════════════════════════════════════
+/**
+ * Type guard to check if the input is a ToolSource array.
+ *
+ * @internal
+ * @param input - Array to check
+ * @returns True if input contains ToolSource instances
+ */
+function isToolSourceArray(input) {
+    if (input.length === 0)
+        return false;
+    // ToolSource has getMetadata method
+    const first = input[0];
+    return typeof first.getMetadata === "function";
+}
+/**
+ * Creates a LangGraph agent with dynamic tool discovery.
+ *
+ * This is the main entry point for bigtool-ts. It creates a complete
+ * agent graph that can discover and use tools based on user requests.
+ *
+ * ## How It Works
+ *
+ * The agent follows this workflow:
+ *
+ * 1. **Agent Node**: LLM receives the conversation plus available tools
+ *    (search_tools + pinned + previously discovered tools)
+ *
+ * 2. **Routing**: Based on the LLM's response:
+ *    - If it calls `search_tools` → go to Search Node
+ *    - If it calls other tools → go to Execute Node
+ *    - If no tool calls → END
+ *
+ * 3. **Search Node**: Executes the search query, updates state with
+ *    discovered tool IDs, returns to Agent Node
+ *
+ * 4. **Execute Node**: Runs the called tools, returns results to
+ *    Agent Node
+ *
+ * @param options - Configuration options for the agent
+ * @returns Promise resolving to the compiled agent graph
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { createAgent, OramaSearch } from '@repo/bigtool-ts';
+ * import { ChatOpenAI } from '@langchain/openai';
+ *
+ * const agent = await createAgent({
+ *   llm: new ChatOpenAI({ model: 'gpt-4o' }),
+ *   tools: [calculatorTool, weatherTool, searchTool],
+ *   search: new OramaSearch(),
+ * });
+ *
+ * const result = await agent.invoke({
+ *   messages: [{ role: 'user', content: 'What is the weather in NYC?' }]
+ * });
+ * ```
+ *
+ * @example With MCP and pinned tools
+ * ```typescript
+ * const agent = await createAgent({
+ *   llm: new ChatOpenAI({ model: 'gpt-4o' }),
+ *   sources: [
+ *     new MCPSource(githubClient, { namespace: 'github' }),
+ *     new MCPSource(slackClient, { namespace: 'slack' }),
+ *   ],
+ *   search: new OramaSearch({ mode: 'hybrid', embeddings }),
+ *   pinnedTools: [helpTool],
+ *   systemPrompt: 'You are a DevOps assistant.',
+ *   searchLimit: 10,
+ * });
+ * ```
+ *
+ * @throws Error if LLM does not support tool binding
+ */
+export async function createAgent(options) {
+    const { llm, tools = [], sources = [], search: searchIndex, pinnedTools = [], systemPrompt, searchLimit = 5, cacheSize = 100, } = options;
+    // 1. Create catalog
+    const catalog = new DefaultToolCatalog();
+    // 2. Collect all sources
+    const allSources = [...sources];
+    if (tools.length > 0) {
+        if (isToolSourceArray(tools)) {
+            allSources.push(...tools);
+        }
+        else {
+            allSources.push(new LocalSource(tools));
+        }
+    }
+    // 3. Register all sources with catalog
+    for (const source of allSources) {
+        await catalog.register(source);
+    }
+    // 4. Index tools for search
+    const allMetadata = catalog.getAllMetadata();
+    await searchIndex.index(allMetadata);
+    // 5. Create loader
+    const loader = new DefaultToolLoader(catalog, {
+        maxSize: cacheSize,
+    });
+    // 6. Create search_tools tool
+    const searchTool = createSearchToolsTool({
+        index: searchIndex,
+        catalog,
+        limit: searchLimit,
+    });
+    // 7. Build the graph
+    const workflow = new StateGraph(ToolDiscoveryAnnotation)
+        .addNode("agent", createAgentNode({
+        llm,
+        catalog,
+        loader,
+        pinnedTools,
+        searchTool,
+        systemPrompt,
+    }))
+        .addNode("search", createSearchNode({
+        index: searchIndex,
+        catalog,
+        searchLimit,
+    }))
+        .addNode("execute", createExecuteNode({
+        loader,
+        pinnedTools,
+    }))
+        .addEdge(START, "agent")
+        .addConditionalEdges("agent", routeNode, {
+        search: "search",
+        execute: "execute",
+        end: END,
+    })
+        .addEdge("search", "agent")
+        .addEdge("execute", "agent");
+    // 8. Compile and return
+    return workflow.compile();
+}
+// ═══════════════════════════════════════════════════════════════════
+// SUBGRAPH FACTORY
+// ═══════════════════════════════════════════════════════════════════
+/**
+ * Creates the tool discovery graph for advanced composition.
+ *
+ * This is functionally identical to createAgent but named to clarify
+ * its use as a subgraph in larger LangGraph workflows.
+ *
+ * Use this when you want to integrate tool discovery into an existing
+ * LangGraph workflow rather than using the full agent standalone.
+ *
+ * @param options - Configuration options (same as createAgent)
+ * @returns Promise resolving to the compiled discovery graph
+ *
+ * @example Embedding in a larger workflow
+ * ```typescript
+ * import { createToolDiscoveryGraph, OramaSearch } from '@repo/bigtool-ts';
+ * import { StateGraph } from '@langchain/langgraph';
+ *
+ * // Create the discovery subgraph
+ * const discoveryGraph = await createToolDiscoveryGraph({
+ *   llm: new ChatOpenAI({ model: 'gpt-4o' }),
+ *   tools: myTools,
+ *   search: new OramaSearch(),
+ * });
+ *
+ * // Integrate into your main workflow
+ * const mainGraph = new StateGraph(MyAnnotation)
+ *   .addNode('preprocess', preprocessNode)
+ *   .addNode('discover', discoveryGraph)
+ *   .addNode('postprocess', postprocessNode)
+ *   .addEdge('preprocess', 'discover')
+ *   .addEdge('discover', 'postprocess');
+ * ```
+ *
+ * @see {@link createAgent} for standalone agent usage
+ */
+export async function createToolDiscoveryGraph(options) {
+    // Same implementation as createAgent - the full graph IS the discovery graph
+    return createAgent(options);
+}
+//# sourceMappingURL=agent.js.map

package/dist/graph/agent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.js","sourceRoot":"","sources":["../../src/graph/agent.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,sBAAsB,CAAC;AAK9D,OAAO,EAAE,uBAAuB,EAA2B,MAAM,YAAY,CAAC;AAC9E,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,SAAS,GACV,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AA2HlD,sEAAsE;AACtE,iBAAiB;AACjB,sEAAsE;AAEtE;;;;;;GAMG;AACH,SAAS,iBAAiB,CACxB,KAAsC;IAEtC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAErC,oCAAoC;IACpC,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IACvB,OAAO,OAAQ,KAAoB,CAAC,WAAW,KAAK,UAAU,CAAC;AACjE,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,OAA2B;IAE3B,MAAM,EACJ,GAAG,EACH,KAAK,GAAG,EAAE,EACV,OAAO,GAAG,EAAE,EACZ,MAAM,EAAE,WAAW,EACnB,WAAW,GAAG,EAAE,EAChB,YAAY,EACZ,WAAW,GAAG,CAAC,EACf,SAAS,GAAG,GAAG,GAChB,GAAG,OAAO,CAAC;IAEZ,oBAAoB;IACpB,MAAM,OAAO,GAAgB,IAAI,kBAAkB,EAAE,CAAC;IAEtD,yBAAyB;IACzB,MAAM,UAAU,GAAiB,CAAC,GAAG,OAAO,CAAC,CAAC;IAE9C,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACrB,IAAI,iBAAiB,CAAC,KAAK,CAAC,EAAE,CAAC;YAC7B,UAAU,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC;QAC5B,CAAC;aAAM,CAAC;YACN,UAAU,CAAC,IAAI,CAAC,IAAI,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;QAC1C,CAAC;IACH,CAAC;IAED,uCAAuC;IACvC,KAAK,MAAM,MAAM,IAAI,UAAU,EAAE,CAAC;QAChC,MAAM,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IACjC,CAAC;IAED,4BAA4B;IAC5B,MAAM,WAAW,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAC7C,MAAM,WAAW,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;IAErC,mBAAmB;IACnB,MAAM,MAAM,GAAe,IAAI,iBAAiB,CAAC,OAAO,EAAE;QACxD,OAAO,EAAE,SAAS;KACnB,CAAC,CAAC;IAEH,8BAA8B;IAC9B,MAAM,UAAU,GAAG,qBAAqB,CAAC;QACvC,KAAK,EAAE,WAAW;QAClB,OAAO;QACP,KAAK,EAAE,WAAW;KACnB,CAAC,CAAC;IAEH,qBAAqB;IACrB,MAAM,QAAQ,GAAG,IAAI,UAAU,CAAC,uBAAuB,CAAC;SACrD,OAAO,CACN,OAAO,EACP,eAAe,CAAC;QACd,GAAG;QACH,OAAO;QACP,MAAM;QACN,WAAW;QACX,UAAU;QACV,YAAY;KACb,CAAC,CACH;SACA,OAAO,CACN,QAAQ,EACR,gBAAgB,CAAC;QACf,KAAK,EAAE,WAAW;QAClB,OAAO;QACP,WAAW;KACZ,CAAC,CACH;SACA,OAAO,CACN,SAAS,EACT,iBAAiB,CAAC;QAChB,MAAM;QACN,WAAW;KACZ,CAAC,CACH;SACA,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC;SACvB,mBAAmB,CAAC,OAAO,EAAE,SAAS,EAAE;QACvC,MAAM,EAAE,QAAQ;QAChB,OAAO,EAAE,SAAS;QAClB,GAAG,EAAE,GAAG;KACT,CAAC;SACD,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC;SAC1B,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;IAE/B,wBAAwB;IACxB,OAAO,QAAQ,CAAC,OAAO,EAAE,CAAC;AAC5B,CAAC;AAED,sEAAsE;AACtE,mBAAmB;AACnB,sEAAsE;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAC5C,OAA2B;IAE3B,6EAA6E;IAC7E,OAAO,WAAW,CAAC,OAAO,CAAC,CAAC;AAC9B,CAAC"}

package/dist/graph/index.d.ts

@@ -0,0 +1,5 @@
+export { createAgent, createToolDiscoveryGraph } from './agent.js';
+export type { CreateAgentOptions } from './agent.js';
+export { ToolDiscoveryAnnotation, type ToolDiscoveryState, type ToolDiscoveryUpdate, type SearchQuery } from './state.js';
+export { searchNode, routeNode, executeNode } from './nodes.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/graph/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/graph/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AACnE,YAAY,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AACrD,OAAO,EAAE,uBAAuB,EAAE,KAAK,kBAAkB,EAAE,KAAK,mBAAmB,EAAE,KAAK,WAAW,EAAE,MAAM,YAAY,CAAC;AAC1H,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC"}

package/dist/graph/index.js

@@ -0,0 +1,4 @@
+export { createAgent, createToolDiscoveryGraph } from './agent.js';
+export { ToolDiscoveryAnnotation } from './state.js';
+export { searchNode, routeNode, executeNode } from './nodes.js';
+//# sourceMappingURL=index.js.map

package/dist/graph/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/graph/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAEnE,OAAO,EAAE,uBAAuB,EAAuE,MAAM,YAAY,CAAC;AAC1H,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC"}

package/dist/graph/nodes.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Graph Nodes
+ *
+ * Node factories for the BigTool LangGraph agent.
+ */
+import type { RunnableConfig } from "@langchain/core/runnables";
+import type { BaseChatModel } from "@langchain/core/language_models/chat_models";
+import type { StructuredTool } from "@langchain/core/tools";
+import type { ToolCatalog, ToolLoader, SearchIndex } from "../types.js";
+import type { ToolDiscoveryState, ToolDiscoveryUpdate } from "./state.js";
+/**
+ * Configuration for the agent node
+ */
+export interface AgentNodeConfig {
+    /** The LLM to use */
+    llm: BaseChatModel;
+    /** Tool catalog for metadata lookups */
+    catalog: ToolCatalog;
+    /** Tool loader for loading selected tools */
+    loader: ToolLoader;
+    /** Tools that are always available (bypass search) */
+    pinnedTools: StructuredTool[];
+    /** The search_tools tool */
+    searchTool: StructuredTool;
+    /** Optional system prompt to prepend */
+    systemPrompt?: string;
+}
+/**
+ * Creates the agent node that invokes the LLM with bound tools.
+ *
+ * The agent always has access to:
+ * 1. search_tools - for discovering new tools
+ * 2. pinnedTools - always available tools
+ * 3. selectedTools - tools discovered via search
+ *
+ * @param config - Agent node configuration
+ * @returns A node function for the StateGraph
+ */
+export declare function createAgentNode(config: AgentNodeConfig): (state: ToolDiscoveryState, runnableConfig: RunnableConfig) => Promise<Partial<ToolDiscoveryUpdate>>;
+/**
+ * Configuration for the search node
+ */
+export interface SearchNodeConfig {
+    /** Search index for finding tools */
+    index: SearchIndex;
+    /** Tool catalog for metadata lookups */
+    catalog: ToolCatalog;
+    /** Maximum results per search (default: 5) */
+    searchLimit?: number;
+}
+/**
+ * Creates the search node that executes search_tools calls.
+ *
+ * This node:
+ * 1. Extracts search_tools calls from the last message
+ * 2. Executes searches against the index
+ * 3. Updates selectedToolIds with found tools
+ * 4. Returns ToolMessages with search results
+ *
+ * @param config - Search node configuration
+ * @returns A node function for the StateGraph
+ */
+export declare function createSearchNode(config: SearchNodeConfig): (state: ToolDiscoveryState, _runnableConfig: RunnableConfig) => Promise<Partial<ToolDiscoveryUpdate>>;
+/**
+ * Configuration for the execute node
+ */
+export interface ExecuteNodeConfig {
+    /** Tool loader for loading tools */
+    loader: ToolLoader;
+    /** Tools that are always available */
+    pinnedTools: StructuredTool[];
+}
+/**
+ * Creates the execute node that runs selected tools.
+ *
+ * Uses LangGraph's ToolNode to execute tool calls from the last message.
+ * Tools are loaded from the loader + pinnedTools.
+ *
+ * @param config - Execute node configuration
+ * @returns A node function for the StateGraph
+ */
+export declare function createExecuteNode(config: ExecuteNodeConfig): (state: ToolDiscoveryState, runnableConfig: RunnableConfig) => Promise<Partial<ToolDiscoveryUpdate>>;
+/**
+ * @deprecated Use createSearchNode instead
+ */
+export declare function searchNode(_state: ToolDiscoveryState, _config: RunnableConfig): Promise<Partial<ToolDiscoveryUpdate>>;
+/**
+ * Routing function - determines next node based on last message.
+ *
+ * Returns:
+ * - "search" if agent called search_tools
+ * - "execute" if agent called other tools
+ * - "end" if agent responded without tool calls
+ */
+export declare function routeNode(state: ToolDiscoveryState): "search" | "execute" | "end";
+/**
+ * @deprecated Use createExecuteNode instead
+ */
+export declare function executeNode(_state: ToolDiscoveryState, _config: RunnableConfig): Promise<Partial<ToolDiscoveryUpdate>>;
+//# sourceMappingURL=nodes.d.ts.map

package/dist/graph/nodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nodes.d.ts","sourceRoot":"","sources":["../../src/graph/nodes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAQH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6CAA6C,CAAC;AACjF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACxE,OAAO,KAAK,EACV,kBAAkB,EAClB,mBAAmB,EAEpB,MAAM,YAAY,CAAC;AAMpB;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,qBAAqB;IACrB,GAAG,EAAE,aAAa,CAAC;IACnB,wCAAwC;IACxC,OAAO,EAAE,WAAW,CAAC;IACrB,6CAA6C;IAC7C,MAAM,EAAE,UAAU,CAAC;IACnB,sDAAsD;IACtD,WAAW,EAAE,cAAc,EAAE,CAAC;IAC9B,4BAA4B;IAC5B,UAAU,EAAE,cAAc,CAAC;IAC3B,wCAAwC;IACxC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,eAAe,IAInD,OAAO,kBAAkB,EACzB,gBAAgB,cAAc,KAC7B,OAAO,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC,CAyCzC;AAMD;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,qCAAqC;IACrC,KAAK,EAAE,WAAW,CAAC;IACnB,wCAAwC;IACxC,OAAO,EAAE,WAAW,CAAC;IACrB,8CAA8C;IAC9C,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,IAIrD,OAAO,kBAAkB,EACzB,iBAAiB,cAAc,KAC9B,OAAO,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC,CAgEzC;AAMD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,oCAAoC;IACpC,MAAM,EAAE,UAAU,CAAC;IACnB,sCAAsC;IACtC,WAAW,EAAE,cAAc,EAAE,CAAC;CAC/B;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,iBAAiB,IAIvD,OAAO,kBAAkB,EACzB,gBAAgB,cAAc,KAC7B,OAAO,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC,CAyBzC;AAMD;;GAEG;AACH,wBAAsB,UAAU,CAC9B,MAAM,EAAE,kBAAkB,EAC1B,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC,CAIvC;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,kBAAkB,GAAG,QAAQ,GAAG,SAAS,GAAG,KAAK,CAuBjF;AAED;;GAEG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,kBAAkB,EAC1B,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC,CAIvC"}