@amalgm/tools 0.1.4 → 0.1.5

package/dist/apply-definition.js

@@ -1,33 +0,0 @@
-import { portableRecordSemantic } from './artifacts.js';
-import { normalizeDefinition } from './definition.js';
-import { assertMcpNamesUnique, id } from './ids.js';
-/** Normalize and deploy one authoritative user definition. */
-async function applyDefinition(options) {
-    const { definition, store, deployments, systemTools, systemActions } = options;
-    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 (systemTools.some((tool) => tool.id === normalizedId))
-        throw new Error(`System tool is immutable: ${normalizedId}`);
-    const existing = store.getTool(normalizedId);
-    const oldActions = new Map(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,
-    }));
-    assertMcpNamesUnique([
-        ...systemActions,
-        ...store.catalog().actions.filter((action) => action.toolId !== normalized.tool.id),
-        ...normalized.actions,
-    ]);
-    const unchanged = existing && portableRecordSemantic(existing) === portableRecordSemantic(normalized.tool)
-        && normalized.actions.length === oldActions.size
-        && normalized.actions.every((action) => portableRecordSemantic(action)
-            === portableRecordSemantic(oldActions.get(action.id)));
-    if (unchanged) {
-        return { tool: existing, actions: [...oldActions.values()].sort((a, b) => a.id.localeCompare(b.id)) };
-    }
-    await deployments.activateLocal(normalized);
-    return normalized;
-}
-export { applyDefinition };

package/dist/deployment-files.d.ts

@@ -1,10 +0,0 @@
-import type { ToolDeployment } from './types.js';
-/** Host effect for the portable, immutable deployment document tree. */
-declare class DeploymentFiles {
-    private readonly root;
-    constructor(root: string);
-    file(deployment: ToolDeployment): string;
-    write(deployment: ToolDeployment): string;
-    materialize(deployments: readonly ToolDeployment[]): void;
-}
-export { DeploymentFiles };

package/dist/deployment-files.js

@@ -1,38 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { canonicalJson } from './deployments.js';
-/** Host effect for the portable, immutable deployment document tree. */
-class DeploymentFiles {
-    root;
-    constructor(root) {
-        this.root = root;
-    }
-    file(deployment) {
-        return path.join(this.root, deployment.subjectId, 'deployments', `${deployment.id}.json`);
-    }
-    write(deployment) {
-        const target = this.file(deployment);
-        const bytes = `${JSON.stringify(deployment, null, 2)}\n`;
-        try {
-            const existing = fs.readFileSync(target, 'utf8');
-            if (canonicalJson(JSON.parse(existing)) !== canonicalJson(deployment)) {
-                throw new Error(`Deployment file is immutable: ${deployment.id}`);
-            }
-            return target;
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT')
-                throw error;
-        }
-        fs.mkdirSync(path.dirname(target), { recursive: true });
-        const temporary = `${target}.tmp`;
-        fs.writeFileSync(temporary, bytes, { flag: 'wx' });
-        fs.renameSync(temporary, target);
-        return target;
-    }
-    materialize(deployments) {
-        for (const deployment of deployments)
-            this.write(deployment);
-    }
-}
-export { DeploymentFiles };

package/dist/deployment-types.d.ts

@@ -1,32 +0,0 @@
-import type { ApplyResult } from './types.js';
-interface ToolDeployment {
-    schemaVersion: 1;
-    kind: 'amalgm-tool-deployment';
-    id: string;
-    /** The stable tool id, named generically to match @amalgm/live. */
-    subjectId: string;
-    previousDeploymentId: string | null;
-    definition: ApplyResult | null;
-    contentHash: string;
-    createdAt: string;
-}
-interface ToolDeploymentActivation {
-    type: 'deployment.activate';
-    deployment: ToolDeployment;
-}
-interface ToolDeploymentSnapshot {
-    version: 1;
-    deployments: Record<string, ToolDeployment>;
-    heads: Record<string, string>;
-}
-interface ToolDeploymentSurface {
-    readonly contract: 'amalgm.tools.deployments@1';
-    observeEdits(emit: (operation: ToolDeploymentActivation) => void): () => void;
-    applyRemote(operation: ToolDeploymentActivation, context: {
-        readonly hydrating: boolean;
-    }): void | Promise<void>;
-    applySnapshot(snapshot: ToolDeploymentSnapshot, context: {
-        readonly reason: 'hydration' | 'recovery';
-    }): void | Promise<void>;
-}
-export type { ToolDeployment, ToolDeploymentActivation, ToolDeploymentSnapshot, ToolDeploymentSurface, };

package/dist/deployment-types.js

@@ -1 +0,0 @@
-export {};

package/dist/deployments.d.ts

@@ -1,19 +0,0 @@
-import type { ActionRecord, ApplyResult, ToolDeploymentActivation, ToolDeploymentSnapshot, ToolRecord } from './types.js';
-declare const TOOL_DEPLOYMENT_CONTRACT: "amalgm.tools.deployments@1";
-declare const TOOL_DEPLOYMENT_KIND: "amalgm-tool-deployment";
-declare const TOOL_DEPLOYMENT_SCHEMA_VERSION: 1;
-declare function canonicalJson(value: unknown): string;
-declare function createToolDeployment(input: {
-    toolId: string;
-    previousDeploymentId: string | null;
-    definition: ApplyResult | null;
-    createdAt: string;
-}): ToolDeploymentActivation;
-declare function assertToolDeploymentActivation(value: unknown): asserts value is ToolDeploymentActivation;
-declare function deploymentRevisionId(input: {
-    heads: Readonly<Record<string, string>>;
-    systemTools?: readonly ToolRecord[];
-    systemActions?: readonly ActionRecord[];
-}): string;
-declare function emptyToolDeploymentSnapshot(): ToolDeploymentSnapshot;
-export { TOOL_DEPLOYMENT_CONTRACT, TOOL_DEPLOYMENT_KIND, TOOL_DEPLOYMENT_SCHEMA_VERSION, assertToolDeploymentActivation, canonicalJson, createToolDeployment, deploymentRevisionId, emptyToolDeploymentSnapshot, };

package/dist/deployments.js

@@ -1,98 +0,0 @@
-import { createHash } from 'node:crypto';
-const TOOL_DEPLOYMENT_CONTRACT = 'amalgm.tools.deployments@1';
-const TOOL_DEPLOYMENT_KIND = 'amalgm-tool-deployment';
-const TOOL_DEPLOYMENT_SCHEMA_VERSION = 1;
-function canonical(value) {
-    if (Array.isArray(value))
-        return value.map(canonical);
-    if (!value || typeof value !== 'object')
-        return value;
-    return Object.fromEntries(Object.entries(value)
-        .filter(([, item]) => item !== undefined)
-        .sort(([left], [right]) => left.localeCompare(right))
-        .map(([key, item]) => [key, canonical(item)]));
-}
-function canonicalJson(value) {
-    return JSON.stringify(canonical(value));
-}
-function sha256(value) {
-    return createHash('sha256').update(canonicalJson(value)).digest('hex');
-}
-function createToolDeployment(input) {
-    const contentHash = sha256(input.definition);
-    const identity = sha256({
-        subjectId: input.toolId,
-        previousDeploymentId: input.previousDeploymentId,
-        contentHash,
-        createdAt: input.createdAt,
-    });
-    return Object.freeze({
-        type: 'deployment.activate',
-        deployment: Object.freeze({
-            schemaVersion: TOOL_DEPLOYMENT_SCHEMA_VERSION,
-            kind: TOOL_DEPLOYMENT_KIND,
-            id: `tooldep_${identity}`,
-            subjectId: input.toolId,
-            previousDeploymentId: input.previousDeploymentId,
-            definition: input.definition,
-            contentHash,
-            createdAt: input.createdAt,
-        }),
-    });
-}
-function assertRecord(value, label) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        throw new Error(`${label} must be an object`);
-}
-function assertToolDeploymentActivation(value) {
-    assertRecord(value, 'Tool deployment activation');
-    if (value.type !== 'deployment.activate')
-        throw new Error('Tool deployment operation must be deployment.activate');
-    assertRecord(value.deployment, 'Tool deployment');
-    const deployment = value.deployment;
-    if (deployment.schemaVersion !== TOOL_DEPLOYMENT_SCHEMA_VERSION || deployment.kind !== TOOL_DEPLOYMENT_KIND) {
-        throw new Error('Unsupported tool deployment document');
-    }
-    if (typeof deployment.id !== 'string' || !deployment.id
-        || typeof deployment.subjectId !== 'string' || !deployment.subjectId
-        || typeof deployment.createdAt !== 'string' || !deployment.createdAt
-        || (deployment.previousDeploymentId !== null && typeof deployment.previousDeploymentId !== 'string')) {
-        throw new Error('Tool deployment identity is incomplete');
-    }
-    if (deployment.definition !== null) {
-        assertRecord(deployment.definition, 'Tool deployment definition');
-        assertRecord(deployment.definition.tool, 'Tool deployment tool');
-        if (deployment.definition.tool.id !== deployment.subjectId) {
-            throw new Error('Tool deployment subject does not match its tool');
-        }
-        if (deployment.definition.tool.origin === 'system') {
-            throw new Error('System tools cannot arrive as user deployments');
-        }
-        if (!Array.isArray(deployment.definition.actions)
-            || deployment.definition.actions.some((action) => action.toolId !== deployment.subjectId)) {
-            throw new Error('Tool deployment actions must all belong to its subject');
-        }
-    }
-    if (deployment.contentHash !== sha256(deployment.definition)) {
-        throw new Error(`Tool deployment content hash is invalid: ${deployment.id}`);
-    }
-    const expected = createToolDeployment({
-        toolId: deployment.subjectId,
-        previousDeploymentId: deployment.previousDeploymentId,
-        definition: deployment.definition,
-        createdAt: deployment.createdAt,
-    }).deployment.id;
-    if (deployment.id !== expected)
-        throw new Error(`Tool deployment id is invalid: ${deployment.id}`);
-}
-function deploymentRevisionId(input) {
-    return `toolbox_${sha256({
-        heads: input.heads,
-        systemTools: input.systemTools || [],
-        systemActions: input.systemActions || [],
-    })}`;
-}
-function emptyToolDeploymentSnapshot() {
-    return { version: 1, deployments: {}, heads: {} };
-}
-export { TOOL_DEPLOYMENT_CONTRACT, TOOL_DEPLOYMENT_KIND, TOOL_DEPLOYMENT_SCHEMA_VERSION, assertToolDeploymentActivation, canonicalJson, createToolDeployment, deploymentRevisionId, emptyToolDeploymentSnapshot, };

package/dist/host-mcp-tool.d.ts

@@ -1,8 +0,0 @@
-import type { HostMcpToolDefinitionInput, ToolDefinition } from './types.js';
-/**
- * Project an owning SDK's MCP descriptors into one immutable first-party
- * Toolbox tool. The descriptors remain authoritative; this adapter does not
- * copy or reinterpret action schemas.
- */
-declare function defineHostMcpTool(input: HostMcpToolDefinitionInput): ToolDefinition;
-export { defineHostMcpTool };

package/dist/host-mcp-tool.js

@@ -1,40 +0,0 @@
-import { defineTool } from './definition.js';
-const EMPTY_INPUT = {
-    type: 'object',
-    properties: {},
-    additionalProperties: false,
-};
-/**
- * Project an owning SDK's MCP descriptors into one immutable first-party
- * Toolbox tool. The descriptors remain authoritative; this adapter does not
- * copy or reinterpret action schemas.
- */
-function defineHostMcpTool(input) {
-    const actions = input.tools.map((tool) => ({
-        name: tool.name,
-        ...(tool.description ? { description: tool.description } : {}),
-        inputSchema: tool.inputSchema || EMPTY_INPUT,
-        target: { name: tool.name },
-    }));
-    return defineTool({
-        id: input.id,
-        name: input.name,
-        ...(input.description ? { description: input.description } : {}),
-        owner: input.owner || 'amalgm',
-        origin: 'system',
-        source: {
-            type: 'mcp',
-            transport: 'host',
-            serverName: input.serverName,
-            route: input.route,
-        },
-        actions,
-        policy: { firstParty: true },
-        ...(input.display ? { display: structuredClone(input.display) } : {}),
-        metadata: {
-            platform: true,
-            ...(input.metadata ? structuredClone(input.metadata) : {}),
-        },
-    });
-}
-export { defineHostMcpTool };

package/dist/toolbox-deployments.d.ts

@@ -1,30 +0,0 @@
-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

@@ -1,125 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,41 +0,0 @@
-/** 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

@@ -1,35 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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 };