@amalgm/tools 0.1.0

package/dist/process.js

@@ -0,0 +1,46 @@
+import { spawn } from 'node:child_process';
+function runCommand(input) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(input.command, input.args, {
+            cwd: input.cwd || process.cwd(), env: input.env,
+            shell: false, windowsHide: true, stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        let stdout = Buffer.alloc(0);
+        let stderr = Buffer.alloc(0);
+        let timedOut = false;
+        let aborted = false;
+        let truncated = false;
+        const append = (current, chunk) => {
+            const room = Math.max(0, input.maximumBytes - stdout.length - stderr.length);
+            if (chunk.length > room)
+                truncated = true;
+            return room > 0 ? Buffer.concat([current, chunk.subarray(0, room)]) : current;
+        };
+        child.stdout.on('data', (chunk) => { stdout = append(stdout, chunk); });
+        child.stderr.on('data', (chunk) => { stderr = append(stderr, chunk); });
+        child.on('error', reject);
+        const stop = () => child.kill('SIGTERM');
+        let forceTimer;
+        const terminate = () => {
+            stop();
+            forceTimer = setTimeout(() => child.kill('SIGKILL'), 1_000);
+            forceTimer.unref();
+        };
+        const timer = setTimeout(() => { timedOut = true; terminate(); }, input.timeoutMs);
+        timer.unref();
+        const abort = () => { aborted = true; terminate(); };
+        input.signal?.addEventListener('abort', abort, { once: true });
+        child.on('close', (code, signal) => {
+            clearTimeout(timer);
+            if (forceTimer)
+                clearTimeout(forceTimer);
+            input.signal?.removeEventListener('abort', abort);
+            resolve({
+                code, signal, timedOut, aborted, truncated,
+                stdout: stdout.toString('utf8'), stderr: stderr.toString('utf8'),
+            });
+        });
+        child.stdin.end(input.stdin);
+    });
+}
+export { runCommand };

package/dist/query.d.ts

@@ -0,0 +1,23 @@
+import type { Catalog, LoadoutInput, ToolQuery, ToolRecord } from './types.js';
+interface QueryPort {
+    catalog(): Catalog;
+    hasDriver(tool: ToolRecord): boolean;
+}
+declare function matches(tool: ToolRecord, filters: ToolQuery): boolean;
+declare function queryTools(port: QueryPort, filters?: ToolQuery): {
+    tool: ToolRecord;
+    actions: import("./types.js").ActionRecord[];
+}[];
+declare function callableActions(port: QueryPort, loadout?: LoadoutInput, filters?: ToolQuery): {
+    tool: ToolRecord;
+    action: import("./types.js").ActionRecord;
+}[];
+declare function resolveAction(port: QueryPort, toolId: string, actionReference: string, loadout?: LoadoutInput): {
+    tool: ToolRecord;
+    action: import("./types.js").ActionRecord;
+} | null;
+declare function resolveCallableAction(port: QueryPort, toolId: string, actionReference: string, loadout?: LoadoutInput, filters?: ToolQuery): {
+    tool: ToolRecord;
+    action: import("./types.js").ActionRecord;
+} | null;
+export { callableActions, matches, queryTools, resolveAction, resolveCallableAction };

package/dist/query.js

@@ -0,0 +1,36 @@
+import { id } from './ids.js';
+import { findSelected, selected } from './selection.js';
+function matches(tool, filters) {
+    return (filters.type === undefined || tool.source.type === filters.type)
+        && (filters.owner === undefined || tool.owner === filters.owner)
+        && (filters.origin === undefined || tool.origin === filters.origin)
+        && (filters.origins === undefined || filters.origins.includes(tool.origin))
+        && (filters.status === undefined || tool.status === filters.status);
+}
+function queryTools(port, filters = {}) {
+    const catalog = port.catalog();
+    return catalog.tools
+        .filter((tool) => matches(tool, filters))
+        .map((tool) => ({
+        tool,
+        actions: catalog.actions.filter((action) => action.toolId === tool.id),
+    }));
+}
+function callableActions(port, loadout, filters = {}) {
+    return selected(port.catalog(), loadout)
+        .filter(({ tool }) => port.hasDriver(tool))
+        .filter(({ tool }) => matches(tool, filters));
+}
+function resolveAction(port, toolId, actionReference, loadout) {
+    const owner = id(toolId, 'tool id');
+    const reference = id(actionReference, 'action reference');
+    const actionId = reference.startsWith(`${owner}.`) ? reference : `${owner}.${reference}`;
+    return findSelected(port.catalog(), actionId, loadout);
+}
+function resolveCallableAction(port, toolId, actionReference, loadout, filters = {}) {
+    const resolved = resolveAction(port, toolId, actionReference, loadout);
+    return resolved && port.hasDriver(resolved.tool) && matches(resolved.tool, filters)
+        ? resolved
+        : null;
+}
+export { callableActions, matches, queryTools, resolveAction, resolveCallableAction };

package/dist/results.d.ts

@@ -0,0 +1,6 @@
+import type { ToolResult } from './types.js';
+declare function textResult(value: unknown): ToolResult;
+declare function structuredResult(value: unknown): ToolResult;
+declare function errorResult(value: unknown): ToolResult;
+declare function boundedResult(result: ToolResult, maximum: number): ToolResult;
+export { boundedResult, errorResult, structuredResult, textResult };

package/dist/results.js

@@ -0,0 +1,27 @@
+function textResult(value) {
+    const text = typeof value === 'string' ? value : JSON.stringify(value, null, 2);
+    return { content: [{ type: 'text', text }] };
+}
+function structuredResult(value) {
+    return { ...textResult(value), structuredContent: value };
+}
+function errorResult(value) {
+    return { ...textResult(value instanceof Error ? value.message : value), isError: true };
+}
+function boundedResult(result, maximum) {
+    let remaining = Math.max(0, maximum);
+    let truncated = false;
+    const content = result.content.map((item) => {
+        const bytes = Buffer.from(item.text);
+        if (bytes.length <= remaining) {
+            remaining -= bytes.length;
+            return item;
+        }
+        truncated = true;
+        const text = bytes.subarray(0, remaining).toString('utf8');
+        remaining = 0;
+        return { ...item, text: `${text}\n[output truncated]` };
+    });
+    return { ...result, content, ...(truncated ? { truncated: true } : {}) };
+}
+export { boundedResult, errorResult, structuredResult, textResult };

package/dist/schema.d.ts

@@ -0,0 +1,3 @@
+import type Database from 'better-sqlite3';
+declare function migrate(db: Database.Database): void;
+export { migrate };

package/dist/schema.js

@@ -0,0 +1,26 @@
+function migrate(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS metadata (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+    INSERT OR IGNORE INTO metadata (key, value) VALUES ('revision', '0');
+
+    CREATE TABLE IF NOT EXISTS tools (
+      id TEXT PRIMARY KEY,
+      origin TEXT NOT NULL,
+      status TEXT NOT NULL,
+      record_json TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS actions (
+      id TEXT PRIMARY KEY,
+      tool_id TEXT NOT NULL REFERENCES tools(id) ON DELETE CASCADE,
+      status TEXT NOT NULL,
+      record_json TEXT NOT NULL,
+      UNIQUE(tool_id, id)
+    );
+    CREATE INDEX IF NOT EXISTS actions_tool_id ON actions(tool_id);
+  `);
+}
+export { migrate };

package/dist/secrets.d.ts

@@ -0,0 +1,3 @@
+import type { SecretResolver } from './types.js';
+declare function resolveReferences(references: Record<string, string> | undefined, resolver: SecretResolver | undefined): Promise<Record<string, string>>;
+export { resolveReferences };

package/dist/secrets.js

@@ -0,0 +1,13 @@
+async function resolveReferences(references, resolver) {
+    const resolved = {};
+    for (const [name, reference] of Object.entries(references || {})) {
+        if (!resolver)
+            throw new Error(`Secret resolver is required for ${reference}`);
+        const value = await resolver(reference);
+        if (value === undefined)
+            throw new Error(`Secret not found: ${reference}`);
+        resolved[name] = value;
+    }
+    return resolved;
+}
+export { resolveReferences };

package/dist/selection.d.ts

@@ -0,0 +1,10 @@
+import type { ActionRecord, Catalog, LoadoutInput, ToolRecord } from './types.js';
+declare function selected(catalog: Catalog, loadout?: LoadoutInput): Array<{
+    tool: ToolRecord;
+    action: ActionRecord;
+}>;
+declare function findSelected(catalog: Catalog, actionId: string, loadout?: LoadoutInput): {
+    tool: ToolRecord;
+    action: ActionRecord;
+} | null;
+export { findSelected, selected };

package/dist/selection.js

@@ -0,0 +1,18 @@
+function selected(catalog, loadout) {
+    const ids = loadout === undefined
+        ? null
+        : new Set(Array.isArray(loadout) ? loadout : loadout.toolIds);
+    const tools = new Map(catalog.tools.map((tool) => [tool.id, tool]));
+    return catalog.actions.flatMap((action) => {
+        const tool = tools.get(action.toolId);
+        if (!tool || tool.status !== 'enabled' || action.status !== 'enabled')
+            return [];
+        if (ids && !ids.has(tool.id) && !ids.has(action.id))
+            return [];
+        return [{ tool, action }];
+    });
+}
+function findSelected(catalog, actionId, loadout) {
+    return selected(catalog, loadout).find(({ action }) => action.id === actionId) || null;
+}
+export { findSelected, selected };

package/dist/store.d.ts

@@ -0,0 +1,17 @@
+import Database from 'better-sqlite3';
+import type { ActionRecord, ApplyResult, Catalog, Status, ToolRecord } from './types.js';
+declare class Store {
+    readonly db: Database.Database;
+    constructor(file: string);
+    revision(): number;
+    private bump;
+    getTool(id: string): ToolRecord | null;
+    getAction(id: string): ActionRecord | null;
+    actionsFor(toolId: string): ActionRecord[];
+    catalog(): Catalog;
+    apply(result: ApplyResult): ApplyResult;
+    setStatus(id: string, status: Status, now: string): ToolRecord | ActionRecord | null;
+    remove(id: string): ToolRecord | ActionRecord | null;
+    close(): void;
+}
+export { Store };

package/dist/store.js

@@ -0,0 +1,96 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import Database from 'better-sqlite3';
+import { migrate } from './schema.js';
+function parse(row) {
+    return row ? JSON.parse(row.record_json) : null;
+}
+class Store {
+    db;
+    constructor(file) {
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        this.db = new Database(file);
+        this.db.pragma('journal_mode = WAL');
+        this.db.pragma('foreign_keys = ON');
+        this.db.pragma('busy_timeout = 5000');
+        migrate(this.db);
+    }
+    revision() {
+        const row = this.db.prepare("SELECT value FROM metadata WHERE key = 'revision'").get();
+        return Number(row.value);
+    }
+    bump() {
+        this.db.prepare("UPDATE metadata SET value = CAST(value AS INTEGER) + 1 WHERE key = 'revision'").run();
+    }
+    getTool(id) {
+        return parse(this.db.prepare('SELECT record_json FROM tools WHERE id = ?').get(id));
+    }
+    getAction(id) {
+        return parse(this.db.prepare('SELECT record_json FROM actions WHERE id = ?').get(id));
+    }
+    actionsFor(toolId) {
+        return this.db.prepare('SELECT record_json FROM actions WHERE tool_id = ? ORDER BY id')
+            .all(toolId).map((row) => parse(row)).filter(Boolean);
+    }
+    catalog() {
+        const tools = this.db.prepare('SELECT record_json FROM tools ORDER BY id')
+            .all().map((row) => parse(row)).filter(Boolean);
+        const actions = this.db.prepare('SELECT record_json FROM actions ORDER BY id')
+            .all().map((row) => parse(row)).filter(Boolean);
+        return { version: 1, revision: this.revision(), tools, actions };
+    }
+    apply(result) {
+        this.db.transaction(() => {
+            this.db.prepare(`
+        INSERT INTO tools (id, origin, status, record_json)
+        VALUES (@id, @origin, @status, @json)
+        ON CONFLICT(id) DO UPDATE SET
+          origin = excluded.origin, status = excluded.status, record_json = excluded.record_json
+      `).run({ id: result.tool.id, origin: result.tool.origin, status: result.tool.status, json: JSON.stringify(result.tool) });
+            this.db.prepare('DELETE FROM actions WHERE tool_id = ?').run(result.tool.id);
+            const insert = this.db.prepare('INSERT INTO actions (id, tool_id, status, record_json) VALUES (?, ?, ?, ?)');
+            for (const action of result.actions)
+                insert.run(action.id, action.toolId, action.status, JSON.stringify(action));
+            this.bump();
+        })();
+        return result;
+    }
+    setStatus(id, status, now) {
+        return this.db.transaction(() => {
+            const tool = this.getTool(id);
+            if (tool) {
+                const updated = { ...tool, status, updatedAt: now };
+                this.db.prepare('UPDATE tools SET status = ?, record_json = ? WHERE id = ?')
+                    .run(status, JSON.stringify(updated), id);
+                this.bump();
+                return updated;
+            }
+            const action = this.getAction(id);
+            if (!action)
+                return null;
+            const updated = { ...action, status, updatedAt: now };
+            this.db.prepare('UPDATE actions SET status = ?, record_json = ? WHERE id = ?')
+                .run(status, JSON.stringify(updated), id);
+            this.bump();
+            return updated;
+        })();
+    }
+    remove(id) {
+        return this.db.transaction(() => {
+            const tool = this.getTool(id);
+            if (tool) {
+                this.db.prepare('DELETE FROM tools WHERE id = ?').run(id);
+                this.bump();
+                return tool;
+            }
+            const action = this.getAction(id);
+            if (!action)
+                return null;
+            this.db.prepare('DELETE FROM actions WHERE id = ?').run(id);
+            this.bump();
+            return action;
+        })();
+    }
+    close() { this.db.close(); }
+}
+export { Store };

package/dist/toolbox.d.ts

@@ -0,0 +1,46 @@
+import type { ActionDefinition, ActionPatch, ActionRecord, ApplyResult, CallOptions, Catalog, LoadoutInput, ToolDefinition, ToolboxOptions, ToolPatch, ToolQuery, ToolRecord, ToolResult } from './types.js';
+declare class Toolbox {
+    private readonly store;
+    private readonly artifacts;
+    private readonly system;
+    private readonly drivers;
+    private readonly onChange?;
+    constructor(options?: ToolboxOptions);
+    catalog(): Catalog;
+    list(loadout?: LoadoutInput): Array<{
+        tool: ToolRecord;
+        actions: ActionRecord[];
+    }>;
+    query(filters?: ToolQuery): {
+        tool: ToolRecord;
+        actions: ActionRecord[];
+    }[];
+    callable(loadout?: LoadoutInput, filters?: ToolQuery): {
+        tool: ToolRecord;
+        action: ActionRecord;
+    }[];
+    get(toolId: string): ApplyResult | null;
+    action(actionId: string): ActionRecord | null;
+    resolve(toolId: string, actionReference: string, loadout?: LoadoutInput): {
+        tool: ToolRecord;
+        action: ActionRecord;
+    } | null;
+    resolveCallable(toolId: string, actionReference: string, loadout?: LoadoutInput, filters?: ToolQuery): {
+        tool: ToolRecord;
+        action: ActionRecord;
+    } | null;
+    apply(definition: ToolDefinition): Promise<ApplyResult>;
+    update(toolId: string, patch: ToolPatch): Promise<ApplyResult>;
+    upsertAction(toolId: string, definition: ActionDefinition): Promise<ActionRecord>;
+    updateAction(actionId: string, patch: ActionPatch): Promise<ActionRecord>;
+    setStatus(recordId: string, status: 'enabled' | 'disabled'): Promise<ToolRecord | ActionRecord>;
+    remove(recordId: string): Promise<ToolRecord | ActionRecord>;
+    connections(loadout?: LoadoutInput): ToolRecord[];
+    call(actionId: string, input?: unknown, options?: CallOptions): Promise<ToolResult>;
+    hasDriver(tool: ToolRecord): boolean;
+    callMcp(name: string, input?: unknown, options?: CallOptions): Promise<ToolResult>;
+    private changed;
+    private driverFor;
+    close(): void;
+}
+export { Toolbox };

package/dist/toolbox.js

@@ -0,0 +1,204 @@
+import os from 'node:os';
+import path from 'node:path';
+import { resolveProductStateDir } from '@amalgm/core/identity';
+import { apiDriver } from './api-driver.js';
+import { ArtifactFiles } from './artifact-files.js';
+import { cliDriver } from './cli-driver.js';
+import { normalizeDefinition } from './definition.js';
+import { assertMcpNamesUnique, id, mcpName } from './ids.js';
+import { validateInput } from './input.js';
+import { callableActions, queryTools, resolveAction, resolveCallableAction } from './query.js';
+import { findSelected, selected } from './selection.js';
+import { Store } from './store.js';
+import { updateAction, updateTool, upsertAction } from './updates.js';
+function semantic(value) {
+    const { createdAt, updatedAt, ...record } = value;
+    return JSON.stringify(record);
+}
+function defaultDatabase(options) {
+    if (options.databaseFile)
+        return path.resolve(options.databaseFile);
+    // The state-dir LAW lives in @amalgm/core; only the effectful reads
+    // (process.env, os.homedir) happen here at the construction boundary.
+    // Precedence: AMALGM_TOOLS_DIR, then AMALGM_DIR/toolbox, then the
+    // scoped layout <home>/.amalgm/users/<scope>/toolbox.
+    const state = options.stateDir || resolveProductStateDir({
+        product: 'tools',
+        primitive: 'toolbox',
+        env: process.env,
+        homedir: path.join(os.homedir(), '.amalgm'),
+    });
+    return path.join(path.resolve(state), 'tools.db');
+}
+class Toolbox {
+    store;
+    artifacts;
+    system;
+    drivers = new Map();
+    onChange;
+    constructor(options = {}) {
+        const databaseFile = defaultDatabase(options);
+        this.store = new Store(databaseFile);
+        this.artifacts = new ArtifactFiles(path.dirname(databaseFile));
+        this.onChange = options.onChange;
+        for (const driver of [cliDriver, apiDriver, ...(options.drivers || [])])
+            this.drivers.set(driver.type, driver);
+        const tools = [];
+        const actions = [];
+        for (const definition of options.systemTools || []) {
+            const normalized = normalizeDefinition({ ...definition, origin: 'system' });
+            if (tools.some((tool) => tool.id === normalized.tool.id))
+                throw new Error(`Duplicate system tool: ${normalized.tool.id}`);
+            tools.push(normalized.tool);
+            actions.push(...normalized.actions);
+        }
+        assertMcpNamesUnique(actions);
+        this.system = { version: 1, revision: 0, tools, actions };
+        this.artifacts.migrateLegacy();
+        this.artifacts.materialize(this.catalog());
+    }
+    catalog() {
+        const persisted = this.store.catalog();
+        const systemIds = new Set(this.system.tools.map((tool) => tool.id));
+        const userTools = persisted.tools.filter((tool) => !systemIds.has(tool.id));
+        const userActions = persisted.actions.filter((action) => !systemIds.has(action.toolId));
+        const catalog = {
+            version: 1, revision: persisted.revision,
+            tools: [...this.system.tools, ...userTools].sort((a, b) => a.id.localeCompare(b.id)),
+            actions: [...this.system.actions, ...userActions].sort((a, b) => a.id.localeCompare(b.id)),
+        };
+        assertMcpNamesUnique(catalog.actions);
+        return catalog;
+    }
+    list(loadout) {
+        const catalog = this.catalog();
+        const runnable = selected(catalog, loadout);
+        return catalog.tools.flatMap((tool) => {
+            const actions = runnable.filter((item) => item.tool.id === tool.id).map((item) => item.action);
+            if (loadout !== undefined && actions.length === 0)
+                return [];
+            return [{ tool, actions }];
+        });
+    }
+    query(filters = {}) { return queryTools(this, filters); }
+    callable(loadout, filters = {}) { return callableActions(this, loadout, filters); }
+    get(toolId) {
+        const value = id(toolId, 'tool id');
+        const catalog = this.catalog();
+        const tool = catalog.tools.find((candidate) => candidate.id === value);
+        return tool ? { tool, actions: catalog.actions.filter((action) => action.toolId === value) } : null;
+    }
+    action(actionId) {
+        const value = id(actionId, 'action id');
+        return this.catalog().actions.find((action) => action.id === value) || null;
+    }
+    resolve(toolId, actionReference, loadout) {
+        return resolveAction(this, toolId, actionReference, loadout);
+    }
+    resolveCallable(toolId, actionReference, loadout, filters = {}) {
+        return resolveCallableAction(this, toolId, actionReference, loadout, filters);
+    }
+    async apply(definition) {
+        const normalizedId = id(definition.id, 'tool.id', 64);
+        if (definition.origin === 'system')
+            throw new Error('System tools can only be supplied by the embedder');
+        if (this.system.tools.some((tool) => tool.id === normalizedId))
+            throw new Error(`System tool is immutable: ${normalizedId}`);
+        const existing = this.store.getTool(normalizedId);
+        const oldActions = new Map(this.store.actionsFor(normalizedId).map((action) => [action.id, action]));
+        const normalized = normalizeDefinition(definition, existing || undefined);
+        normalized.actions = normalized.actions.map((action) => ({
+            ...action, createdAt: oldActions.get(action.id)?.createdAt || action.createdAt,
+        }));
+        const candidateActions = [
+            ...this.system.actions,
+            ...this.store.catalog().actions.filter((action) => action.toolId !== normalized.tool.id),
+            ...normalized.actions,
+        ];
+        assertMcpNamesUnique(candidateActions);
+        const unchanged = existing && semantic(existing) === semantic(normalized.tool)
+            && normalized.actions.length === oldActions.size
+            && normalized.actions.every((action) => semantic(action) === semantic(oldActions.get(action.id)));
+        if (unchanged)
+            return { tool: existing, actions: [...oldActions.values()].sort((a, b) => a.id.localeCompare(b.id)) };
+        const result = this.store.apply(normalized);
+        await this.changed(normalized.tool.id);
+        return result;
+    }
+    async update(toolId, patch) {
+        return updateTool(this, toolId, patch);
+    }
+    async upsertAction(toolId, definition) {
+        return upsertAction(this, toolId, definition);
+    }
+    async updateAction(actionId, patch) {
+        return updateAction(this, actionId, patch);
+    }
+    async setStatus(recordId, status) {
+        const value = id(recordId, 'record id');
+        if (this.system.tools.some((tool) => tool.id === value)
+            || this.system.actions.some((action) => action.id === value))
+            throw new Error(`System record is immutable: ${value}`);
+        const updated = this.store.setStatus(value, status, new Date().toISOString());
+        if (!updated)
+            throw new Error(`Unknown tool or action: ${value}`);
+        await this.changed('toolId' in updated ? updated.toolId : updated.id);
+        return updated;
+    }
+    async remove(recordId) {
+        const value = id(recordId, 'record id');
+        if (this.system.tools.some((tool) => tool.id === value)
+            || this.system.actions.some((action) => action.id === value))
+            throw new Error(`System record is immutable: ${value}`);
+        const removed = this.store.remove(value);
+        if (!removed)
+            throw new Error(`Unknown tool or action: ${value}`);
+        await this.changed('toolId' in removed ? removed.toolId : removed.id);
+        return removed;
+    }
+    connections(loadout) {
+        const catalog = this.catalog();
+        const ids = loadout === undefined ? null : new Set(Array.isArray(loadout) ? loadout : loadout.toolIds);
+        return catalog.tools.filter((tool) => {
+            if (tool.status !== 'enabled' || tool.source.type !== 'mcp' || tool.origin === 'system')
+                return false;
+            if (!ids)
+                return true;
+            return ids.has(tool.id) || catalog.actions.some((action) => action.toolId === tool.id && ids.has(action.id));
+        });
+    }
+    async call(actionId, input = {}, options = {}) {
+        const resolved = findSelected(this.catalog(), id(actionId, 'action id'), options.loadout);
+        if (!resolved)
+            throw new Error(`Action is unavailable: ${actionId}`);
+        const driver = this.driverFor(resolved.tool);
+        if (!driver)
+            throw new Error(`No ${resolved.tool.source.type} driver is configured for ${resolved.tool.id}`);
+        return driver.call({ ...resolved, input: validateInput(resolved.action.inputSchema, input), options });
+    }
+    hasDriver(tool) { return this.driverFor(tool) !== null; }
+    async callMcp(name, input = {}, options = {}) {
+        const resolved = selected(this.catalog(), options.loadout).find(({ action }) => mcpName(action) === name);
+        if (!resolved)
+            throw new Error(`Unknown MCP tool: ${name}`);
+        return this.call(resolved.action.id, input, options);
+    }
+    async changed(toolId) {
+        const catalog = this.catalog();
+        const tool = catalog.tools.find((candidate) => candidate.id === toolId);
+        if (tool && tool.origin !== 'system') {
+            this.artifacts.writeTool({ tool, actions: catalog.actions.filter((action) => action.toolId === toolId) });
+        }
+        else if (!tool) {
+            this.artifacts.removeTool(toolId);
+        }
+        this.artifacts.writeIndex(catalog);
+        await this.onChange?.(catalog);
+    }
+    driverFor(tool) {
+        const driver = this.drivers.get(tool.source.type);
+        return driver && (driver.supports?.(tool) ?? true) ? driver : null;
+    }
+    close() { this.store.close(); }
+}
+export { Toolbox };