@amalgm/tools 0.1.3 → 0.1.4

package/dist/mcp.js

@@ -21,45 +21,57 @@ function managed(definition, handler) {
         },
     };
 }
-function managementTools(toolbox) {
+function managementToolDescriptors() {
     const idProperty = { id: { type: 'string', description: 'Tool or action id' } };
     return [
-        managed({
+        {
             name: 'toolbox_tools_list', description: 'List the canonical Toolbox catalog.',
             inputSchema: { type: 'object', properties: {}, additionalProperties: false },
-        }, () => toolbox.catalog()),
-        managed({
+        },
+        {
             name: 'toolbox_tool_get', description: 'Get one tool and its actions.',
             inputSchema: { type: 'object', properties: idProperty, required: ['id'], additionalProperties: false },
-        }, ({ id }) => {
-            const result = toolbox.get(String(id));
-            if (!result)
-                throw new Error(`Unknown tool: ${id}`);
-            return result;
-        }),
-        managed({
+        },
+        {
             name: 'toolbox_tool_apply', description: 'Atomically apply an authoritative tool definition.',
             inputSchema: {
                 type: 'object', required: ['tool'], additionalProperties: false,
                 properties: { tool: { type: 'object', description: 'Complete tool definition' } },
             },
-        }, ({ tool }) => toolbox.apply(tool)),
-        managed({
+        },
+        {
             name: 'toolbox_record_enable', description: 'Enable one user-owned tool or action.',
             inputSchema: { type: 'object', properties: idProperty, required: ['id'], additionalProperties: false },
-        }, ({ id }) => toolbox.setStatus(String(id), 'enabled')),
-        managed({
+        },
+        {
             name: 'toolbox_record_disable', description: 'Disable one user-owned tool or action.',
             inputSchema: { type: 'object', properties: idProperty, required: ['id'], additionalProperties: false },
-        }, ({ id }) => toolbox.setStatus(String(id), 'disabled')),
-        managed({
+        },
+        {
             name: 'toolbox_record_remove', description: 'Remove one user-owned tool or action.',
             inputSchema: { type: 'object', properties: idProperty, required: ['id'], additionalProperties: false },
-        }, ({ id }) => toolbox.remove(String(id))),
-        managed({
+        },
+        {
             name: 'toolbox_mcp_connections', description: 'List external MCP connections for the composing host.',
             inputSchema: { type: 'object', properties: {}, additionalProperties: false },
-        }, () => toolbox.connections()),
+        },
+    ];
+}
+function managementTools(toolbox) {
+    const [list, get, apply, enable, disable, remove, connections] = managementToolDescriptors();
+    return [
+        managed(list, () => toolbox.catalog()),
+        managed(get, ({ id }) => {
+            const result = toolbox.get(String(id));
+            if (!result)
+                throw new Error(`Unknown tool: ${id}`);
+            return result;
+        }),
+        managed(apply, ({ tool }) => toolbox.apply(tool)),
+        managed(enable, ({ id }) => toolbox.setStatus(String(id), 'enabled')),
+        managed(disable, ({ id }) => toolbox.setStatus(String(id), 'disabled')),
+        managed(remove, ({ id }) => toolbox.remove(String(id))),
+        managed(connections, () => toolbox.connections()),
     ];
 }
 function actionTools(toolbox, options = {}) {
@@ -92,4 +104,4 @@ async function callMcpTool(toolbox, name, input = {}, options = {}) {
         throw new Error(`Unknown tool: ${name}`);
     return tool.handler(input);
 }
-export { actionTools, callMcpTool, createMcpTools, findMcpTool, managementTools, portable, };
+export { actionTools, callMcpTool, createMcpTools, findMcpTool, managementTools, managementToolDescriptors, portable, };

package/dist/notifications.js

@@ -18,11 +18,12 @@ function contextSessionId(value) {
 function notificationToolDefinition() {
     return {
         id: 'notifications',
-        name: 'Notifications',
+        name: 'Channels',
         description: 'Notify the current user about important results, completions, and failures.',
         owner: 'amalgm',
         origin: 'system',
-        source: { type: 'mcp', transport: 'host', serverName: 'notifications' },
+        source: { type: 'mcp', transport: 'host', serverName: 'channels', route: '/mcp/channels' },
+        policy: { firstParty: true },
         actions: [{
                 name: 'notify_user',
                 description: 'Send the current user an email notification. Keep it concise and actionable.',
@@ -91,7 +92,7 @@ function createNotificationsDriver(notifications) {
             return tool.id === 'notifications'
                 && tool.source.type === 'mcp'
                 && tool.source.transport === 'host'
-                && tool.source.serverName === 'notifications';
+                && tool.source.serverName === 'channels';
         },
         async call({ action, input, options }) {
             if (action.id !== 'notifications.notify_user')

package/dist/schema.js

@@ -21,6 +21,21 @@ function migrate(db) {
       UNIQUE(tool_id, id)
     );
     CREATE INDEX IF NOT EXISTS actions_tool_id ON actions(tool_id);
+
+    CREATE TABLE IF NOT EXISTS tool_deployments (
+      id TEXT PRIMARY KEY,
+      tool_id TEXT NOT NULL,
+      previous_deployment_id TEXT,
+      created_at TEXT NOT NULL,
+      record_json TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS tool_deployments_tool_id
+      ON tool_deployments(tool_id, created_at, id);
+
+    CREATE TABLE IF NOT EXISTS tool_heads (
+      tool_id TEXT PRIMARY KEY,
+      deployment_id TEXT NOT NULL REFERENCES tool_deployments(id)
+    );
   `);
 }
 export { migrate };

package/dist/store.d.ts

@@ -1,5 +1,5 @@
 import Database from 'better-sqlite3';
-import type { ActionRecord, ApplyResult, Catalog, Status, ToolRecord } from './types.js';
+import type { ActionRecord, ApplyResult, Catalog, ToolDeployment, ToolDeploymentActivation, ToolDeploymentSnapshot, ToolRecord } from './types.js';
 declare class Store {
     readonly db: Database.Database;
     constructor(file: string);
@@ -8,10 +8,23 @@ declare class Store {
     getTool(id: string): ToolRecord | null;
     getAction(id: string): ActionRecord | null;
     actionsFor(toolId: string): ActionRecord[];
+    heads(): Record<string, string>;
     catalog(): Catalog;
-    apply(result: ApplyResult): ApplyResult;
-    setStatus(id: string, status: Status, now: string): ToolRecord | ActionRecord | null;
-    remove(id: string): ToolRecord | ActionRecord | null;
+    currentDeploymentId(toolId: string): string | null;
+    getDeployment(id: string): ToolDeployment | null;
+    deploymentsFor(toolId: string): ToolDeployment[];
+    allDeployments(): ToolDeployment[];
+    deploymentSnapshot(): ToolDeploymentSnapshot;
+    /** Add a baseline for a pre-deployment database without changing its catalog bytes. */
+    adoptDeployment(activation: ToolDeploymentActivation): void;
+    applyDeployment(activation: ToolDeploymentActivation): {
+        changed: boolean;
+        result: ApplyResult | null;
+    };
+    replaceDeploymentSnapshot(snapshot: ToolDeploymentSnapshot): void;
+    private insertDeployment;
+    private setHead;
+    private materializeDefinition;
     close(): void;
 }
 export { Store };

package/dist/store.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import Database from 'better-sqlite3';
+import { canonicalJson, deploymentRevisionId } from './deployments.js';
 import { migrate } from './schema.js';
 function parse(row) {
     return row ? JSON.parse(row.record_json) : null;
@@ -32,65 +33,128 @@ class Store {
         return this.db.prepare('SELECT record_json FROM actions WHERE tool_id = ? ORDER BY id')
             .all(toolId).map((row) => parse(row)).filter(Boolean);
     }
+    heads() {
+        return Object.fromEntries(this.db.prepare('SELECT tool_id, deployment_id FROM tool_heads ORDER BY tool_id').all()
+            .map((row) => [row.tool_id, row.deployment_id]));
+    }
     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 };
+        const deployments = this.heads();
+        return {
+            version: 1,
+            revision: this.revision(),
+            revisionId: deploymentRevisionId({ heads: deployments }),
+            deployments,
+            tools,
+            actions,
+        };
+    }
+    currentDeploymentId(toolId) {
+        const row = this.db.prepare('SELECT deployment_id FROM tool_heads WHERE tool_id = ?').get(toolId);
+        return row?.deployment_id || null;
+    }
+    getDeployment(id) {
+        return parse(this.db.prepare('SELECT record_json FROM tool_deployments WHERE id = ?').get(id));
+    }
+    deploymentsFor(toolId) {
+        return this.db.prepare(`
+      SELECT record_json FROM tool_deployments
+      WHERE tool_id = ? ORDER BY created_at, id
+    `).all(toolId).map((row) => parse(row)).filter(Boolean);
+    }
+    allDeployments() {
+        return this.db.prepare(`
+      SELECT record_json FROM tool_deployments ORDER BY created_at, id
+    `).all().map((row) => parse(row)).filter(Boolean);
+    }
+    deploymentSnapshot() {
+        return {
+            version: 1,
+            deployments: Object.fromEntries(this.allDeployments().map((deployment) => [deployment.id, deployment])),
+            heads: this.heads(),
+        };
     }
-    apply(result) {
+    /** Add a baseline for a pre-deployment database without changing its catalog bytes. */
+    adoptDeployment(activation) {
+        const deployment = activation.deployment;
         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();
+            if (this.getDeployment(deployment.id))
+                return;
+            this.insertDeployment(deployment);
+            this.setHead(deployment.subjectId, deployment.id);
         })();
-        return result;
     }
-    setStatus(id, status, now) {
+    applyDeployment(activation) {
+        const deployment = activation.deployment;
         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 existing = this.getDeployment(deployment.id);
+            if (existing) {
+                if (canonicalJson(existing) !== canonicalJson(deployment)) {
+                    throw new Error(`Deployment id is immutable: ${deployment.id}`);
+                }
+                return { changed: false, result: existing.definition };
             }
-            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.insertDeployment(deployment);
+            this.materializeDefinition(deployment.subjectId, deployment.definition);
+            this.setHead(deployment.subjectId, deployment.id);
             this.bump();
-            return updated;
+            return { changed: true, result: deployment.definition };
         })();
     }
-    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;
+    replaceDeploymentSnapshot(snapshot) {
+        this.db.transaction(() => {
+            this.db.prepare('DELETE FROM actions').run();
+            this.db.prepare('DELETE FROM tools').run();
+            this.db.prepare('DELETE FROM tool_heads').run();
+            this.db.prepare('DELETE FROM tool_deployments').run();
+            for (const deployment of Object.values(snapshot.deployments))
+                this.insertDeployment(deployment);
+            for (const [toolId, deploymentId] of Object.entries(snapshot.heads)) {
+                const deployment = snapshot.deployments[deploymentId];
+                this.materializeDefinition(toolId, deployment.definition);
+                this.setHead(toolId, deploymentId);
             }
-            const action = this.getAction(id);
-            if (!action)
-                return null;
-            this.db.prepare('DELETE FROM actions WHERE id = ?').run(id);
             this.bump();
-            return action;
         })();
     }
+    insertDeployment(deployment) {
+        this.db.prepare(`
+      INSERT INTO tool_deployments
+        (id, tool_id, previous_deployment_id, created_at, record_json)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(deployment.id, deployment.subjectId, deployment.previousDeploymentId, deployment.createdAt, JSON.stringify(deployment));
+    }
+    setHead(toolId, deploymentId) {
+        this.db.prepare(`
+      INSERT INTO tool_heads (tool_id, deployment_id) VALUES (?, ?)
+      ON CONFLICT(tool_id) DO UPDATE SET deployment_id = excluded.deployment_id
+    `).run(toolId, deploymentId);
+    }
+    materializeDefinition(toolId, result) {
+        if (result === null) {
+            this.db.prepare('DELETE FROM tools WHERE id = ?').run(toolId);
+            return;
+        }
+        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));
+        }
+    }
     close() { this.db.close(); }
 }
 export { Store };

package/dist/toolbox-deployments.d.ts

@@ -0,0 +1,30 @@
+import { DeploymentFiles } from './deployment-files.js';
+import { Store } from './store.js';
+import type { ActionRecord, ApplyResult, ToolDeployment, ToolDeploymentActivation, ToolDeploymentSnapshot, ToolDeploymentSurface, ToolRecord, ToolboxOptions } from './types.js';
+interface DeploymentServiceOptions {
+    store: Store;
+    files: DeploymentFiles;
+    systemTools: readonly ToolRecord[];
+    systemActions: readonly ActionRecord[];
+    project(toolId: string): Promise<void>;
+    replaceProjection(previousToolIds: readonly string[]): Promise<void>;
+    onDeployment?: ToolboxOptions['onDeployment'];
+}
+/** The Toolbox deployment state machine; adapters only observe its operations. */
+declare class ToolboxDeployments {
+    private readonly options;
+    private readonly observers;
+    constructor(options: DeploymentServiceOptions);
+    adoptLegacy(): void;
+    activateLocal(definition: ApplyResult | null, deletedToolId?: string): Promise<void>;
+    current(toolId: string): ToolDeployment | null;
+    get(deploymentId: string): ToolDeployment | null;
+    history(toolId: string): ToolDeployment[];
+    snapshot(): ToolDeploymentSnapshot;
+    activateRemote(activation: ToolDeploymentActivation): Promise<ApplyResult | null>;
+    applySnapshot(snapshot: ToolDeploymentSnapshot): Promise<void>;
+    surface(): ToolDeploymentSurface;
+    private validateActivation;
+    private assertNotSystem;
+}
+export { ToolboxDeployments };

package/dist/toolbox-deployments.js

@@ -0,0 +1,125 @@
+import { TOOL_DEPLOYMENT_CONTRACT, assertToolDeploymentActivation, createToolDeployment, } from './deployments.js';
+import { assertMcpNamesUnique, id } from './ids.js';
+/** The Toolbox deployment state machine; adapters only observe its operations. */
+class ToolboxDeployments {
+    options;
+    observers = new Set();
+    constructor(options) {
+        this.options = options;
+    }
+    adoptLegacy() {
+        const { store, systemTools, files } = this.options;
+        for (const tool of store.catalog().tools) {
+            if (store.currentDeploymentId(tool.id) || systemTools.some((system) => system.id === tool.id))
+                continue;
+            store.adoptDeployment(createToolDeployment({
+                toolId: tool.id,
+                previousDeploymentId: null,
+                definition: { tool, actions: store.actionsFor(tool.id) },
+                createdAt: tool.updatedAt,
+            }));
+        }
+        files.materialize(store.allDeployments());
+    }
+    async activateLocal(definition, deletedToolId) {
+        const toolId = definition?.tool.id || deletedToolId;
+        if (!toolId)
+            throw new Error('Tool deployment requires a stable tool id');
+        const activation = createToolDeployment({
+            toolId,
+            previousDeploymentId: this.options.store.currentDeploymentId(toolId),
+            definition,
+            createdAt: definition?.tool.updatedAt || new Date().toISOString(),
+        });
+        const applied = this.options.store.applyDeployment(activation);
+        if (!applied.changed)
+            return;
+        this.options.files.write(activation.deployment);
+        await this.options.project(toolId);
+        for (const observer of this.observers)
+            observer(activation);
+        await this.options.onDeployment?.(activation);
+    }
+    current(toolId) {
+        const value = id(toolId, 'tool id');
+        const deploymentId = this.options.store.currentDeploymentId(value);
+        return deploymentId ? this.options.store.getDeployment(deploymentId) : null;
+    }
+    get(deploymentId) {
+        return this.options.store.getDeployment(id(deploymentId, 'deployment id', 96));
+    }
+    history(toolId) {
+        return this.options.store.deploymentsFor(id(toolId, 'tool id'));
+    }
+    snapshot() {
+        return this.options.store.deploymentSnapshot();
+    }
+    async activateRemote(activation) {
+        this.validateActivation(activation);
+        const applied = this.options.store.applyDeployment(activation);
+        if (!applied.changed)
+            return applied.result;
+        this.options.files.write(activation.deployment);
+        await this.options.project(activation.deployment.subjectId);
+        return applied.result;
+    }
+    async applySnapshot(snapshot) {
+        if (!snapshot || snapshot.version !== 1 || !snapshot.deployments || !snapshot.heads) {
+            throw new Error('Invalid tool deployment snapshot');
+        }
+        for (const [deploymentId, deployment] of Object.entries(snapshot.deployments)) {
+            this.validateActivation({ type: 'deployment.activate', deployment }, false);
+            if (deploymentId !== deployment.id)
+                throw new Error(`Deployment snapshot key mismatch: ${deploymentId}`);
+        }
+        const currentDefinitions = [];
+        for (const [toolId, deploymentId] of Object.entries(snapshot.heads)) {
+            const deployment = snapshot.deployments[deploymentId];
+            if (!deployment || deployment.subjectId !== toolId) {
+                throw new Error(`Deployment snapshot head is invalid: ${toolId}`);
+            }
+            this.assertNotSystem(toolId);
+            if (deployment.definition)
+                currentDefinitions.push(deployment.definition);
+        }
+        assertMcpNamesUnique([
+            ...this.options.systemActions,
+            ...currentDefinitions.flatMap((definition) => definition.actions),
+        ]);
+        const previousToolIds = this.options.store.catalog().tools.map((tool) => tool.id);
+        this.options.store.replaceDeploymentSnapshot(snapshot);
+        this.options.files.materialize(Object.values(snapshot.deployments));
+        await this.options.replaceProjection(previousToolIds);
+    }
+    surface() {
+        return Object.freeze({
+            contract: TOOL_DEPLOYMENT_CONTRACT,
+            observeEdits: (emit) => {
+                this.observers.add(emit);
+                return () => this.observers.delete(emit);
+            },
+            applyRemote: async (operation) => {
+                await this.activateRemote(operation);
+            },
+            applySnapshot: (snapshot) => this.applySnapshot(snapshot),
+        });
+    }
+    validateActivation(activation, checkNames = true) {
+        assertToolDeploymentActivation(activation);
+        const deployment = activation.deployment;
+        this.assertNotSystem(deployment.subjectId);
+        if (checkNames && deployment.definition) {
+            assertMcpNamesUnique([
+                ...this.options.systemActions,
+                ...this.options.store.catalog().actions.filter((action) => action.toolId !== deployment.subjectId),
+                ...deployment.definition.actions,
+            ]);
+        }
+    }
+    assertNotSystem(toolId) {
+        if (this.options.systemTools.some((tool) => tool.id === toolId)) {
+            throw new Error(`System tool is immutable: ${toolId}`);
+        }
+    }
+}
+export { ToolboxDeployments };

package/dist/toolbox-projection.d.ts

@@ -0,0 +1,13 @@
+import { ArtifactFiles } from './artifact-files.js';
+import type { Catalog, ToolboxOptions } from './types.js';
+/** Current-catalog compatibility projections; deployments remain authority. */
+declare class ToolboxProjection {
+    private readonly artifacts;
+    private readonly catalog;
+    private readonly onChange?;
+    constructor(artifacts: ArtifactFiles, catalog: () => Catalog, onChange?: ToolboxOptions['onChange']);
+    boot(): void;
+    changed(toolId: string): Promise<void>;
+    replaced(previousToolIds: readonly string[]): Promise<void>;
+}
+export { ToolboxProjection };

package/dist/toolbox-projection.js

@@ -0,0 +1,41 @@
+/** Current-catalog compatibility projections; deployments remain authority. */
+class ToolboxProjection {
+    artifacts;
+    catalog;
+    onChange;
+    constructor(artifacts, catalog, onChange) {
+        this.artifacts = artifacts;
+        this.catalog = catalog;
+        this.onChange = onChange;
+    }
+    boot() {
+        this.artifacts.migrateLegacy();
+        this.artifacts.materialize(this.catalog());
+    }
+    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);
+    }
+    async replaced(previousToolIds) {
+        const catalog = this.catalog();
+        const currentToolIds = new Set(catalog.tools.map((tool) => tool.id));
+        for (const toolId of previousToolIds) {
+            if (!currentToolIds.has(toolId))
+                this.artifacts.removeTool(toolId);
+        }
+        this.artifacts.materialize(catalog);
+        await this.onChange?.(catalog);
+    }
+}
+export { ToolboxProjection };

package/dist/toolbox-view.d.ts

@@ -0,0 +1,35 @@
+import type { ActionRecord, ApplyResult, CallOptions, Catalog, LoadoutInput, ToolDriver, ToolQuery, ToolRecord, ToolResult } from './types.js';
+declare class ToolboxView {
+    private readonly readCatalog;
+    private readonly drivers;
+    constructor(readCatalog: () => Catalog, drivers: ReadonlyMap<string, ToolDriver>);
+    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;
+    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 driverFor;
+}
+export { ToolboxView };

package/dist/toolbox-view.js

@@ -0,0 +1,75 @@
+import { id, mcpName } from './ids.js';
+import { validateInput } from './input.js';
+import { callableActions, queryTools, resolveAction, resolveCallableAction } from './query.js';
+import { findSelected, selected } from './selection.js';
+class ToolboxView {
+    readCatalog;
+    drivers;
+    constructor(readCatalog, drivers) {
+        this.readCatalog = readCatalog;
+        this.drivers = drivers;
+    }
+    catalog() { return this.readCatalog(); }
+    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);
+    }
+    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);
+    }
+    driverFor(tool) {
+        const driver = this.drivers.get(tool.source.type);
+        return driver && (driver.supports?.(tool) ?? true) ? driver : null;
+    }
+}
+export { ToolboxView };