@amalgm/tools 0.1.4 → 0.1.5

package/dist/store.js

@@ -1,7 +1,6 @@
 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;
@@ -33,128 +32,65 @@ 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);
-        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(),
-        };
+        return { version: 1, revision: this.revision(), tools, actions };
     }
-    /** Add a baseline for a pre-deployment database without changing its catalog bytes. */
-    adoptDeployment(activation) {
-        const deployment = activation.deployment;
+    apply(result) {
         this.db.transaction(() => {
-            if (this.getDeployment(deployment.id))
-                return;
-            this.insertDeployment(deployment);
-            this.setHead(deployment.subjectId, deployment.id);
+            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;
     }
-    applyDeployment(activation) {
-        const deployment = activation.deployment;
+    setStatus(id, status, now) {
         return this.db.transaction(() => {
-            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 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;
             }
-            this.insertDeployment(deployment);
-            this.materializeDefinition(deployment.subjectId, deployment.definition);
-            this.setHead(deployment.subjectId, deployment.id);
+            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 { changed: true, result: deployment.definition };
+            return updated;
         })();
     }
-    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);
+    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;
         })();
     }
-    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.d.ts

@@ -1,11 +1,10 @@
-import type { ActionDefinition, ActionPatch, ActionRecord, ApplyResult, CallOptions, Catalog, LoadoutInput, ToolDefinition, ToolboxOptions, ToolDeployment, ToolDeploymentActivation, ToolDeploymentSnapshot, ToolDeploymentSurface, ToolPatch, ToolQuery, ToolRecord, ToolResult } from './types.js';
+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 deploymentService;
-    private readonly projection;
+    private readonly artifacts;
     private readonly system;
     private readonly drivers;
-    private readonly view;
+    private readonly onChange?;
     constructor(options?: ToolboxOptions);
     catalog(): Catalog;
     list(loadout?: LoadoutInput): Array<{
@@ -36,19 +35,12 @@ declare class Toolbox {
     updateAction(actionId: string, patch: ActionPatch): Promise<ActionRecord>;
     setStatus(recordId: string, status: 'enabled' | 'disabled'): Promise<ToolRecord | ActionRecord>;
     remove(recordId: string): Promise<ToolRecord | ActionRecord>;
-    currentDeployment(toolId: string): ToolDeployment | null;
-    deployment(deploymentId: string): ToolDeployment | null;
-    deploymentHistory(toolId: string): ToolDeployment[];
-    deploymentSnapshot(): ToolDeploymentSnapshot;
-    /** Apply an officially ordered remote activation without emitting it again. */
-    activateDeployment(activation: ToolDeploymentActivation): Promise<ApplyResult | null>;
-    /** Replace local materialization during Live hydration or gap recovery. */
-    applyDeploymentSnapshot(snapshot: ToolDeploymentSnapshot): Promise<void>;
-    deploymentSurface(): ToolDeploymentSurface;
     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

@@ -2,19 +2,19 @@ import os from 'node:os';
 import path from 'node:path';
 import { resolveProductStateDir } from '@amalgm/core/identity';
 import { apiDriver } from './api-driver.js';
-import { applyDefinition } from './apply-definition.js';
 import { ArtifactFiles } from './artifact-files.js';
-import { preserveProjectionTime } from './artifacts.js';
 import { cliDriver } from './cli-driver.js';
-import { DeploymentFiles } from './deployment-files.js';
-import { deploymentRevisionId } from './deployments.js';
 import { normalizeDefinition } from './definition.js';
-import { assertMcpNamesUnique, id } from './ids.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 { ToolboxDeployments } from './toolbox-deployments.js';
-import { ToolboxProjection } from './toolbox-projection.js';
-import { ToolboxView } from './toolbox-view.js';
-import { removeAction, updateAction, updateTool, upsertAction } from './updates.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);
@@ -32,17 +32,15 @@ function defaultDatabase(options) {
 }
 class Toolbox {
     store;
-    deploymentService;
-    projection;
+    artifacts;
     system;
     drivers = new Map();
-    view;
+    onChange;
     constructor(options = {}) {
         const databaseFile = defaultDatabase(options);
         this.store = new Store(databaseFile);
-        const artifacts = new ArtifactFiles(path.dirname(databaseFile));
-        const deploymentFiles = new DeploymentFiles(path.resolve(options.deploymentDir || options.stateDir || path.dirname(databaseFile)));
-        const priorIndex = artifacts.readIndex();
+        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 = [];
@@ -51,31 +49,13 @@ class Toolbox {
             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(preserveProjectionTime(normalized.tool, priorIndex?.tools[normalized.tool.id]));
-            actions.push(...normalized.actions.map((action) => preserveProjectionTime(action, priorIndex?.toolActions[action.id])));
+            tools.push(normalized.tool);
+            actions.push(...normalized.actions);
         }
         assertMcpNamesUnique(actions);
-        this.system = {
-            version: 1,
-            revision: 0,
-            revisionId: deploymentRevisionId({ heads: {}, systemTools: tools, systemActions: actions }),
-            deployments: {},
-            tools,
-            actions,
-        };
-        this.projection = new ToolboxProjection(artifacts, () => this.catalog(), options.onChange);
-        this.deploymentService = new ToolboxDeployments({
-            store: this.store,
-            files: deploymentFiles,
-            systemTools: this.system.tools,
-            systemActions: this.system.actions,
-            project: (toolId) => this.projection.changed(toolId),
-            replaceProjection: (previousToolIds) => this.projection.replaced(previousToolIds),
-            ...(options.onDeployment ? { onDeployment: options.onDeployment } : {}),
-        });
-        this.deploymentService.adoptLegacy();
-        this.view = new ToolboxView(() => this.catalog(), this.drivers);
-        this.projection.boot();
+        this.system = { version: 1, revision: 0, tools, actions };
+        this.artifacts.migrateLegacy();
+        this.artifacts.materialize(this.catalog());
     }
     catalog() {
         const persisted = this.store.catalog();
@@ -84,37 +64,66 @@ class Toolbox {
         const userActions = persisted.actions.filter((action) => !systemIds.has(action.toolId));
         const catalog = {
             version: 1, revision: persisted.revision,
-            revisionId: deploymentRevisionId({
-                heads: persisted.deployments,
-                systemTools: this.system.tools,
-                systemActions: this.system.actions,
-            }),
-            deployments: persisted.deployments,
             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) { return this.view.list(loadout); }
-    query(filters = {}) { return this.view.query(filters); }
-    callable(loadout, filters = {}) { return this.view.callable(loadout, filters); }
-    get(toolId) { return this.view.get(toolId); }
-    action(actionId) { return this.view.action(actionId); }
+    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 this.view.resolve(toolId, actionReference, loadout);
+        return resolveAction(this, toolId, actionReference, loadout);
     }
     resolveCallable(toolId, actionReference, loadout, filters = {}) {
-        return this.view.resolveCallable(toolId, actionReference, loadout, filters);
+        return resolveCallableAction(this, toolId, actionReference, loadout, filters);
     }
     async apply(definition) {
-        return applyDefinition({
-            definition,
-            store: this.store,
-            deployments: this.deploymentService,
-            systemTools: this.system.tools,
-            systemActions: this.system.actions,
-        });
+        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);
@@ -130,50 +139,65 @@ class Toolbox {
         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 tool = this.get(value);
-        if (tool)
-            return tool.tool.status === status ? tool.tool : (await this.update(value, { status })).tool;
-        const action = this.action(value);
-        if (!action)
+        const updated = this.store.setStatus(value, status, new Date().toISOString());
+        if (!updated)
             throw new Error(`Unknown tool or action: ${value}`);
-        return action.status === status ? action : this.updateAction(value, { status });
+        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 tool = this.get(value);
-        if (tool) {
-            await this.deploymentService.activateLocal(null, value);
-            return tool.tool;
-        }
-        return removeAction(this, value);
-    }
-    currentDeployment(toolId) { return this.deploymentService.current(toolId); }
-    deployment(deploymentId) { return this.deploymentService.get(deploymentId); }
-    deploymentHistory(toolId) { return this.deploymentService.history(toolId); }
-    deploymentSnapshot() { return this.deploymentService.snapshot(); }
-    /** Apply an officially ordered remote activation without emitting it again. */
-    async activateDeployment(activation) {
-        return this.deploymentService.activateRemote(activation);
-    }
-    /** Replace local materialization during Live hydration or gap recovery. */
-    async applyDeploymentSnapshot(snapshot) {
-        return this.deploymentService.applySnapshot(snapshot);
-    }
-    deploymentSurface() {
-        return this.deploymentService.surface();
+        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) {
-        return this.view.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 = {}) {
-        return this.view.call(actionId, input, options);
-    }
-    hasDriver(tool) { return this.view.hasDriver(tool); }
+        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 = {}) {
-        return this.view.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(); }
 }

package/dist/types.d.ts

@@ -1,5 +1,4 @@
 import type { Writable } from 'node:stream';
-import type { ToolDeploymentActivation } from './deployment-types.js';
 type JsonSchema = {
     type: 'object';
     properties?: Record<string, {
@@ -42,8 +41,6 @@ interface McpSource extends BaseSource {
     args?: string[];
     cwd?: string;
     serverName?: string;
-    /** Absolute path mounted by the composing host for `transport: host`. */
-    route?: string;
     secretHeaders?: SecretReferences;
     secretEnv?: SecretReferences;
 }
@@ -112,12 +109,7 @@ interface ActionRecord extends Omit<ActionDefinition, 'id' | 'status' | 'inputSc
 }
 interface Catalog {
     version: 1;
-    /** Local materialization counter. Never used as immutable authority. */
     revision: number;
-    /** Exact digest of current user deployments and system projections. */
-    revisionId: string;
-    /** Current deployment id per stable user tool, including tombstones. */
-    deployments: Record<string, string>;
     tools: ToolRecord[];
     actions: ActionRecord[];
 }
@@ -159,13 +151,9 @@ interface ToolDriver {
 interface ToolboxOptions {
     stateDir?: string;
     databaseFile?: string;
-    /** Portable immutable deployment documents; may differ from databaseFile. */
-    deploymentDir?: string;
     systemTools?: ToolDefinition[];
     drivers?: ToolDriver[];
     onChange?: (catalog: Catalog) => void | Promise<void>;
-    /** Outbound local Live operation. Remote application never calls it. */
-    onDeployment?: (activation: ToolDeploymentActivation) => void | Promise<void>;
 }
 interface McpTool {
     name: string;
@@ -176,26 +164,9 @@ interface McpTool {
 interface McpOptions extends CallOptions {
     includeManagement?: boolean;
 }
-interface HostMcpToolDescriptor {
-    name: string;
-    description?: string;
-    inputSchema?: JsonSchema;
-}
-interface HostMcpToolDefinitionInput {
-    id: string;
-    name: string;
-    description?: string;
-    serverName: string;
-    route: string;
-    tools: readonly HostMcpToolDescriptor[];
-    owner?: string;
-    display?: Record<string, unknown>;
-    metadata?: Record<string, unknown>;
-}
 interface CliIo {
     stdout?: Writable;
     stderr?: Writable;
     toolbox?: import('./toolbox.js').Toolbox;
 }
-export type { ActionDefinition, ActionRecord, ActionTarget, ApiSource, ApiTarget, ApplyResult, CallOptions, Catalog, CliIo, CliSource, CliTarget, DriverCall, HostMcpToolDefinitionInput, HostMcpToolDescriptor, JsonSchema, Loadout, LoadoutInput, McpOptions, McpSource, McpTarget, McpTool, Origin, SecretResolver, Status, ToolDefinition, ToolDriver, ToolboxOptions, ToolRecord, ToolResult, ToolPatch, ActionPatch, ToolQuery, ToolSource, ToolType, };
-export type { ToolDeployment, ToolDeploymentActivation, ToolDeploymentSnapshot, ToolDeploymentSurface, } from './deployment-types.js';
+export type { ActionDefinition, ActionRecord, ActionTarget, ApiSource, ApiTarget, ApplyResult, CallOptions, Catalog, CliIo, CliSource, CliTarget, DriverCall, JsonSchema, Loadout, LoadoutInput, McpOptions, McpSource, McpTarget, McpTool, Origin, SecretResolver, Status, ToolDefinition, ToolDriver, ToolboxOptions, ToolRecord, ToolResult, ToolPatch, ActionPatch, ToolQuery, ToolSource, ToolType, };

package/dist/updates.d.ts

@@ -4,5 +4,4 @@ type UpdatePort = Pick<Toolbox, 'action' | 'apply' | 'get'>;
 declare function updateTool(toolbox: UpdatePort, toolId: string, patch: ToolPatch): Promise<ApplyResult>;
 declare function upsertAction(toolbox: UpdatePort, toolId: string, definition: ActionDefinition): Promise<ActionRecord>;
 declare function updateAction(toolbox: UpdatePort, actionId: string, patch: ActionPatch): Promise<ActionRecord>;
-declare function removeAction(toolbox: UpdatePort, actionId: string): Promise<ActionRecord>;
-export { removeAction, updateAction, updateTool, upsertAction };
+export { updateAction, updateTool, upsertAction };

package/dist/updates.js

@@ -54,15 +54,4 @@ async function updateAction(toolbox, actionId, patch) {
         metadata: mergedObject(definition.metadata, patch.metadata),
     });
 }
-async function removeAction(toolbox, actionId) {
-    const action = toolbox.action(actionId);
-    if (!action)
-        throw new Error(`Unknown action: ${actionId}`);
-    const current = toolbox.get(action.toolId);
-    await toolbox.apply({
-        ...toolDefinition(current),
-        actions: current.actions.filter((candidate) => candidate.id !== actionId).map(actionDefinition),
-    });
-    return action;
-}
-export { removeAction, updateAction, updateTool, upsertAction };
+export { updateAction, updateTool, upsertAction };

package/docs/ENGINE_INTEGRATION.md

@@ -8,7 +8,6 @@ second registry.
 
 - tool and action definition, validation, identity, and persistence;
 - atomic apply, enable, disable, and removal behavior;
-- immutable deployment history, current heads, and the Tools Live surface;
 - loadout selection semantics and deterministic MCP action names;
 - CLI and HTTP API execution drivers and output bounds;
 - SDK, CLI, Toolbox management MCP tools, and action MCP projection;
@@ -19,8 +18,7 @@ second registry.
 - first-party action implementations supplied as `systemTools` and drivers;
 - authenticated capability context and the execution-time secret resolver;
 - the long-lived MCP connection/session host;
-- the machine-local SQLite path, portable deployment directory, Live binding,
-  state-event projection, REST shape translation, UI composition, and one-time
+- state-event projection, REST shape translation, UI composition, and one-time
   import from Engine's superseded Toolbox tables or JSON file.
 
 Agents owns agent records and their loadout ids. Tools treats those ids as
@@ -28,8 +26,7 @@ input to product-owned selection. Neither product is allowed to rewrite the
 other through a Core adapter.
 
 Engine adapters call one `Toolbox` instance. They do not write its SQLite
-database, synchronize database pages, or independently normalize, select,
-name, deploy, or execute tool actions.
+database or independently normalize, select, name, or execute tool actions.
 An absent loadout must be passed as `undefined`; an explicitly empty loadout
 must be passed as `[]`.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amalgm/tools",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Local-first tool definitions, Toolbox registry, and agent execution surfaces.",
   "license": "UNLICENSED",
   "private": false,
@@ -39,17 +39,17 @@
     "README.md"
   ],
   "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.build.json && tsx scripts/mark-executables.ts",
+    "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.build.json && tsx scripts/mark-executables.ts",
     "check": "tsx scripts/check-tree.ts && tsc -p tsconfig.json && tsc -p tsconfig.test.json",
     "test": "tsx --test --test-concurrency=1 --test-timeout=30000 test/*.test.ts",
     "verify": "npm run check && npm run build && npm test",
     "prepack": "npm run build"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=24"
   },
   "dependencies": {
-    "@amalgm/core": "0.2.0",
+    "@amalgm/core": "0.4.7",
     "better-sqlite3": "^12.6.2"
   },
   "devDependencies": {

package/dist/apply-definition.d.ts

@@ -1,12 +0,0 @@
-import { Store } from './store.js';
-import { ToolboxDeployments } from './toolbox-deployments.js';
-import type { ActionRecord, ApplyResult, ToolDefinition, ToolRecord } from './types.js';
-/** Normalize and deploy one authoritative user definition. */
-declare function applyDefinition(options: {
-    definition: ToolDefinition;
-    store: Store;
-    deployments: ToolboxDeployments;
-    systemTools: readonly ToolRecord[];
-    systemActions: readonly ActionRecord[];
-}): Promise<ApplyResult>;
-export { applyDefinition };