@pellux/goodvibes-sdk 0.18.3 → 0.18.11

package/dist/platform/tools/registry-tool/index.js

@@ -0,0 +1,408 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join, resolve, isAbsolute } from 'node:path';
+import Fuse from 'fuse.js';
+import { logger } from '../../utils/logger.js';
+import { collectMarkdownReferences, extractMarkdownPreview, normalizeFrontmatterList, parseMarkdownFrontmatter, readMarkdownDisclosure, materializeMarkdownBody, } from '../../utils/markdown-disclosure.js';
+import { REGISTRY_TOOL_SCHEMA } from './schema.js';
+import { summarizeError } from '../../utils/error-display.js';
+// ---------------------------------------------------------------------------
+// Frontmatter parser
+// ---------------------------------------------------------------------------
+function parseFrontmatter(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!match)
+        return {};
+    const result = {};
+    for (const line of match[1].split('\n')) {
+        const [key, ...rest] = line.split(':');
+        if (key && rest.length)
+            result[key.trim()] = rest.join(':').trim();
+    }
+    return result;
+}
+function scanDirectory(dir, itemType, query) {
+    if (!existsSync(dir))
+        return [];
+    const all = scanDirectoryAll(dir, itemType);
+    if (!query)
+        return all;
+    return fuzzyFilter(all, query);
+}
+function scanDirectoryAll(dir, itemType) {
+    if (!existsSync(dir))
+        return [];
+    const results = [];
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    for (const entry of entries) {
+        // Strategy 1: flat .md file (e.g., skills/foo.md)
+        if (entry.endsWith('.md')) {
+            const filePath = join(dir, entry);
+            let content = '';
+            try {
+                content = readFileSync(filePath, 'utf-8');
+            }
+            catch {
+                continue;
+            }
+            const { metadata: frontmatter, body } = parseMarkdownFrontmatter(content);
+            const name = typeof frontmatter['name'] === 'string' ? frontmatter['name'] : entry.replace(/\.md$/, '');
+            const description = typeof frontmatter['description'] === 'string' ? frontmatter['description'] : '';
+            results.push({
+                name,
+                type: itemType,
+                description,
+                path: filePath,
+                preview: extractMarkdownPreview(body),
+                dependencies: normalizeFrontmatterList(frontmatter['depends_on']),
+                includes: collectMarkdownReferences(body),
+            });
+            continue;
+        }
+        // Strategy 2: directory with SKILL.md or AGENT.md (e.g., skills/foo/SKILL.md)
+        const markerFile = itemType === 'skill' ? 'SKILL.md' : 'AGENT.md';
+        const markerPath = join(dir, entry, markerFile);
+        if (existsSync(markerPath)) {
+            let content = '';
+            try {
+                content = readFileSync(markerPath, 'utf-8');
+            }
+            catch {
+                continue;
+            }
+            const { metadata: frontmatter, body } = parseMarkdownFrontmatter(content);
+            const name = typeof frontmatter['name'] === 'string' ? frontmatter['name'] : entry;
+            const description = typeof frontmatter['description'] === 'string' ? frontmatter['description'] : '';
+            results.push({
+                name,
+                type: itemType,
+                description,
+                path: markerPath,
+                preview: extractMarkdownPreview(body),
+                dependencies: normalizeFrontmatterList(frontmatter['depends_on']),
+                includes: collectMarkdownReferences(body),
+            });
+        }
+    }
+    return results;
+}
+/**
+ * Fuzzy-filter a list of RegistryMatch items using Fuse.js.
+ * Weights: name (3) > path/filename (2) > description (1).
+ * Results are sorted by ascending Fuse score (lower = better match).
+ */
+function fuzzyFilter(items, query) {
+    if (!query || items.length === 0)
+        return items;
+    const fuse = new Fuse(items, {
+        keys: [
+            { name: 'name', weight: 3 },
+            { name: 'path', weight: 2 },
+            { name: 'description', weight: 1 },
+        ],
+        threshold: 0.4,
+        includeScore: true,
+        minMatchCharLength: 1,
+    });
+    return fuse.search(query).map((r) => r.item);
+}
+function getSkillDirs(roots) {
+    const dirs = [
+        join(roots.workingDirectory, '.goodvibes', 'skills'),
+        join(roots.workingDirectory, '.goodvibes', 'sdk', 'skills'),
+    ];
+    if (roots.homeDirectory) {
+        dirs.push(join(roots.homeDirectory, '.goodvibes', 'skills'), join(roots.homeDirectory, '.goodvibes', 'sdk', 'skills'));
+    }
+    return dirs;
+}
+function getAgentDirs(roots) {
+    const dirs = [
+        join(roots.workingDirectory, '.goodvibes', 'agents'),
+        join(roots.workingDirectory, '.goodvibes', 'sdk', 'agents'),
+    ];
+    if (roots.homeDirectory) {
+        dirs.push(join(roots.homeDirectory, '.goodvibes', 'agents'), join(roots.homeDirectory, '.goodvibes', 'sdk', 'agents'));
+    }
+    return dirs;
+}
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+/**
+ * Create the `registry` tool bound to the given ToolRegistry.
+ *
+ * Returns a Tool object conforming to the Tool interface.
+ * Never throws from execute().
+ */
+export function createRegistryTool(toolRegistry, roots) {
+    const definition = {
+        name: 'registry',
+        description: 'Discover and inspect skills, agents, and tools.'
+            + ' Modes: search finds items by keyword; recommend lists items sorted by relevance;'
+            + ' dependencies reads a skill\'s dependency chain; content returns full markdown file.',
+        parameters: REGISTRY_TOOL_SCHEMA,
+        sideEffects: ['read_fs'],
+        concurrency: 'parallel',
+    };
+    async function execute(args) {
+        try {
+            if (!args.mode || typeof args.mode !== 'string') {
+                return { success: false, error: 'Missing required "mode" field' };
+            }
+            const input = args;
+            const { mode } = input;
+            switch (mode) {
+                case 'search': return runSearch(input, toolRegistry, roots);
+                case 'recommend': return runRecommend(input, toolRegistry, roots);
+                case 'dependencies': return runDependencies(input, roots);
+                case 'preview': return runPreview(input, roots);
+                case 'content': return runContent(input, roots);
+                default: {
+                    return { success: false, error: `Unknown mode: ${String(mode)}` };
+                }
+            }
+        }
+        catch (err) {
+            const message = summarizeError(err);
+            logger.debug('registry tool: unexpected error', { error: message });
+            return { success: false, error: `Unexpected error: ${message}` };
+        }
+    }
+    return { definition, execute };
+}
+// ---------------------------------------------------------------------------
+// Mode handlers
+// ---------------------------------------------------------------------------
+function runSearch(input, toolRegistry, roots) {
+    const query = input.query ?? '';
+    const typeFilter = input.type ?? 'all';
+    const matches = [];
+    if (typeFilter === 'skills' || typeFilter === 'all') {
+        for (const dir of getSkillDirs(roots)) {
+            matches.push(...scanDirectory(dir, 'skill', query));
+        }
+    }
+    if (typeFilter === 'agents' || typeFilter === 'all') {
+        for (const dir of getAgentDirs(roots)) {
+            matches.push(...scanDirectory(dir, 'agent', query));
+        }
+    }
+    if (typeFilter === 'tools' || typeFilter === 'all') {
+        const allTools = toolRegistry.list().map((t) => ({
+            name: t.definition.name,
+            type: 'tool',
+            description: t.definition.description,
+            path: '',
+        }));
+        const filtered = query ? fuzzyFilter(allTools, query) : allTools;
+        matches.push(...filtered);
+    }
+    // Deduplicate: project-local entries override global (first seen wins)
+    const seen = new Set();
+    const deduped = matches.filter((r) => {
+        const key = `${r.type}:${r.name}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+    return Promise.resolve({
+        success: true,
+        output: JSON.stringify({
+            mode: 'search',
+            query,
+            count: deduped.length,
+            results: deduped,
+        }),
+    });
+}
+function runRecommend(input, toolRegistry, roots) {
+    const task = input.task ?? '';
+    const scope = input.scope ?? 'skills';
+    const lowerTask = task.toLowerCase();
+    let candidates;
+    if (scope === 'tools') {
+        candidates = toolRegistry.list().map((t) => ({
+            name: t.definition.name,
+            type: 'tool',
+            description: t.definition.description,
+            path: '',
+        }));
+    }
+    else {
+        candidates = [];
+        for (const dir of getSkillDirs(roots)) {
+            candidates.push(...scanDirectoryAll(dir, 'skill'));
+        }
+        // Deduplicate: project-local entries override global (first seen wins)
+        const seen = new Set();
+        candidates = candidates.filter((r) => {
+            const key = `${r.type}:${r.name}`;
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+    }
+    // Use Fuse.js for fuzzy scoring when task is given; otherwise sort alphabetically
+    let sorted;
+    if (task) {
+        sorted = fuzzyFilter(candidates, task);
+        // For items not matched by fuzzy (below threshold), append alphabetically
+        const matchedNames = new Set(sorted.map((r) => `${r.type}:${r.name}`));
+        const unmatched = candidates
+            .filter((c) => !matchedNames.has(`${c.type}:${c.name}`))
+            .sort((a, b) => a.name.localeCompare(b.name));
+        sorted = [...sorted, ...unmatched];
+    }
+    else {
+        // No task — fall back to simple word-overlap scoring.
+        const lowerTask2 = lowerTask; // already empty string
+        const taskWords = lowerTask2.split(/\s+/).filter(Boolean);
+        const scored = candidates.map((item) => {
+            const target = `${item.name} ${item.description}`.toLowerCase();
+            const score = taskWords.reduce((acc, word) => acc + (target.includes(word) ? 1 : 0), 0);
+            return { ...item, score };
+        });
+        scored.sort((a, b) => b.score - a.score || a.name.localeCompare(b.name));
+        sorted = scored;
+    }
+    return Promise.resolve({
+        success: true,
+        output: JSON.stringify({
+            mode: 'recommend',
+            task,
+            scope,
+            count: sorted.length,
+            results: sorted.map(({ score: _score, ...item }) => {
+                // strip internal score if present (from fallback path)
+                const { score: _s, ...rest } = { score: undefined, ...item };
+                void _s;
+                return rest;
+            }),
+        }),
+    });
+}
+function runDependencies(input, roots) {
+    const skillName = input.skillName;
+    if (!skillName) {
+        return Promise.resolve({
+            success: false,
+            error: 'mode "dependencies" requires "skillName"',
+        });
+    }
+    let filePath = null;
+    for (const dir of getSkillDirs(roots)) {
+        const candidate = join(dir, `${skillName}.md`);
+        if (existsSync(candidate)) {
+            filePath = candidate;
+            break;
+        }
+        // Also try exact match without .md appended (caller may have included extension)
+        const candidateExact = join(dir, skillName);
+        if (existsSync(candidateExact)) {
+            filePath = candidateExact;
+            break;
+        }
+    }
+    if (!filePath) {
+        return Promise.resolve({
+            success: false,
+            error: `Skill not found: ${skillName}`,
+        });
+    }
+    let content;
+    try {
+        content = readFileSync(filePath, 'utf-8');
+    }
+    catch (err) {
+        return Promise.resolve({
+            success: false,
+            error: `Failed to read skill file: ${summarizeError(err)}`,
+        });
+    }
+    const { metadata: frontmatter, body } = parseMarkdownFrontmatter(content);
+    // Parse depends_on: can be a comma-separated string or single name
+    const dependencies = normalizeFrontmatterList(frontmatter['depends_on']);
+    const includes = collectMarkdownReferences(body);
+    return Promise.resolve({
+        success: true,
+        output: JSON.stringify({
+            mode: 'dependencies',
+            skillName,
+            path: filePath,
+            depends_on: dependencies,
+            includes,
+        }),
+    });
+}
+function runPreview(input, roots) {
+    const resolvedPath = resolveRegistryPath(input.path, roots);
+    if (!resolvedPath.ok)
+        return Promise.resolve({ success: false, error: resolvedPath.error });
+    try {
+        const disclosure = readMarkdownDisclosure(resolvedPath.path);
+        return Promise.resolve({
+            success: true,
+            output: JSON.stringify({
+                mode: 'preview',
+                path: disclosure.path,
+                metadata: disclosure.metadata,
+                preview: disclosure.preview,
+                includes: disclosure.includes,
+                sections: disclosure.sections,
+                dependencies: normalizeFrontmatterList(disclosure.metadata['depends_on']),
+            }),
+        });
+    }
+    catch (err) {
+        return Promise.resolve({
+            success: false,
+            error: `Failed to preview file: ${summarizeError(err)}`,
+        });
+    }
+}
+function runContent(input, roots) {
+    const resolvedPath = resolveRegistryPath(input.path, roots);
+    if (!resolvedPath.ok)
+        return Promise.resolve({ success: false, error: resolvedPath.error });
+    return Promise.resolve({
+        success: true,
+        output: JSON.stringify({
+            mode: 'content',
+            path: resolvedPath.path,
+            metadata: readMarkdownDisclosure(resolvedPath.path).metadata,
+            content: materializeMarkdownBody(resolvedPath.path),
+        }),
+    });
+}
+function resolveRegistryPath(path, roots) {
+    if (!path) {
+        return {
+            ok: false,
+            error: 'mode requires "path"',
+        };
+    }
+    const resolvedPath = isAbsolute(path)
+        ? path
+        : resolve(roots.workingDirectory, path);
+    if (!resolvedPath.includes('.goodvibes/')) {
+        return {
+            ok: false,
+            error: 'mode can only read files within .goodvibes/ directories',
+        };
+    }
+    if (!existsSync(resolvedPath)) {
+        return {
+            ok: false,
+            error: `File not found: ${resolvedPath}`,
+        };
+    }
+    return { ok: true, path: resolvedPath };
+}

package/dist/platform/tools/registry-tool/schema.d.ts

@@ -0,0 +1,53 @@
+/**
+ * JSON Schema and TypeScript types for the `registry` tool.
+ */
+export declare const REGISTRY_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly mode: {
+            readonly type: "string";
+            readonly enum: readonly ["search", "recommend", "dependencies", "preview", "content"];
+            readonly description: string;
+        };
+        readonly query: {
+            readonly type: "string";
+            readonly description: "(mode: search) Search term to match against name, description.";
+        };
+        readonly type: {
+            readonly type: "string";
+            readonly enum: readonly ["skills", "agents", "tools", "all"];
+            readonly description: "(mode: search) Filter by item type. Default: \"all\".";
+        };
+        readonly task: {
+            readonly type: "string";
+            readonly description: "(mode: recommend) Task description used for keyword-based relevance sorting.";
+        };
+        readonly scope: {
+            readonly type: "string";
+            readonly enum: readonly ["skills", "tools"];
+            readonly description: "(mode: recommend) Whether to recommend skills or tools. Default: \"skills\".";
+        };
+        readonly skillName: {
+            readonly type: "string";
+            readonly description: "(mode: dependencies) Name of the skill to inspect for dependencies.";
+        };
+        readonly path: {
+            readonly type: "string";
+            readonly description: "(mode: preview/content) Absolute or relative path to a skill/agent markdown file.";
+        };
+    };
+    readonly required: readonly ["mode"];
+};
+/** Valid operation modes for the registry tool. */
+export type RegistryMode = 'search' | 'recommend' | 'dependencies' | 'preview' | 'content';
+/** Full input shape for the registry tool. */
+export interface RegistryInput {
+    mode: RegistryMode;
+    query?: string;
+    type?: 'skills' | 'agents' | 'tools' | 'all';
+    task?: string;
+    scope?: 'skills' | 'tools';
+    skillName?: string;
+    path?: string;
+}
+//# sourceMappingURL=schema.d.ts.map

package/dist/platform/tools/registry-tool/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/platform/tools/registry-tool/schema.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2CvB,CAAC;AAEX,mDAAmD;AACnD,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,WAAW,GAAG,cAAc,GAAG,SAAS,GAAG,SAAS,CAAC;AAE3F,8CAA8C;AAC9C,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,YAAY,CAAC;IAGnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,OAAO,GAAG,KAAK,CAAC;IAG7C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC;IAG3B,SAAS,CAAC,EAAE,MAAM,CAAC;IAGnB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf"}

package/dist/platform/tools/registry-tool/schema.js

@@ -0,0 +1,46 @@
+/**
+ * JSON Schema and TypeScript types for the `registry` tool.
+ */
+export const REGISTRY_TOOL_SCHEMA = {
+    type: 'object',
+    properties: {
+        mode: {
+            type: 'string',
+            enum: ['search', 'recommend', 'dependencies', 'preview', 'content'],
+            description: 'Operation mode: search finds skills/agents/tools by query;'
+                + ' recommend lists items sorted by relevance to a task;'
+                + ' dependencies reads a skill\'s depends_on;'
+                + ' preview returns metadata, references, and preview text without materializing linked content;'
+                + ' content returns the materialized markdown body and parsed metadata.'
+                + ' Discovery: use mode=search with no query to list all available items;'
+                + ' use mode=search type=skills to list skills, type=agents for agents, type=tools for tools.',
+        },
+        query: {
+            type: 'string',
+            description: '(mode: search) Search term to match against name, description.',
+        },
+        type: {
+            type: 'string',
+            enum: ['skills', 'agents', 'tools', 'all'],
+            description: '(mode: search) Filter by item type. Default: "all".',
+        },
+        task: {
+            type: 'string',
+            description: '(mode: recommend) Task description used for keyword-based relevance sorting.',
+        },
+        scope: {
+            type: 'string',
+            enum: ['skills', 'tools'],
+            description: '(mode: recommend) Whether to recommend skills or tools. Default: "skills".',
+        },
+        skillName: {
+            type: 'string',
+            description: '(mode: dependencies) Name of the skill to inspect for dependencies.',
+        },
+        path: {
+            type: 'string',
+            description: '(mode: preview/content) Absolute or relative path to a skill/agent markdown file.',
+        },
+    },
+    required: ['mode'],
+};

package/dist/platform/tools/registry-tool/skill-loader.d.ts

@@ -0,0 +1,10 @@
+export interface SkillLoaderRoots {
+    readonly workingDirectory: string;
+    readonly homeDirectory?: string;
+}
+/**
+ * Find a skill whose triggers include the given input string.
+ * Returns the skill body (markdown content to inject as prompt), or null.
+ */
+export declare function loadSkillByTrigger(input: string, roots: SkillLoaderRoots): string | null;
+//# sourceMappingURL=skill-loader.d.ts.map

package/dist/platform/tools/registry-tool/skill-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-loader.d.ts","sourceRoot":"","sources":["../../../../src/platform/tools/registry-tool/skill-loader.ts"],"names":[],"mappings":"AAcA,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CACjC;AAgBD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,gBAAgB,GAAG,MAAM,GAAG,IAAI,CAuDxF"}

package/dist/platform/tools/registry-tool/skill-loader.js

@@ -0,0 +1,73 @@
+/**
+ * Skill loader — finds and loads skills by trigger match.
+ *
+ * Scans skill directories for SKILL.md files with trigger frontmatter.
+ * Returns the skill body (system prompt) if a matching trigger is found.
+ */
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { materializeMarkdownBody, parseMarkdownFrontmatter, normalizeFrontmatterList, } from '../../utils/markdown-disclosure.js';
+function getSkillDirs(roots) {
+    const dirs = [
+        join(roots.workingDirectory, '.goodvibes', 'skills'),
+        join(roots.workingDirectory, '.goodvibes', 'sdk', 'skills'),
+    ];
+    if (roots.homeDirectory) {
+        dirs.push(join(roots.homeDirectory, '.goodvibes', 'skills'), join(roots.homeDirectory, '.goodvibes', 'sdk', 'skills'));
+    }
+    return dirs;
+}
+/**
+ * Find a skill whose triggers include the given input string.
+ * Returns the skill body (markdown content to inject as prompt), or null.
+ */
+export function loadSkillByTrigger(input, roots) {
+    const normalizedInput = input.toLowerCase().trim();
+    for (const dir of getSkillDirs(roots)) {
+        if (!existsSync(dir))
+            continue;
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            // Check for directory-based skill: entry/SKILL.md
+            const skillPath = join(dir, entry, 'SKILL.md');
+            // Also check flat file: entry.md
+            const flatPath = join(dir, entry);
+            let content = null;
+            let filePath = null;
+            if (existsSync(skillPath)) {
+                filePath = skillPath;
+            }
+            else if (entry.endsWith('.md') && existsSync(flatPath)) {
+                filePath = flatPath;
+            }
+            if (!filePath)
+                continue;
+            try {
+                content = readFileSync(filePath, 'utf-8');
+            }
+            catch {
+                continue;
+            }
+            const { metadata: frontmatter, body } = parseMarkdownFrontmatter(content);
+            const name = typeof frontmatter.name === 'string' ? frontmatter.name : undefined;
+            const triggers = normalizeFrontmatterList(frontmatter.triggers);
+            // Check triggers
+            for (const trigger of triggers) {
+                if (trigger.toLowerCase().trim() === normalizedInput) {
+                    return materializeMarkdownBody(filePath, body);
+                }
+            }
+            // Also match by name: /skill-name
+            if (name && `/${name}`.toLowerCase() === normalizedInput) {
+                return materializeMarkdownBody(filePath, body);
+            }
+        }
+    }
+    return null;
+}

package/dist/platform/tools/registry.d.ts

@@ -0,0 +1,51 @@
+import type { Tool, ToolDefinition, ToolResult } from '../types/tools.js';
+import type { ContractVerificationResult, ContractVerifierOptions } from '../runtime/tools/contract-verifier.js';
+/**
+ * ToolRegistry - Central registry for all tools available to the LLM.
+ * Manages registration, discovery, and execution of tools.
+ */
+export declare class ToolRegistry {
+    private tools;
+    /** Register a tool. Throws if a tool with the same name is already registered. */
+    register(tool: Tool): void;
+    /**
+     * Register a tool after running contract verification.
+     *
+     * If verification finds error-level violations the tool is NOT registered
+     * and an error is thrown listing all violations. This implements "fail closed"
+     * semantics: invalid tools cannot enter the registry.
+     *
+     * Warn-level violations are collected and returned so callers can surface them
+     * without blocking registration.
+     *
+     * @param tool    - The tool to register.
+     * @param opts    - Optional verifier options (strictness overrides).
+     * @returns The full ContractVerificationResult so callers can inspect warnings.
+     * @throws If the tool has any error-level contract violations.
+     */
+    registerWithContract(tool: Tool, opts?: ContractVerifierOptions): ContractVerificationResult;
+    /**
+     * Run contract verification on a single registered tool without re-registering.
+     *
+     * @param name - The tool name to verify.
+     * @param opts - Optional verifier options.
+     * @returns The verification result, or undefined if the tool is not registered.
+     */
+    verifyContract(name: string, opts?: ContractVerifierOptions): ContractVerificationResult | undefined;
+    /**
+     * Run contract verification on all registered tools.
+     *
+     * @param opts - Optional verifier options.
+     * @returns Map of tool name → ContractVerificationResult for every registered tool.
+     */
+    verifyAllContracts(opts?: ContractVerifierOptions): Map<string, ContractVerificationResult>;
+    /** Returns the ToolDefinition array formatted for LLM function calling. */
+    getToolDefinitions(): ToolDefinition[];
+    /** Execute a named tool with the given arguments. Wraps errors in ToolResult. */
+    execute(callId: string, name: string, args: Record<string, unknown>): Promise<ToolResult>;
+    /** Returns true if a tool with the given name is registered. */
+    has(name: string): boolean;
+    /** Returns all registered tools. */
+    list(): Tool[];
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/platform/tools/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/platform/tools/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAI1E,OAAO,KAAK,EAAE,0BAA0B,EAAE,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAGjH;;;GAGG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,KAAK,CAA2B;IAExC,kFAAkF;IAClF,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAO1B;;;;;;;;;;;;;;OAcG;IACH,oBAAoB,CAClB,IAAI,EAAE,IAAI,EACV,IAAI,CAAC,EAAE,uBAAuB,GAC7B,0BAA0B;IAiB7B;;;;;;OAMG;IACH,cAAc,CACZ,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE,uBAAuB,GAC7B,0BAA0B,GAAG,SAAS;IAOzC;;;;;OAKG;IACH,kBAAkB,CAChB,IAAI,CAAC,EAAE,uBAAuB,GAC7B,GAAG,CAAC,MAAM,EAAE,0BAA0B,CAAC;IAK1C,2EAA2E;IAC3E,kBAAkB,IAAI,cAAc,EAAE;IAItC,iFAAiF;IAC3E,OAAO,CACX,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,OAAO,CAAC,UAAU,CAAC;IAuCtB,gEAAgE;IAChE,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B,oCAAoC;IACpC,IAAI,IAAI,IAAI,EAAE;CAGf"}