bigtool-ts 0.1.0

package/dist/adapters/agent-protocol.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Agent Protocol adapter for bigtool-ts.
+ *
+ * IMPORTANT: Agent Protocol is a task/step-oriented specification, NOT a tool-oriented one.
+ * The protocol defines Tasks (high-level goals) and Steps (actions), with no native tool endpoints.
+ *
+ * This adapter provides a framework-agnostic handler interface that maps bigtool-ts
+ * tool operations to a REST-like API. It can be used with any HTTP framework
+ * (Express, Fastify, Hono, etc.) or integrated with the Agent Protocol SDK.
+ *
+ * @see https://github.com/AI-Engineers-Foundation/agent-protocol
+ * @module adapters/agent-protocol
+ */
+import type { AdapterConfig } from './types.js';
+/**
+ * Tool representation in Agent Protocol wire format.
+ *
+ * Uses JSON Schema for parameters (not Zod) as required by REST APIs.
+ */
+export interface AgentTool {
+    /** Unique tool identifier */
+    name: string;
+    /** Human-readable description */
+    description: string;
+    /** JSON Schema for tool parameters */
+    parameters: Record<string, unknown>;
+}
+/**
+ * Result from tool execution.
+ */
+export interface ToolExecutionResult {
+    /** Unique identifier for this tool call */
+    tool_call_id: string;
+    /** Output from the tool (serialized to string) */
+    output: string;
+}
+/**
+ * Error response structure.
+ */
+export interface ToolError {
+    /** Error code for programmatic handling */
+    code: 'TOOL_NOT_FOUND' | 'EXECUTION_ERROR';
+    /** Human-readable error message */
+    message: string;
+}
+/**
+ * Result type for operations that can fail.
+ */
+export type ToolResult<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: ToolError;
+};
+/**
+ * Framework-agnostic handler for Agent Protocol tool operations.
+ *
+ * This interface provides the core operations that can be exposed via any
+ * HTTP framework or integrated with the Agent Protocol SDK's step mechanism.
+ *
+ * @example Express integration
+ * ```typescript
+ * import express from 'express';
+ * import { createAgentProtocolHandler } from '@repo/bigtool-ts/adapters';
+ *
+ * const handler = createAgentProtocolHandler({ catalog, loader, searchIndex });
+ * const app = express();
+ *
+ * app.get('/tools', async (req, res) => {
+ *   const tools = await handler.listTools();
+ *   res.json(tools);
+ * });
+ *
+ * app.post('/tools/search', async (req, res) => {
+ *   const { query, limit } = req.body;
+ *   const tools = await handler.searchTools(query, limit);
+ *   res.json(tools);
+ * });
+ *
+ * app.post('/tools/execute', async (req, res) => {
+ *   const { name, args } = req.body;
+ *   const result = await handler.executeTool(name, args);
+ *   if (result.success) {
+ *     res.json(result.data);
+ *   } else {
+ *     res.status(400).json(result.error);
+ *   }
+ * });
+ * ```
+ */
+export interface AgentProtocolHandler {
+    /**
+     * List all available tools.
+     *
+     * @returns Array of tools in Agent Protocol format
+     */
+    listTools(): Promise<AgentTool[]>;
+    /**
+     * Search for tools matching a query.
+     *
+     * @param query - Natural language search query
+     * @param limit - Maximum number of results (default: 5)
+     * @returns Array of matching tools, sorted by relevance
+     */
+    searchTools(query: string, limit?: number): Promise<AgentTool[]>;
+    /**
+     * Execute a tool with the given arguments.
+     *
+     * @param name - Tool name to execute
+     * @param args - Arguments to pass to the tool
+     * @returns Result containing output or error
+     */
+    executeTool(name: string, args: Record<string, unknown>): Promise<ToolResult<ToolExecutionResult>>;
+}
+/**
+ * Creates a framework-agnostic Agent Protocol handler.
+ *
+ * The handler provides three core operations for tool management:
+ * - `listTools()`: Get all available tools
+ * - `searchTools()`: Find tools by natural language query
+ * - `executeTool()`: Run a specific tool with arguments
+ *
+ * @param config - Adapter configuration with catalog, loader, and search index
+ * @returns Handler instance with tool operations
+ *
+ * @example Basic usage
+ * ```typescript
+ * const handler = createAgentProtocolHandler({
+ *   catalog,
+ *   loader,
+ *   searchIndex,
+ * });
+ *
+ * // List all tools
+ * const tools = await handler.listTools();
+ *
+ * // Search for specific tools
+ * const githubTools = await handler.searchTools('github pull request', 5);
+ *
+ * // Execute a tool
+ * const result = await handler.executeTool('create_pr', {
+ *   title: 'My PR',
+ *   body: 'Description',
+ * });
+ * ```
+ */
+export declare function createAgentProtocolHandler(config: AdapterConfig): AgentProtocolHandler;
+//# sourceMappingURL=agent-protocol.d.ts.map

package/dist/adapters/agent-protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-protocol.d.ts","sourceRoot":"","sources":["../../src/adapters/agent-protocol.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAMhD;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACxB,6BAA6B;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,iCAAiC;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,sCAAsC;IACtC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACrC;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,2CAA2C;IAC3C,YAAY,EAAE,MAAM,CAAC;IACrB,kDAAkD;IAClD,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,2CAA2C;IAC3C,IAAI,EAAE,gBAAgB,GAAG,iBAAiB,CAAC;IAC3C,mCAAmC;IACnC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IACpB;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,CAAC,CAAA;CAAE,GAC1B;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,SAAS,CAAA;CAAE,CAAC;AAMzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,SAAS,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;IAElC;;;;;;OAMG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;IAEjE;;;;;;OAMG;IACH,WAAW,CACT,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,OAAO,CAAC,UAAU,CAAC,mBAAmB,CAAC,CAAC,CAAC;CAC7C;AA+BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,aAAa,GACpB,oBAAoB,CA2EtB"}

package/dist/adapters/agent-protocol.js

@@ -0,0 +1,133 @@
+/**
+ * Agent Protocol adapter for bigtool-ts.
+ *
+ * IMPORTANT: Agent Protocol is a task/step-oriented specification, NOT a tool-oriented one.
+ * The protocol defines Tasks (high-level goals) and Steps (actions), with no native tool endpoints.
+ *
+ * This adapter provides a framework-agnostic handler interface that maps bigtool-ts
+ * tool operations to a REST-like API. It can be used with any HTTP framework
+ * (Express, Fastify, Hono, etc.) or integrated with the Agent Protocol SDK.
+ *
+ * @see https://github.com/AI-Engineers-Foundation/agent-protocol
+ * @module adapters/agent-protocol
+ */
+// ═══════════════════════════════════════════════════════════════════
+// IMPLEMENTATION
+// ═══════════════════════════════════════════════════════════════════
+/**
+ * Convert bigtool-ts metadata to Agent Protocol wire format.
+ *
+ * This is a pure function that transforms internal metadata to the
+ * external API representation.
+ */
+function toAgentTool(metadata) {
+    return {
+        name: metadata.name,
+        description: metadata.description,
+        parameters: metadata.parameters ?? {},
+    };
+}
+/**
+ * Generate a unique tool call ID.
+ *
+ * Uses timestamp + random suffix for uniqueness without external dependencies.
+ */
+function generateToolCallId() {
+    const timestamp = Date.now().toString(36);
+    const random = Math.random().toString(36).substring(2, 8);
+    return `call_${timestamp}_${random}`;
+}
+/**
+ * Creates a framework-agnostic Agent Protocol handler.
+ *
+ * The handler provides three core operations for tool management:
+ * - `listTools()`: Get all available tools
+ * - `searchTools()`: Find tools by natural language query
+ * - `executeTool()`: Run a specific tool with arguments
+ *
+ * @param config - Adapter configuration with catalog, loader, and search index
+ * @returns Handler instance with tool operations
+ *
+ * @example Basic usage
+ * ```typescript
+ * const handler = createAgentProtocolHandler({
+ *   catalog,
+ *   loader,
+ *   searchIndex,
+ * });
+ *
+ * // List all tools
+ * const tools = await handler.listTools();
+ *
+ * // Search for specific tools
+ * const githubTools = await handler.searchTools('github pull request', 5);
+ *
+ * // Execute a tool
+ * const result = await handler.executeTool('create_pr', {
+ *   title: 'My PR',
+ *   body: 'Description',
+ * });
+ * ```
+ */
+export function createAgentProtocolHandler(config) {
+    const { catalog, loader, searchIndex } = config;
+    return {
+        async listTools() {
+            const metadata = catalog.getAllMetadata();
+            return metadata.map(toAgentTool);
+        },
+        async searchTools(query, limit = 5) {
+            const results = await searchIndex.search(query, { limit });
+            // Map search results to agent tools
+            // Filter out nulls in case metadata was removed between search and lookup
+            const tools = [];
+            for (const result of results) {
+                const metadata = catalog.getMetadata(result.toolId);
+                if (metadata !== null) {
+                    tools.push(toAgentTool(metadata));
+                }
+            }
+            return tools;
+        },
+        async executeTool(name, args) {
+            // Find tool by name (search through metadata)
+            const allMetadata = catalog.getAllMetadata();
+            const metadata = allMetadata.find((m) => m.name === name);
+            if (metadata === undefined) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'TOOL_NOT_FOUND',
+                        message: `Tool not found: ${name}`,
+                    },
+                };
+            }
+            // Load and execute the tool
+            const tool = await loader.load(metadata.id);
+            // Attempt execution with error handling
+            const toolCallId = generateToolCallId();
+            try {
+                const rawResult = await tool.invoke(args);
+                const output = typeof rawResult === 'string' ? rawResult : JSON.stringify(rawResult);
+                return {
+                    success: true,
+                    data: {
+                        tool_call_id: toolCallId,
+                        output,
+                    },
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Unknown execution error';
+                return {
+                    success: false,
+                    error: {
+                        code: 'EXECUTION_ERROR',
+                        message,
+                    },
+                };
+            }
+        },
+    };
+}
+//# sourceMappingURL=agent-protocol.js.map

package/dist/adapters/agent-protocol.js.map

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

package/dist/adapters/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Framework adapters for bigtool-ts.
+ *
+ * This module provides adapters that convert bigtool-ts tools to
+ * framework-specific formats. Each adapter implements the ToolAdapter
+ * interface and provides a factory function for easy instantiation.
+ *
+ * @module adapters
+ *
+ * @example Inngest AgentKit
+ * ```typescript
+ * import { createInngestAdapter } from '@repo/bigtool-ts/adapters';
+ *
+ * const adapter = createInngestAdapter({ catalog, loader, searchIndex });
+ * const tools = await adapter.getTools(['github:create_pr']);
+ * ```
+ *
+ * @example Vercel AI SDK
+ * ```typescript
+ * import { createVercelAdapter } from '@repo/bigtool-ts/adapters';
+ *
+ * const adapter = createVercelAdapter({ catalog, loader, searchIndex });
+ * const tools = await adapter.getToolsAsRecord(['github:create_pr']);
+ * ```
+ *
+ * @example Mastra
+ * ```typescript
+ * import { createMastraAdapter } from '@repo/bigtool-ts/adapters';
+ *
+ * const adapter = createMastraAdapter({ catalog, loader, searchIndex });
+ * const tools = await adapter.getToolsAsRecord(['github:create_pr']);
+ * ```
+ */
+export type { AdapterConfig, SearchToolOptions, ToolAdapter } from './types.js';
+export { InngestAdapter, createInngestAdapter, type InngestTool, type InngestToolOptions, type InngestNetworkRun, type InngestStep, type SearchToolResult, } from './inngest.js';
+export { createAgentProtocolHandler, type AgentProtocolHandler, type AgentTool, type ToolExecutionResult, type ToolError, type ToolResult, } from './agent-protocol.js';
+export { VercelAIAdapter, createVercelAdapter, } from './vercel-ai.js';
+export { MastraAdapter, createMastraAdapter, type MastraTool, type MastraToolContext, } from './mastra.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/adapters/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAGH,YAAY,EAAE,aAAa,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAGhF,OAAO,EACL,cAAc,EACd,oBAAoB,EACpB,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,WAAW,EAChB,KAAK,gBAAgB,GACtB,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,0BAA0B,EAC1B,KAAK,oBAAoB,EACzB,KAAK,SAAS,EACd,KAAK,mBAAmB,EACxB,KAAK,SAAS,EACd,KAAK,UAAU,GAChB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EACL,eAAe,EACf,mBAAmB,GACpB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,aAAa,EACb,mBAAmB,EACnB,KAAK,UAAU,EACf,KAAK,iBAAiB,GACvB,MAAM,aAAa,CAAC"}

package/dist/adapters/index.js

@@ -0,0 +1,42 @@
+/**
+ * Framework adapters for bigtool-ts.
+ *
+ * This module provides adapters that convert bigtool-ts tools to
+ * framework-specific formats. Each adapter implements the ToolAdapter
+ * interface and provides a factory function for easy instantiation.
+ *
+ * @module adapters
+ *
+ * @example Inngest AgentKit
+ * ```typescript
+ * import { createInngestAdapter } from '@repo/bigtool-ts/adapters';
+ *
+ * const adapter = createInngestAdapter({ catalog, loader, searchIndex });
+ * const tools = await adapter.getTools(['github:create_pr']);
+ * ```
+ *
+ * @example Vercel AI SDK
+ * ```typescript
+ * import { createVercelAdapter } from '@repo/bigtool-ts/adapters';
+ *
+ * const adapter = createVercelAdapter({ catalog, loader, searchIndex });
+ * const tools = await adapter.getToolsAsRecord(['github:create_pr']);
+ * ```
+ *
+ * @example Mastra
+ * ```typescript
+ * import { createMastraAdapter } from '@repo/bigtool-ts/adapters';
+ *
+ * const adapter = createMastraAdapter({ catalog, loader, searchIndex });
+ * const tools = await adapter.getToolsAsRecord(['github:create_pr']);
+ * ```
+ */
+// Inngest AgentKit adapter
+export { InngestAdapter, createInngestAdapter, } from './inngest.js';
+// Agent Protocol adapter
+export { createAgentProtocolHandler, } from './agent-protocol.js';
+// Vercel AI SDK adapter
+export { VercelAIAdapter, createVercelAdapter, } from './vercel-ai.js';
+// Mastra adapter
+export { MastraAdapter, createMastraAdapter, } from './mastra.js';
+//# sourceMappingURL=index.js.map

package/dist/adapters/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/adapters/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAKH,2BAA2B;AAC3B,OAAO,EACL,cAAc,EACd,oBAAoB,GAMrB,MAAM,cAAc,CAAC;AAEtB,yBAAyB;AACzB,OAAO,EACL,0BAA0B,GAM3B,MAAM,qBAAqB,CAAC;AAE7B,wBAAwB;AACxB,OAAO,EACL,eAAe,EACf,mBAAmB,GACpB,MAAM,gBAAgB,CAAC;AAExB,iBAAiB;AACjB,OAAO,EACL,aAAa,EACb,mBAAmB,GAGpB,MAAM,aAAa,CAAC"}

package/dist/adapters/inngest.d.ts

@@ -0,0 +1,234 @@
+/**
+ * Inngest AgentKit adapter for bigtool-ts.
+ *
+ * Converts bigtool-ts tools to Inngest AgentKit format and provides
+ * search tools for dynamic tool discovery.
+ *
+ * @module adapters/inngest
+ *
+ * @example
+ * ```typescript
+ * import { createInngestAdapter } from '@repo/bigtool-ts/adapters';
+ * import { createAgent, openai } from '@inngest/agent-kit';
+ *
+ * const adapter = createInngestAdapter({ catalog, loader, searchIndex });
+ *
+ * const agent = createAgent({
+ *   name: 'tool-user',
+ *   model: openai({ model: 'gpt-4o' }),
+ *   tools: [
+ *     adapter.createSearchTool(),
+ *     adapter.createCallToolTool(),
+ *   ],
+ *   system: 'You are a helpful assistant...',
+ * });
+ * ```
+ */
+import { z } from 'zod';
+import type { ToolMetadata } from '../types.js';
+import type { AdapterConfig, SearchToolOptions, ToolAdapter } from './types.js';
+/**
+ * Inngest AgentKit tool type.
+ *
+ * Matches the Tool type from @inngest/agent-kit but defined here
+ * to avoid requiring the package as a runtime dependency.
+ */
+export interface InngestTool {
+    name: string;
+    description: string | undefined;
+    parameters: z.ZodTypeAny | undefined;
+    handler: (input: unknown, opts: InngestToolOptions) => unknown | Promise<unknown>;
+}
+/**
+ * Options passed to tool handlers by Inngest AgentKit.
+ *
+ * These options provide access to agent context, network state,
+ * and durable execution primitives.
+ */
+export interface InngestToolOptions {
+    /** The agent executing this tool */
+    agent: unknown;
+    /** Network run context for accessing shared state (kv store and typed data) */
+    network: InngestNetworkRun | undefined;
+    /** Step context for durable execution (step.run, step.waitForEvent) */
+    step: InngestStep | undefined;
+}
+/**
+ * Inngest network run context for state access.
+ */
+export interface InngestNetworkRun {
+    state: {
+        kv: {
+            get(key: string): unknown;
+            set(key: string, value: unknown): void;
+        };
+        data: Record<string, unknown>;
+    };
+}
+/**
+ * Inngest step context for durable execution.
+ *
+ * Provides primitives for building reliable, resumable workflows.
+ */
+export interface InngestStep {
+    /**
+     * Execute code durably with automatic retries.
+     * Results are cached - if the function resumes, cached results are returned.
+     */
+    run<T>(name: string, fn: () => T | Promise<T>): Promise<T>;
+    /**
+     * Wait for an external event (human-in-the-loop, webhooks, etc.).
+     * The function pauses until the event arrives or timeout is reached.
+     */
+    waitForEvent(name: string, opts: {
+        event: string;
+        timeout: string;
+        match?: string;
+    }): Promise<unknown>;
+}
+/**
+ * Inngest AgentKit adapter for bigtool-ts.
+ *
+ * Implements the ToolAdapter interface to convert bigtool-ts tools
+ * to Inngest AgentKit format. Provides additional tools for dynamic
+ * tool discovery and execution.
+ *
+ * Key features:
+ * - Automatic durable execution wrapping via step.run()
+ * - Search tool for runtime tool discovery
+ * - Call tool for executing discovered tools by name
+ *
+ * @example Basic usage
+ * ```typescript
+ * const adapter = createInngestAdapter({ catalog, loader, searchIndex });
+ *
+ * // Get specific tools by ID
+ * const tools = await adapter.getTools(['github:create_pr', 'slack:send']);
+ *
+ * // Create discovery tools
+ * const searchTool = adapter.createSearchTool({ limit: 5 });
+ * const callTool = adapter.createCallToolTool();
+ * ```
+ */
+export declare class InngestAdapter implements ToolAdapter<InngestTool> {
+    private readonly catalog;
+    private readonly loader;
+    private readonly searchIndex;
+    constructor(config: AdapterConfig);
+    /**
+     * Convert bigtool-ts metadata to an Inngest AgentKit tool.
+     *
+     * The resulting tool wraps the bigtool-ts loader and automatically
+     * uses step.run() for durable execution when available.
+     *
+     * **Note:** Parameter schemas are not converted from ToolMetadata to Zod.
+     * The underlying bigtool-ts tool handles its own input validation.
+     * If you need Inngest-side schema validation, provide tools with Zod
+     * schemas directly rather than using the adapter.
+     *
+     * @param metadata - Tool metadata from the catalog
+     * @returns Inngest-compatible tool
+     */
+    toFrameworkTool(metadata: ToolMetadata): InngestTool;
+    /**
+     * Get multiple tools by their IDs.
+     *
+     * Tools not found in the catalog are silently skipped.
+     * Use this when you know which tools you need ahead of time.
+     *
+     * @param toolIds - Array of tool IDs to retrieve
+     * @returns Array of Inngest-compatible tools
+     */
+    getTools(toolIds: string[]): Promise<InngestTool[]>;
+    /**
+     * Get all tools from the catalog.
+     *
+     * Use sparingly - prefer getTools() or createSearchTool() for
+     * large catalogs.
+     *
+     * @returns Array of all Inngest-compatible tools
+     */
+    getAllTools(): Promise<InngestTool[]>;
+    /**
+     * Get tools filtered by category.
+     *
+     * @param categories - Categories to filter by (matches any)
+     * @returns Array of matching Inngest-compatible tools
+     */
+    getToolsByCategory(categories: string[]): Promise<InngestTool[]>;
+    /**
+     * Create a search tool for discovering available tools.
+     *
+     * This is the core tool for dynamic tool discovery. The agent
+     * can search for tools by natural language query and get back
+     * matching tool names and descriptions.
+     *
+     * @param options - Search options (limit, threshold, categories)
+     * @returns Inngest-compatible search tool
+     *
+     * @example
+     * ```typescript
+     * const searchTool = adapter.createSearchTool({ limit: 5 });
+     * // Agent calls: search_tools({ query: "create github pr" })
+     * // Returns: [{ name: "create_pr", description: "...", score: 0.95 }]
+     * ```
+     */
+    createSearchTool(options?: SearchToolOptions): InngestTool;
+    /**
+     * Create a tool for executing discovered tools by name.
+     *
+     * Use this in combination with createSearchTool() to enable
+     * dynamic tool discovery and execution patterns.
+     *
+     * **Note:** Tool lookup uses name matching. If multiple tools share the
+     * same name (from different sources), the first match wins. Ensure tool
+     * names are unique within your catalog to avoid ambiguity.
+     *
+     * @returns Inngest-compatible call tool
+     *
+     * @example
+     * ```typescript
+     * const callTool = adapter.createCallToolTool();
+     * // Agent calls: call_tool({ toolName: "create_pr", arguments: { title: "..." } })
+     * ```
+     */
+    createCallToolTool(): InngestTool;
+}
+/**
+ * Result returned by the search_tools tool.
+ */
+export interface SearchToolResult {
+    /** Tool name */
+    name: string;
+    /** Tool description */
+    description: string;
+    /** Relevance score (0-1) */
+    score: number;
+}
+/**
+ * Create an Inngest AgentKit adapter.
+ *
+ * Factory function for creating InngestAdapter instances. Use this
+ * as the primary entry point for the adapter.
+ *
+ * @param config - Adapter configuration with catalog, loader, and search index
+ * @returns Configured InngestAdapter instance
+ *
+ * @example
+ * ```typescript
+ * import { createInngestAdapter } from '@repo/bigtool-ts/adapters';
+ * import { DefaultToolCatalog, OramaSearch, DefaultToolLoader } from '@repo/bigtool-ts';
+ *
+ * const catalog = new DefaultToolCatalog();
+ * await catalog.register(new LocalSource(myTools));
+ *
+ * const searchIndex = new OramaSearch();
+ * await searchIndex.index(catalog.getAllMetadata());
+ *
+ * const loader = new DefaultToolLoader(catalog);
+ *
+ * const adapter = createInngestAdapter({ catalog, loader, searchIndex });
+ * ```
+ */
+export declare function createInngestAdapter(config: AdapterConfig): InngestAdapter;
+//# sourceMappingURL=inngest.d.ts.map

package/dist/adapters/inngest.d.ts.map

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