amalgm 0.1.72 → 0.1.73

package/runtime/scripts/amalgm-mcp/toolbox/runner.js

@@ -1,90 +1,24 @@
 'use strict';
 
 const { spawn } = require('child_process');
-const path = require('path');
 const { errorResult, textResult } = require('../lib/tool-result');
-const { readToolbox } = require('./store');
+const {
+  TOOLBOX_TOOL_PREFIX,
+  toolboxMcpToolName,
+} = require('./names');
+const {
+  defaultToolboxService: toolboxService,
+} = require('./service');
 
-const TOOLBOX_TOOL_PREFIX = 'toolbox__';
 const DEFAULT_TIMEOUT_MS = 120_000;
 const MAX_OUTPUT_BYTES = 512 * 1024;
-const MODEL_UNSUPPORTED_TOP_LEVEL_SCHEMA_KEYS = ['anyOf', 'oneOf', 'allOf', 'not', 'enum'];
-
-function isObject(value) {
-  return !!value && typeof value === 'object' && !Array.isArray(value);
-}
-
-function safeMcpName(value) {
-  return String(value || '')
-    .trim()
-    .replace(/[^A-Za-z0-9_.-]+/g, '_')
-    .replace(/[.-]+/g, '_')
-    .replace(/_+/g, '_')
-    .replace(/^_+|_+$/g, '')
-    || 'tool';
-}
-
-function toolboxMcpToolName(action) {
-  return `${TOOLBOX_TOOL_PREFIX}${safeMcpName(action.id)}`;
-}
-
-function selectedToolIdsForContext(context) {
-  const tools = context?.sessionMetadata?.tools;
-  if (!tools || tools.mode !== 'selected') return null;
-  const selected = Array.isArray(tools.selectedToolIds)
-    ? tools.selectedToolIds
-    : Array.isArray(tools.selected)
-      ? tools.selected
-      : [];
-  return new Set(selected.map((value) => String(value || '').trim()).filter(Boolean));
-}
-
-function portableInputSchema(inputSchema) {
-  if (!isObject(inputSchema) || inputSchema.type !== 'object') {
-    return { type: 'object', properties: {}, additionalProperties: true };
-  }
-  const schema = { ...inputSchema };
-  for (const key of MODEL_UNSUPPORTED_TOP_LEVEL_SCHEMA_KEYS) {
-    delete schema[key];
-  }
-  if (!isObject(schema.properties)) schema.properties = {};
-  return schema;
-}
-
-function enabledToolboxActions(context) {
-  const toolbox = readToolbox();
-  const selectedToolIds = selectedToolIdsForContext(context);
-  return Object.values(toolbox.toolActions || {})
-    .map((action) => {
-      const tool = toolbox.tools?.[action.toolId];
-      return { action, tool };
-    })
-    .filter(({ action, tool }) => {
-      if (!tool || tool.status !== 'enabled' || action.status !== 'enabled') return false;
-      if (tool.origin === 'system') return false;
-      // Remote/local MCP tools are injected as MCP providers. The toolbox MCP
-      // runner is for tools Amalgm itself must execute, currently CLI/API.
-      if (tool.type !== 'cli' && tool.type !== 'api') return false;
-      if (!selectedToolIds) return true;
-      return selectedToolIds.has(tool.id) || selectedToolIds.has(action.id);
-    });
-}
 
 function listToolboxMcpTools(context) {
-  return enabledToolboxActions(context).map(({ action, tool }) => ({
-    name: toolboxMcpToolName(action),
-    description: [
-      action.description || `Run ${tool.name} ${action.name}.`,
-      tool.guide?.kind === 'skill' ? `Guidance skill: ${tool.guide.path}` : null,
-      action.guide?.kind === 'skill' ? `Action skill: ${action.guide.path}` : null,
-    ].filter(Boolean).join('\n'),
-    inputSchema: portableInputSchema(action.inputSchema),
-  }));
+  return toolboxService.listMcpTools(context);
 }
 
 function resolveToolboxMcpAction(toolName, context) {
-  return enabledToolboxActions(context)
-    .find(({ action }) => toolboxMcpToolName(action) === toolName) || null;
+  return toolboxService.resolveMcpTool(toolName, context);
 }
 
 function collectOutput(child, resolve, reject, timeoutMs) {

package/runtime/scripts/amalgm-mcp/toolbox/selection.js

@@ -0,0 +1,22 @@
+'use strict';
+
+function selectedToolIdsForContext(context) {
+  const tools = context?.sessionMetadata?.tools;
+  if (!tools || tools.mode !== 'selected') return null;
+  const selected = Array.isArray(tools.selectedToolIds)
+    ? tools.selectedToolIds
+    : Array.isArray(tools.selected)
+      ? tools.selected
+      : [];
+  return new Set(selected.map((value) => String(value || '').trim()).filter(Boolean));
+}
+
+function selectedContainsToolOrAction(selectedToolIds, toolId, actionId) {
+  if (!selectedToolIds) return true;
+  return selectedToolIds.has(toolId) || selectedToolIds.has(actionId);
+}
+
+module.exports = {
+  selectedContainsToolOrAction,
+  selectedToolIdsForContext,
+};

package/runtime/scripts/amalgm-mcp/toolbox/service.js

@@ -0,0 +1,227 @@
+'use strict';
+
+/**
+ * Toolbox service — registry and action domain boundary.
+ *
+ * Persistence lives in store.js. HTTP and MCP adapters should depend on this
+ * service rather than shaping toolbox records directly.
+ */
+
+const store = require('./store');
+const { portableInputSchema, toolboxMcpToolName } = require('./names');
+const {
+  selectedContainsToolOrAction,
+  selectedToolIdsForContext,
+} = require('./selection');
+const { mergeSystemToolboxCatalog } = require('./system-catalog');
+
+function actionRef(toolId, actionName) {
+  return `${toolId}.${actionName}`;
+}
+
+function normalizeId(value) {
+  return String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9_.-]+/g, '.')
+    .replace(/\.+/g, '.')
+    .replace(/^[._-]+|[._-]+$/g, '');
+}
+
+function isRunnableToolboxTool(tool) {
+  return !!tool
+    && tool.status === 'enabled'
+    && tool.origin !== 'system'
+    && (tool.type === 'cli' || tool.type === 'api');
+}
+
+function isExternalMcpTool(tool) {
+  return !!tool
+    && tool.status === 'enabled'
+    && tool.type === 'mcp'
+    && tool.origin !== 'system';
+}
+
+function compactAction(action) {
+  return {
+    id: action.id,
+    name: action.name,
+    ref: actionRef(action.toolId, action.name),
+    status: action.status,
+    description: action.description,
+    mcpToolName: toolboxMcpToolName(action),
+  };
+}
+
+function compactTool(tool, actions) {
+  return {
+    id: tool.id,
+    name: tool.name,
+    type: tool.type,
+    owner: tool.owner,
+    origin: tool.origin,
+    status: tool.status,
+    discovery: tool.discovery,
+    actions: actions.map(compactAction),
+    actionCount: actions.length,
+    source: tool.source,
+    guide: tool.guide,
+    display: tool.display,
+    policy: tool.policy,
+  };
+}
+
+function actionsByToolId(toolbox) {
+  const byToolId = new Map();
+  for (const action of Object.values(toolbox.toolActions || {})) {
+    const existing = byToolId.get(action.toolId) || [];
+    existing.push(action);
+    byToolId.set(action.toolId, existing);
+  }
+  return byToolId;
+}
+
+function createToolboxService(repository = store) {
+  function readToolbox() {
+    return repository.readToolbox();
+  }
+
+  function readCatalog() {
+    return mergeSystemToolboxCatalog(readToolbox());
+  }
+
+  function getTool(id, options = {}) {
+    const idValue = normalizeId(id);
+    if (!idValue) throw new Error('id is required');
+    const toolbox = readCatalog();
+    const tool = toolbox.tools?.[idValue];
+    if (!tool) throw new Error(`Unknown tool: ${idValue}`);
+    return {
+      tool,
+      ...(options.includeActions === false
+        ? {}
+        : {
+            actions: Object.values(toolbox.toolActions || {})
+              .filter((action) => action.toolId === idValue),
+          }),
+    };
+  }
+
+  function getAction(id) {
+    const idValue = normalizeId(id);
+    if (!idValue) throw new Error('id is required');
+    const toolbox = readCatalog();
+    const action = toolbox.toolActions?.[idValue];
+    if (!action) throw new Error(`Unknown tool action: ${idValue}`);
+    return { action };
+  }
+
+  function listTools(filters = {}) {
+    const toolbox = readCatalog();
+    const groupedActions = actionsByToolId(toolbox);
+    const tools = Object.values(toolbox.tools || {})
+      .filter((tool) => !filters.type || tool.type === filters.type)
+      .filter((tool) => !filters.owner || tool.owner === filters.owner)
+      .filter((tool) => !filters.origin || tool.origin === filters.origin)
+      .map((tool) => compactTool(tool, groupedActions.get(tool.id) || []));
+
+    return {
+      version: toolbox.version,
+      tools,
+      ...(filters.include_actions ? { toolActions: toolbox.toolActions } : {}),
+    };
+  }
+
+  function externalMcpToolIdsForMode(mode = 'all', toolIds = []) {
+    const selected = new Set(
+      (Array.isArray(toolIds) ? toolIds : [])
+        .map((value) => String(value || '').trim())
+        .filter(Boolean),
+    );
+    const toolbox = readCatalog();
+    return Object.values(toolbox.tools || {})
+      .filter((tool) => mode !== 'selected' || selected.has(tool.id))
+      .filter(isExternalMcpTool)
+      .map((tool) => tool.id);
+  }
+
+  function externalMcpToolIdsForSelection(toolIds = []) {
+    return externalMcpToolIdsForMode('selected', toolIds);
+  }
+
+  function listRunnableActions(context) {
+    const toolbox = readToolbox();
+    const selectedToolIds = selectedToolIdsForContext(context);
+    return Object.values(toolbox.toolActions || {})
+      .map((action) => ({ action, tool: toolbox.tools?.[action.toolId] }))
+      .filter(({ action, tool }) => {
+        if (!isRunnableToolboxTool(tool) || action.status !== 'enabled') return false;
+        return selectedContainsToolOrAction(selectedToolIds, tool.id, action.id);
+      });
+  }
+
+  function resolveRunnableAction(toolId, actionName) {
+    const normalizedToolId = String(toolId || '').trim();
+    const normalizedActionName = String(actionName || '').trim();
+    const toolbox = readToolbox();
+    const action = Object.values(toolbox.toolActions || {}).find((candidate) => {
+      if (candidate.toolId !== normalizedToolId) return false;
+      return candidate.name === normalizedActionName
+        || candidate.id === normalizedActionName
+        || candidate.id === `${normalizedToolId}.${normalizedActionName}`
+        || candidate.id === `${normalizedToolId}:${normalizedActionName}`;
+    });
+    if (!action || action.status !== 'enabled') return null;
+    const tool = toolbox.tools?.[action.toolId];
+    return isRunnableToolboxTool(tool) ? { tool, action } : null;
+  }
+
+  function listMcpTools(context) {
+    return listRunnableActions(context).map(({ action, tool }) => ({
+      name: toolboxMcpToolName(action),
+      description: [
+        action.description || `Run ${tool.name} ${action.name}.`,
+        tool.guide?.kind === 'skill' ? `Guidance skill: ${tool.guide.path}` : null,
+        action.guide?.kind === 'skill' ? `Action skill: ${action.guide.path}` : null,
+      ].filter(Boolean).join('\n'),
+      inputSchema: portableInputSchema(action.inputSchema),
+    }));
+  }
+
+  function resolveMcpTool(toolName, context) {
+    return listRunnableActions(context)
+      .find(({ action }) => toolboxMcpToolName(action) === toolName) || null;
+  }
+
+  return {
+    deleteAction: repository.deleteToolAction,
+    deleteTool: repository.deleteTool,
+    externalMcpToolIdsForMode,
+    externalMcpToolIdsForSelection,
+    getAction,
+    getTool,
+    listMcpTools,
+    listRunnableActions,
+    listTools,
+    readCatalog,
+    readToolbox,
+    registerAction: repository.upsertToolAction,
+    registerTool: repository.upsertTool,
+    resolveMcpTool,
+    resolveRunnableAction,
+    updateAction: repository.updateToolAction,
+    updateTool: repository.updateTool,
+  };
+}
+
+const defaultToolboxService = createToolboxService();
+
+module.exports = {
+  actionRef,
+  compactAction,
+  compactTool,
+  createToolboxService,
+  defaultToolboxService,
+  isExternalMcpTool,
+  isRunnableToolboxTool,
+};

package/runtime/scripts/amalgm-mcp/toolbox/store.js

@@ -12,7 +12,7 @@
  */
 
 const path = require('path');
-const { AMALGM_DIR, PORT } = require('../config');
+const { AMALGM_DIR } = require('../config');
 const { ensureDir, readJson, writeJsonAtomic } = require('../lib/storage');
 const { openLocalDb } = require('../state/db');
 const { insertStateEvent, publishStateEvent } = require('../state/events');
@@ -406,87 +406,18 @@ function defaultCliAction(tool) {
   }, tool);
 }
 
-function actionFromMcpTool(tool, mcpTool) {
-  return normalizeAction({
-    id: `${tool.id}.${mcpTool.name}`,
-    name: mcpTool.name,
-    displayName: mcpTool.name,
-    description: mcpTool.description,
-    inputSchema: isObject(mcpTool.inputSchema) ? mcpTool.inputSchema : { type: 'object', properties: {} },
-    sourceAction: { mcpToolName: mcpTool.name },
-  }, tool);
-}
-
-function systemAmalgmTool() {
-  return {
-    id: 'amalgm',
-    name: 'amalgm',
-    type: 'mcp',
-    owner: DEFAULT_TOOL_OWNER,
-    origin: 'system',
-    status: 'enabled',
-    source: {
-      transport: 'http',
-      url: `http://127.0.0.1:${PORT}/mcp`,
-    },
-    discovery: {
-      mode: 'dynamic',
-    },
-    display: {
-      icon: '/assets/images/amalgm_logo.svg',
-      description: 'Built-in Amalgm tools for tasks, events, agents, artifacts, browser, and notifications.',
-    },
-    policy: {
-      system: true,
-    },
-    createdAt: nowIso(),
-    updatedAt: nowIso(),
-  };
-}
-
-function seedSystemTools(toolbox) {
+function dropLegacyAggregateAmalgmTool(toolbox) {
   let changed = false;
-  const existing = toolbox.tools.amalgm;
-  const systemTool = {
-    ...systemAmalgmTool(),
-    createdAt: existing?.createdAt || nowIso(),
-    updatedAt: existing?.updatedAt || nowIso(),
-  };
-
-  if (!existing || JSON.stringify({ ...existing, updatedAt: undefined }) !== JSON.stringify({ ...systemTool, updatedAt: undefined })) {
-    toolbox.tools.amalgm = { ...existing, ...systemTool };
+  if (toolbox.tools?.amalgm) {
+    delete toolbox.tools.amalgm;
     changed = true;
   }
-
-  let toolsList = [];
-  try {
-    toolsList = require('../server/core-tools').CORE_TOOLS || [];
-  } catch {
-    toolsList = [];
-  }
-
-  for (const mcpTool of toolsList) {
-    if (!mcpTool?.name) continue;
-    const action = actionFromMcpTool(toolbox.tools.amalgm, mcpTool);
-    const existingAction = toolbox.toolActions[action.id];
-    if (!existingAction || JSON.stringify({
-      ...existingAction,
-      createdAt: undefined,
-      updatedAt: undefined,
-    }) !== JSON.stringify({
-      ...action,
-      createdAt: undefined,
-      updatedAt: undefined,
-    })) {
-      toolbox.toolActions[action.id] = {
-        ...existingAction,
-        ...action,
-        createdAt: existingAction?.createdAt || action.createdAt,
-      };
+  for (const [actionId, action] of Object.entries(toolbox.toolActions || {})) {
+    if (action?.toolId === 'amalgm') {
+      delete toolbox.toolActions[actionId];
       changed = true;
     }
   }
-
   return changed;
 }
 
@@ -637,8 +568,8 @@ function insertToolActionEvent(db, op, action, options = {}) {
 function readToolbox() {
   migrateLegacyToolboxFileIfNeeded();
   const toolbox = readToolboxFromDb();
-  const systemChanged = seedSystemTools(toolbox);
-  if (systemChanged) writeToolbox(toolbox);
+  const removedLegacyAggregate = dropLegacyAggregateAmalgmTool(toolbox);
+  if (removedLegacyAggregate) writeToolbox(toolbox);
   return toolbox;
 }
 

package/runtime/scripts/amalgm-mcp/toolbox/system-catalog.js

@@ -0,0 +1,112 @@
+'use strict';
+
+/**
+ * Virtual first-party Toolbox catalog entries.
+ *
+ * These records make Amalgm's default capabilities look like normal Toolbox
+ * tools/actions to UI and control-plane consumers without changing the legacy
+ * MCP tool names or writing additional system rows to local storage.
+ */
+
+const { PORT } = require('../config');
+const { toolboxMcpToolName } = require('./names');
+
+const SYSTEM_TIMESTAMP = '1970-01-01T00:00:00.000Z';
+
+function coreToolGroups() {
+  return require('../server/core-tools').CORE_TOOL_GROUPS || [];
+}
+
+function systemToolForGroup(group) {
+  return {
+    id: group.id,
+    name: group.name,
+    type: group.type || 'mcp',
+    owner: group.owner || 'amalgm',
+    origin: group.origin || 'system',
+    status: group.status || 'enabled',
+    source: {
+      transport: 'http',
+      url: `http://127.0.0.1:${PORT}/mcp`,
+    },
+    discovery: { mode: 'static' },
+    display: {
+      icon: '/assets/images/amalgm_logo.svg',
+      description: group.description,
+    },
+    policy: {
+      system: true,
+      firstParty: true,
+    },
+    createdAt: SYSTEM_TIMESTAMP,
+    updatedAt: SYSTEM_TIMESTAMP,
+  };
+}
+
+function systemActionForTool(tool, group) {
+  return {
+    id: tool.toolboxActionId,
+    toolId: group.id,
+    name: tool.toolboxActionName,
+    displayName: tool.toolboxActionName,
+    description: tool.description || '',
+    inputSchema: tool.inputSchema || { type: 'object', properties: {} },
+    status: 'enabled',
+    sourceAction: {
+      handlerName: tool.name,
+      mcpToolName: toolboxMcpToolName({ id: tool.toolboxActionId }),
+    },
+    policy: {
+      system: true,
+      firstParty: true,
+    },
+    createdAt: SYSTEM_TIMESTAMP,
+    updatedAt: SYSTEM_TIMESTAMP,
+  };
+}
+
+function buildSystemToolboxCatalog() {
+  const tools = {};
+  const toolActions = {};
+
+  for (const group of coreToolGroups()) {
+    tools[group.id] = systemToolForGroup(group);
+    for (const tool of group.tools) {
+      toolActions[tool.toolboxActionId] = systemActionForTool(tool, group);
+    }
+  }
+
+  return { tools, toolActions };
+}
+
+function persistedCatalogWithoutLegacyAggregate(toolbox) {
+  const tools = { ...(toolbox?.tools || {}) };
+  const toolActions = { ...(toolbox?.toolActions || {}) };
+  delete tools.amalgm;
+  for (const [actionId, action] of Object.entries(toolActions)) {
+    if (action?.toolId === 'amalgm') delete toolActions[actionId];
+  }
+  return { tools, toolActions };
+}
+
+function mergeSystemToolboxCatalog(toolbox) {
+  const catalog = buildSystemToolboxCatalog();
+  const persisted = persistedCatalogWithoutLegacyAggregate(toolbox);
+  return {
+    ...toolbox,
+    tools: {
+      ...catalog.tools,
+      ...persisted.tools,
+    },
+    toolActions: {
+      ...catalog.toolActions,
+      ...persisted.toolActions,
+    },
+  };
+}
+
+module.exports = {
+  buildSystemToolboxCatalog,
+  mergeSystemToolboxCatalog,
+  persistedCatalogWithoutLegacyAggregate,
+};