@frontmcp/plugins 0.6.3 → 0.7.2

package/codecall/services/tool-search.service.d.ts

@@ -1,175 +0,0 @@
-import { ToolEntry, ScopeEntry } from '@frontmcp/sdk';
-import type { EmbeddingStrategy, CodeCallEmbeddingOptions, CodeCallMode } from '../codecall.types';
-import type { ToolSearch, ToolSearchResult as SymbolToolSearchResult, ToolSearchOptions as SymbolToolSearchOptions } from '../codecall.symbol';
-import { SynonymExpansionConfig } from './synonym-expansion.service';
-/**
- * Search result for tool search
- */
-export interface SearchResult {
-    tool: ToolEntry<any, any>;
-    score: number;
-    toolName: string;
-    qualifiedName: string;
-    appId?: string;
-}
-/**
- * Search options for tool search
- */
-export interface SearchOptions {
-    topK?: number;
-    appIds?: string[];
-    excludeToolNames?: string[];
-    minScore?: number;
-}
-/**
- * Filter function type for including tools
- */
-export type IncludeToolsFilter = (info: {
-    name: string;
-    appId?: string;
-    source?: string;
-    description?: string;
-    tags?: string[];
-}) => boolean;
-/**
- * Configuration for tool search service
- */
-export interface ToolSearchServiceConfig {
-    /**
-     * Embedding strategy to use
-     * @default 'tfidf'
-     */
-    strategy?: EmbeddingStrategy;
-    /**
-     * Full embedding options (alternative to just strategy)
-     */
-    embeddingOptions?: CodeCallEmbeddingOptions;
-    /**
-     * Default number of results to return
-     * @default 8
-     */
-    defaultTopK?: number;
-    /**
-     * Default similarity threshold
-     * @default 0.0
-     */
-    defaultSimilarityThreshold?: number;
-    /**
-     * CodeCall mode for filtering tools
-     * @default 'codecall_only'
-     */
-    mode?: CodeCallMode;
-    /**
-     * Optional filter function for including tools in the search index
-     */
-    includeTools?: IncludeToolsFilter;
-    /**
-     * Synonym expansion configuration.
-     * When enabled, queries are expanded with synonyms to improve search relevance.
-     * For example, "add user" will also match tools containing "create user".
-     * Only applies when strategy is 'tfidf' (ML already handles semantic similarity).
-     *
-     * Set to false to disable, or provide a config object to customize.
-     * @default { enabled: true } when strategy is 'tfidf'
-     */
-    synonymExpansion?: false | (SynonymExpansionConfig & {
-        enabled?: boolean;
-    });
-}
-/**
- * Service that maintains a searchable index of tools from the ToolRegistry
- * Supports both TF-IDF (lightweight, synchronous) and ML-based (semantic) embeddings
- * Implements the ToolSearch interface for dependency injection
- */
-export declare class ToolSearchService implements ToolSearch {
-    private static readonly MAX_SUBSCRIPTION_RETRIES;
-    private vectorDB;
-    private strategy;
-    private initialized;
-    private mlInitialized;
-    private subscriptionRetries;
-    private config;
-    private scope;
-    private unsubscribe?;
-    private synonymService;
-    constructor(config: ToolSearchServiceConfig | undefined, scope: ScopeEntry);
-    /**
-     * Sets up subscription to tool changes. Handles the case where scope.tools
-     * may not be available yet during plugin initialization.
-     */
-    private setupSubscription;
-    /**
-     * Handles tool change events by reindexing all tools from the snapshot
-     */
-    private handleToolChange;
-    /**
-     * Determines if a tool should be indexed in the search database.
-     * Filters based on:
-     * - Excludes codecall:* meta-tools (they should not be searchable)
-     * - Mode-based filtering (codecall_only, codecall_opt_in, metadata_driven)
-     * - Per-tool metadata.codecall.enabledInCodeCall
-     * - Custom includeTools filter function
-     */
-    private shouldIndexTool;
-    /**
-     * Extract CodeCall-specific metadata from a tool.
-     */
-    private getCodeCallMetadata;
-    /**
-     * Initializes the search service by indexing all tools from the registry.
-     * NOTE: This method is now a no-op. Initialization is handled reactively
-     * via subscription to tool change events in the constructor.
-     * This method exists for interface compatibility.
-     */
-    initialize(): Promise<void>;
-    /**
-     * Cleanup subscription when service is destroyed
-     */
-    dispose(): void;
-    /**
-     * Extracts searchable text from a tool instance.
-     * Uses term weighting to improve relevance:
-     * - Description terms are heavily weighted (most important for semantic matching)
-     * - Tool name parts are tokenized and weighted
-     * - Tags provide additional context
-     */
-    private extractSearchableText;
-    /**
-     * Checks if a word is a common stop word that should not receive extra weighting.
-     * Uses module-level STOP_WORDS constant to avoid recreating the Set on each call.
-     */
-    private isStopWord;
-    /**
-     * Extracts app ID from tool's owner lineage
-     */
-    private extractAppId;
-    /**
-     * Searches for tools matching the query
-     * Implements the ToolSearch interface
-     */
-    search(query: string, options?: SymbolToolSearchOptions): Promise<SymbolToolSearchResult[]>;
-    /**
-     * Gets all indexed tool names
-     */
-    getAllToolNames(): string[];
-    /**
-     * Gets the total number of indexed tools
-     */
-    getTotalCount(): number;
-    /**
-     * Checks if a tool exists in the index
-     */
-    hasTool(toolName: string): boolean;
-    /**
-     * Clears the entire index
-     */
-    clear(): void;
-    /**
-     * Get the current embedding strategy
-     */
-    getStrategy(): EmbeddingStrategy;
-    /**
-     * Check if the service is initialized
-     */
-    isInitialized(): boolean;
-}

package/codecall/tools/describe.schema.d.ts

@@ -1,28 +0,0 @@
-import { z } from 'zod';
-export declare const describeToolDescription = "Get input/output schemas for tools from search results.\n\nINPUT: toolNames: string[] - tool names from search\nOUTPUT per tool: inputSchema (JSON Schema), outputSchema (JSON Schema), usageExamples (up to 5 callTool examples)\n\nIMPORTANT: If notFound array is non-empty \u2192 re-search with corrected queries.\nFLOW: search \u2192 describe \u2192 execute/invoke";
-export declare const describeToolInputSchema: z.ZodObject<{
-    toolNames: z.ZodArray<z.ZodString>;
-}, z.core.$strip>;
-export type DescribeToolInput = z.infer<typeof describeToolInputSchema>;
-export declare const describeToolOutputSchema: z.ZodObject<{
-    tools: z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        appId: z.ZodString;
-        description: z.ZodString;
-        inputSchema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        outputSchema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        annotations: z.ZodOptional<z.ZodObject<{
-            title: z.ZodOptional<z.ZodString>;
-            readOnlyHint: z.ZodOptional<z.ZodBoolean>;
-            destructiveHint: z.ZodOptional<z.ZodBoolean>;
-            idempotentHint: z.ZodOptional<z.ZodBoolean>;
-            openWorldHint: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>>;
-        usageExamples: z.ZodArray<z.ZodObject<{
-            description: z.ZodString;
-            code: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-    notFound: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-export type DescribeToolOutput = z.infer<typeof describeToolOutputSchema>;

package/codecall/tools/describe.tool.d.ts

@@ -1,35 +0,0 @@
-import { ToolContext } from '@frontmcp/sdk';
-import { DescribeToolInput, DescribeToolOutput } from './describe.schema';
-export default class DescribeTool extends ToolContext {
-    execute(input: DescribeToolInput): Promise<DescribeToolOutput>;
-    /**
-     * Get the input schema for a tool, converting from Zod to JSON Schema.
-     * This ensures that property descriptions from .describe() are included.
-     *
-     * Priority:
-     * 1. Convert from tool.inputSchema (Zod) to get descriptions
-     * 2. Fall back to rawInputSchema if conversion fails
-     * 3. Return null if no schema available
-     */
-    private getInputSchema;
-    /**
-     * Convert a schema to JSON Schema format.
-     * Handles Zod schemas, raw shapes, and already-JSON-Schema objects.
-     *
-     * Uses Zod v4's built-in z.toJSONSchema() for conversion.
-     */
-    private toJsonSchema;
-    /**
-     * Extract app ID from tool metadata or owner.
-     */
-    private extractAppId;
-    /**
-     * Generate up to 5 usage examples for a tool.
-     *
-     * Priority:
-     * 1. User-provided examples from @Tool decorator metadata (up to 5)
-     * 2. Smart intent-based generation to fill remaining slots
-     * 3. Returns at least 1 example
-     */
-    private generateExamples;
-}

package/codecall/tools/execute.schema.d.ts

@@ -1,115 +0,0 @@
-import { z } from 'zod';
-export declare const executeToolDescription = "Execute AgentScript (safe JS subset) for multi-tool orchestration.\n\nAPI: await callTool(name, args, opts?)\n- Default: throws on error\n- Safe mode: { throwOnError: false } \u2192 returns { success, data?, error? }\n\nEXAMPLE:\nconst users = await callTool('users:list', { active: true });\nconst results = [];\nfor (const u of users.items) {\n  const orders = await callTool('orders:list', { userId: u.id });\n  results.push({ id: u.id, total: orders.items.reduce((s,o) => s + o.amount, 0) });\n}\nreturn results;\n\nALLOWED: for, for-of, arrow fn, map/filter/reduce/find, Math.*, JSON.*, if/else, destructuring, spread, template literals\nBLOCKED: while, do-while, function decl, eval, require, fetch, setTimeout, process, globalThis\n\nERRORS: NOT_FOUND | VALIDATION | EXECUTION | TIMEOUT | ACCESS_DENIED\nSTATUS: ok | syntax_error | illegal_access | runtime_error | tool_error | timeout\nLIMITS: 10K iter/loop, 30s timeout, 100 calls max";
-export declare const executeToolInputSchema: z.ZodObject<{
-    script: z.ZodString;
-    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-export type ExecuteToolInput = z.infer<typeof executeToolInputSchema>;
-/**
- * Result variants
- */
-export declare const codeCallOkResultSchema: z.ZodObject<{
-    status: z.ZodLiteral<"ok">;
-    result: z.ZodUnknown;
-    logs: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
-export declare const codeCallSyntaxErrorResultSchema: z.ZodObject<{
-    status: z.ZodLiteral<"syntax_error">;
-    error: z.ZodObject<{
-        message: z.ZodString;
-        location: z.ZodOptional<z.ZodObject<{
-            line: z.ZodNumber;
-            column: z.ZodNumber;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export declare const codeCallIllegalAccessResultSchema: z.ZodObject<{
-    status: z.ZodLiteral<"illegal_access">;
-    error: z.ZodObject<{
-        message: z.ZodString;
-        kind: z.ZodUnion<readonly [z.ZodLiteral<"IllegalBuiltinAccess">, z.ZodLiteral<"DisallowedGlobal">, z.ZodString]>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export declare const codeCallRuntimeErrorResultSchema: z.ZodObject<{
-    status: z.ZodLiteral<"runtime_error">;
-    error: z.ZodObject<{
-        source: z.ZodLiteral<"script">;
-        message: z.ZodString;
-        name: z.ZodOptional<z.ZodString>;
-        stack: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export declare const codeCallToolErrorResultSchema: z.ZodObject<{
-    status: z.ZodLiteral<"tool_error">;
-    error: z.ZodObject<{
-        source: z.ZodLiteral<"tool">;
-        toolName: z.ZodString;
-        toolInput: z.ZodUnknown;
-        message: z.ZodString;
-        code: z.ZodOptional<z.ZodString>;
-        details: z.ZodOptional<z.ZodUnknown>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export declare const codeCallTimeoutResultSchema: z.ZodObject<{
-    status: z.ZodLiteral<"timeout">;
-    error: z.ZodObject<{
-        message: z.ZodString;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-/**
- * Discriminated union for the whole result
- */
-export declare const executeToolOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    status: z.ZodLiteral<"ok">;
-    result: z.ZodUnknown;
-    logs: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>, z.ZodObject<{
-    status: z.ZodLiteral<"syntax_error">;
-    error: z.ZodObject<{
-        message: z.ZodString;
-        location: z.ZodOptional<z.ZodObject<{
-            line: z.ZodNumber;
-            column: z.ZodNumber;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
-}, z.core.$strip>, z.ZodObject<{
-    status: z.ZodLiteral<"illegal_access">;
-    error: z.ZodObject<{
-        message: z.ZodString;
-        kind: z.ZodUnion<readonly [z.ZodLiteral<"IllegalBuiltinAccess">, z.ZodLiteral<"DisallowedGlobal">, z.ZodString]>;
-    }, z.core.$strip>;
-}, z.core.$strip>, z.ZodObject<{
-    status: z.ZodLiteral<"runtime_error">;
-    error: z.ZodObject<{
-        source: z.ZodLiteral<"script">;
-        message: z.ZodString;
-        name: z.ZodOptional<z.ZodString>;
-        stack: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
-}, z.core.$strip>, z.ZodObject<{
-    status: z.ZodLiteral<"tool_error">;
-    error: z.ZodObject<{
-        source: z.ZodLiteral<"tool">;
-        toolName: z.ZodString;
-        toolInput: z.ZodUnknown;
-        message: z.ZodString;
-        code: z.ZodOptional<z.ZodString>;
-        details: z.ZodOptional<z.ZodUnknown>;
-    }, z.core.$strip>;
-}, z.core.$strip>, z.ZodObject<{
-    status: z.ZodLiteral<"timeout">;
-    error: z.ZodObject<{
-        message: z.ZodString;
-    }, z.core.$strip>;
-}, z.core.$strip>], "status">;
-/**
- * Inferred types
- * (you can export whichever ones you actually need)
- */
-export type CodeCallOkResult = z.infer<typeof codeCallOkResultSchema>;
-export type CodeCallSyntaxErrorResult = z.infer<typeof codeCallSyntaxErrorResultSchema>;
-export type CodeCallIllegalAccessResult = z.infer<typeof codeCallIllegalAccessResultSchema>;
-export type CodeCallRuntimeErrorResult = z.infer<typeof codeCallRuntimeErrorResultSchema>;
-export type CodeCallToolErrorResult = z.infer<typeof codeCallToolErrorResultSchema>;
-export type CodeCallTimeoutResult = z.infer<typeof codeCallTimeoutResultSchema>;
-export type CodeCallExecuteResult = CodeCallOkResult | CodeCallSyntaxErrorResult | CodeCallIllegalAccessResult | CodeCallRuntimeErrorResult | CodeCallToolErrorResult | CodeCallTimeoutResult;

package/codecall/tools/execute.tool.d.ts

@@ -1,5 +0,0 @@
-import { ToolContext } from '@frontmcp/sdk';
-import { CodeCallExecuteResult, ExecuteToolInput } from './execute.schema';
-export default class ExecuteTool extends ToolContext {
-    execute(input: ExecuteToolInput): Promise<CodeCallExecuteResult>;
-}

package/codecall/tools/index.d.ts

@@ -1,4 +0,0 @@
-export { default as SearchTool } from './search.tool';
-export { default as DescribeTool } from './describe.tool';
-export { default as ExecuteTool } from './execute.tool';
-export { default as InvokeTool } from './invoke.tool';

package/codecall/tools/invoke.schema.d.ts

@@ -1,104 +0,0 @@
-import { z } from 'zod';
-export declare const invokeToolDescription = "Call ONE tool directly. Returns standard MCP CallToolResult.\n\nUSE invoke: single tool, no transformation\nUSE execute: multiple tools, loops, filtering, joining\n\nINPUT: tool (string), input (object matching tool schema)\nOUTPUT: MCP CallToolResult (same as standard tool call)\nERRORS: tool_not_found (\u2192 re-search) | validation_error | execution_error | permission_denied\n\nFLOW: search \u2192 describe \u2192 invoke";
-export declare const invokeToolInputSchema: z.ZodObject<{
-    tool: z.ZodString;
-    input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-}, z.core.$strip>;
-export type InvokeToolInput = z.infer<typeof invokeToolInputSchema>;
-export declare const invokeToolOutputSchema: z.ZodObject<{
-    _meta: z.ZodOptional<z.ZodObject<{
-        progressToken: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-        "io.modelcontextprotocol/related-task": z.ZodOptional<z.ZodObject<{
-            taskId: z.ZodString;
-        }, z.core.$strip>>;
-    }, z.core.$loose>>;
-    content: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
-        type: z.ZodLiteral<"text">;
-        text: z.ZodString;
-        annotations: z.ZodOptional<z.ZodObject<{
-            audience: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-                user: "user";
-                assistant: "assistant";
-            }>>>;
-            priority: z.ZodOptional<z.ZodNumber>;
-            lastModified: z.ZodOptional<z.ZodISODateTime>;
-        }, z.core.$strip>>;
-        _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"image">;
-        data: z.ZodString;
-        mimeType: z.ZodString;
-        annotations: z.ZodOptional<z.ZodObject<{
-            audience: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-                user: "user";
-                assistant: "assistant";
-            }>>>;
-            priority: z.ZodOptional<z.ZodNumber>;
-            lastModified: z.ZodOptional<z.ZodISODateTime>;
-        }, z.core.$strip>>;
-        _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"audio">;
-        data: z.ZodString;
-        mimeType: z.ZodString;
-        annotations: z.ZodOptional<z.ZodObject<{
-            audience: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-                user: "user";
-                assistant: "assistant";
-            }>>>;
-            priority: z.ZodOptional<z.ZodNumber>;
-            lastModified: z.ZodOptional<z.ZodISODateTime>;
-        }, z.core.$strip>>;
-        _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>, z.ZodObject<{
-        uri: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-        mimeType: z.ZodOptional<z.ZodString>;
-        annotations: z.ZodOptional<z.ZodObject<{
-            audience: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-                user: "user";
-                assistant: "assistant";
-            }>>>;
-            priority: z.ZodOptional<z.ZodNumber>;
-            lastModified: z.ZodOptional<z.ZodISODateTime>;
-        }, z.core.$strip>>;
-        _meta: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
-        icons: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            src: z.ZodString;
-            mimeType: z.ZodOptional<z.ZodString>;
-            sizes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            theme: z.ZodOptional<z.ZodEnum<{
-                light: "light";
-                dark: "dark";
-            }>>;
-        }, z.core.$strip>>>;
-        name: z.ZodString;
-        title: z.ZodOptional<z.ZodString>;
-        type: z.ZodLiteral<"resource_link">;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"resource">;
-        resource: z.ZodUnion<readonly [z.ZodObject<{
-            uri: z.ZodString;
-            mimeType: z.ZodOptional<z.ZodString>;
-            _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-            text: z.ZodString;
-        }, z.core.$strip>, z.ZodObject<{
-            uri: z.ZodString;
-            mimeType: z.ZodOptional<z.ZodString>;
-            _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-            blob: z.ZodString;
-        }, z.core.$strip>]>;
-        annotations: z.ZodOptional<z.ZodObject<{
-            audience: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-                user: "user";
-                assistant: "assistant";
-            }>>>;
-            priority: z.ZodOptional<z.ZodNumber>;
-            lastModified: z.ZodOptional<z.ZodISODateTime>;
-        }, z.core.$strip>>;
-        _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>]>>>;
-    structuredContent: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    isError: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$loose>;
-export type InvokeToolOutput = z.infer<typeof invokeToolOutputSchema>;

package/codecall/tools/invoke.tool.d.ts

@@ -1,13 +0,0 @@
-import { ToolContext } from '@frontmcp/sdk';
-import { InvokeToolInput, InvokeToolOutput } from './invoke.schema';
-/**
- * InvokeTool allows direct tool invocation without running JavaScript code.
- * Returns the same CallToolResult format as a standard MCP tool call.
- *
- * Security Considerations:
- * - Self-reference blocking: Cannot invoke codecall:* tools
- * - All middleware (auth, PII, rate limiting) applies via normal tool execution
- */
-export default class InvokeTool extends ToolContext {
-    execute(input: InvokeToolInput): Promise<InvokeToolOutput>;
-}

package/codecall/tools/search.schema.d.ts

@@ -1,30 +0,0 @@
-import { z } from 'zod';
-export declare const searchToolDescription = "Find tools by splitting user request into atomic actions.\n\nDECOMPOSE: \"delete users and send email\" \u2192 queries: [\"delete user\", \"send email\"]\nDECOMPOSE: \"get order and refund\" \u2192 queries: [\"get order\", \"calculate refund\"]\n\nAVOID RE-SEARCHING: Use excludeToolNames for already-discovered tools.\nRE-SEARCH WHEN: describe fails (typo?) OR execute returns tool_not_found.\n\nINPUT:\n- queries: string[] (required) - atomic action phrases, max 10\n- appIds?: string[] - filter by app\n- excludeToolNames?: string[] - skip known tools\n- topK?: number (default 5) - results per query\n- minRelevanceScore?: number (default 0.3) - minimum match threshold\n\nOUTPUT: Flat deduplicated tool list. relevanceScore: 0.5+=good, 0.7+=strong match.\n\nFLOW: search \u2192 describe \u2192 execute/invoke";
-export declare const searchToolInputSchema: z.ZodObject<{
-    queries: z.ZodArray<z.ZodString>;
-    appIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    excludeToolNames: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    topK: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    minRelevanceScore: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-}, z.core.$strip>;
-export type SearchToolInput = z.infer<typeof searchToolInputSchema>;
-export declare const searchToolOutputSchema: z.ZodObject<{
-    tools: z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        appId: z.ZodOptional<z.ZodString>;
-        description: z.ZodString;
-        relevanceScore: z.ZodNumber;
-        matchedQueries: z.ZodArray<z.ZodString>;
-    }, z.core.$strip>>;
-    warnings: z.ZodArray<z.ZodObject<{
-        type: z.ZodEnum<{
-            excluded_tool_not_found: "excluded_tool_not_found";
-            no_results: "no_results";
-            low_relevance: "low_relevance";
-        }>;
-        message: z.ZodString;
-        affectedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>;
-    totalAvailableTools: z.ZodNumber;
-}, z.core.$strip>;
-export type SearchToolOutput = z.infer<typeof searchToolOutputSchema>;

package/codecall/tools/search.tool.d.ts

@@ -1,5 +0,0 @@
-import { ToolContext } from '@frontmcp/sdk';
-import { SearchToolInput, SearchToolOutput } from './search.schema';
-export default class SearchTool extends ToolContext {
-    execute(input: SearchToolInput): Promise<SearchToolOutput>;
-}

package/codecall/utils/describe.utils.d.ts

@@ -1,86 +0,0 @@
-import type { JSONSchema } from 'zod/v4/core';
-/** JSON Schema type from Zod v4 */
-type JsonSchema = JSONSchema.JSONSchema;
-/**
- * Tool example for describe output
- */
-export interface ToolUsageExample {
-    description: string;
-    code: string;
-}
-/**
- * Detected intent of a tool based on its name and description.
- */
-export type ToolIntent = 'create' | 'list' | 'get' | 'update' | 'delete' | 'search' | 'action' | 'unknown';
-/**
- * Detect the intent of a tool from its name.
- * Extracts the action verb from tool names like "users:create" or "orders:list".
- */
-export declare function detectToolIntent(toolName: string, description?: string): ToolIntent;
-/**
- * Generate a TypeScript-like function signature from a JSON Schema.
- *
- * @example
- * Input: { type: 'object', properties: { id: { type: 'string' }, limit: { type: 'number' } }, required: ['id'] }
- * Output: "(id: string, limit?: number) => unknown"
- */
-export declare function jsonSchemaToSignature(toolName: string, inputSchema?: JsonSchema, outputSchema?: JsonSchema): string;
-/**
- * Generate a natural language summary of a schema.
- */
-export declare function jsonSchemaToNaturalLanguage(schema: JsonSchema | undefined | null, direction: 'input' | 'output'): string;
-/**
- * Generate a basic usage example for a tool.
- */
-export declare function generateBasicExample(toolName: string, inputSchema?: JsonSchema): ToolUsageExample;
-/**
- * Check if a schema has pagination parameters.
- */
-export declare function hasPaginationParams(schema?: JsonSchema): boolean;
-/**
- * Check if a schema has filter-like parameters.
- */
-export declare function hasFilterParams(schema?: JsonSchema): boolean;
-/**
- * Get filter-like property names from a schema.
- */
-export declare function getFilterProperties(schema?: JsonSchema): string[];
-/**
- * Generate a pagination example for a tool.
- */
-export declare function generatePaginationExample(toolName: string): ToolUsageExample;
-/**
- * Generate a filter example for a tool.
- */
-export declare function generateFilterExample(toolName: string, filterProp: string): ToolUsageExample;
-/**
- * Generate a create example for a tool.
- * Shows required parameters with contextual sample values.
- */
-export declare function generateCreateExample(toolName: string, inputSchema?: JsonSchema): ToolUsageExample;
-/**
- * Generate a get (retrieve single item) example for a tool.
- */
-export declare function generateGetExample(toolName: string, inputSchema?: JsonSchema): ToolUsageExample;
-/**
- * Generate a list example for a tool.
- */
-export declare function generateListExample(toolName: string, inputSchema?: JsonSchema): ToolUsageExample;
-/**
- * Generate an update example for a tool.
- */
-export declare function generateUpdateExample(toolName: string, inputSchema?: JsonSchema): ToolUsageExample;
-/**
- * Generate a delete example for a tool.
- */
-export declare function generateDeleteExample(toolName: string, inputSchema?: JsonSchema): ToolUsageExample;
-/**
- * Generate a search example for a tool.
- */
-export declare function generateSearchExample(toolName: string, inputSchema?: JsonSchema): ToolUsageExample;
-/**
- * Smart example generator that uses intent detection.
- * This is the main entry point for generating examples.
- */
-export declare function generateSmartExample(toolName: string, inputSchema?: JsonSchema, description?: string): ToolUsageExample;
-export {};

package/codecall/utils/index.d.ts

@@ -1,2 +0,0 @@
-export * from './describe.utils';
-export * from './mcp-result';

package/codecall/utils/mcp-result.d.ts

@@ -1,6 +0,0 @@
-import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-/**
- * Extract the actual result from a CallToolResult.
- * MCP returns results wrapped in content array format.
- */
-export declare function extractResultFromCallToolResult(mcpResult: CallToolResult): unknown;