amalgm 0.1.126 → 0.1.127

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amalgm",
-  "version": "0.1.126",
+  "version": "0.1.127",
   "description": "Amalgm local computer runtime: login, MCP, chat, events, previews, and tunnels.",
   "license": "UNLICENSED",
   "private": false,

package/runtime/scripts/amalgm-mcp/agent-bundles/bundles.js

@@ -9,6 +9,12 @@ const { defaultToolboxService } = require('../toolbox/service');
 
 const BUNDLE_KIND = 'amalgm.agent.bundle';
 const BUNDLE_SCHEMA_VERSION = 1;
+const GRAPH_ELEMENT_ORDER = {
+  agent: 0,
+  tool: 1,
+  tool_action: 2,
+  skill: 3,
+};
 
 const SECRET_KEY_PATTERN = /(api[_-]?key|authorization|bearer|cookie|password|passwd|secret|token|credential|private[_-]?key)/i;
 
@@ -42,6 +48,76 @@ function bundleId() {
   return `agent-bundle-${crypto.randomUUID()}`;
 }
 
+function stableDigest(value) {
+  return crypto.createHash('sha256')
+    .update(typeof value === 'string' ? value : JSON.stringify(value))
+    .digest('hex')
+    .slice(0, 16);
+}
+
+function graphElementId(type, id) {
+  return `${type}:${id}`;
+}
+
+function skillFingerprint(skill) {
+  if (typeof skill === 'string') {
+    const value = skill.trim();
+    return value ? `string:${value}` : '';
+  }
+  if (!isObject(skill)) return '';
+  const id = typeof skill.id === 'string' ? skill.id.trim() : '';
+  if (id) return `id:${id}`;
+  const path = typeof skill.path === 'string' ? skill.path.trim() : '';
+  if (path) return `path:${path}`;
+  const name = typeof skill.name === 'string' ? skill.name.trim() : '';
+  const content = typeof skill.content === 'string' ? skill.content.trim() : '';
+  if (name && content) return `name-content:${name}:${content}`;
+  if (name) return `name:${name}`;
+  if (content) return `content:${content}`;
+  return `json:${JSON.stringify(skill)}`;
+}
+
+function skillElementId(skill) {
+  const fingerprint = skillFingerprint(skill);
+  return fingerprint ? graphElementId('skill', stableDigest(fingerprint)) : '';
+}
+
+function skillLabel(skill) {
+  if (typeof skill === 'string') return skill.trim() || 'Skill';
+  if (!isObject(skill)) return 'Skill';
+  const id = typeof skill.id === 'string' ? skill.id.trim() : '';
+  const name = typeof skill.name === 'string' ? skill.name.trim() : '';
+  const path = typeof skill.path === 'string' ? skill.path.trim() : '';
+  if (name) return name;
+  if (path) return path.split('/').filter(Boolean).pop() || path;
+  if (id) return id;
+  const content = typeof skill.content === 'string' ? skill.content.trim() : '';
+  return content.slice(0, 60) || 'Skill';
+}
+
+function compareGraphElements(left, right) {
+  const order = (GRAPH_ELEMENT_ORDER[left.type] || 99) - (GRAPH_ELEMENT_ORDER[right.type] || 99);
+  if (order !== 0) return order;
+  return String(left.id).localeCompare(String(right.id));
+}
+
+function compareGraphEdges(left, right) {
+  return String(left.from).localeCompare(String(right.from))
+    || String(left.kind).localeCompare(String(right.kind))
+    || String(left.to).localeCompare(String(right.to));
+}
+
+function pushGraphElement(elements, element) {
+  if (!element?.id) return;
+  if (!elements.has(element.id)) elements.set(element.id, element);
+}
+
+function pushGraphEdge(edges, edge) {
+  if (!edge?.from || !edge?.to || !edge?.kind) return;
+  const key = `${edge.from}::${edge.kind}::${edge.to}`;
+  if (!edges.has(key)) edges.set(key, edge);
+}
+
 function portableAgent(agent) {
   return {
     sourceAgentId: agent.id,
@@ -108,14 +184,185 @@ function countHooks(bundleAgents) {
 }
 
 function collectSkillRecords(bundleAgents) {
-  const byId = new Map();
+  const byKey = new Map();
   for (const entry of bundleAgents) {
     for (const skill of entry.config.skills || []) {
-      if (!skill?.id) continue;
-      byId.set(skill.id, cloneJson(skill));
+      const key = skillFingerprint(skill);
+      if (!key) continue;
+      byKey.set(key, cloneJson(skill));
     }
   }
-  return [...byId.values()];
+  return [...byKey.values()];
+}
+
+function buildFlatAgentBundleGraph(bundle) {
+  const elements = new Map();
+  const edges = new Map();
+  const toolMap = new Map((Array.isArray(bundle.tools) ? bundle.tools : []).map((tool) => [tool.id, tool]));
+  const toolActionMap = new Map((Array.isArray(bundle.toolActions) ? bundle.toolActions : []).map((action) => [action.id, action]));
+  const systemToolIds = new Set(uniqueStrings(bundle.requires?.systemTools));
+  const missingToolIds = new Set(uniqueStrings(bundle.requires?.missingTools));
+  const skills = collectSkillRecords(bundle.agents || []);
+
+  for (const entry of bundle.agents || []) {
+    const currentAgentId = agentEntryId(entry);
+    if (!currentAgentId) continue;
+    pushGraphElement(elements, {
+      id: graphElementId('agent', currentAgentId),
+      type: 'agent',
+      label: entry.agent?.name || currentAgentId,
+      data: {
+        sourceAgentId: currentAgentId,
+        agent: cloneJson(entry.agent || {}),
+        config: cloneJson(normalizeAgentConfig(entry.config || {})),
+      },
+    });
+  }
+
+  for (const skill of skills) {
+    const elementId = skillElementId(skill);
+    if (!elementId) continue;
+    pushGraphElement(elements, {
+      id: elementId,
+      type: 'skill',
+      label: skillLabel(skill),
+      data: typeof skill === 'string' ? { value: skill } : cloneJson(skill),
+    });
+  }
+
+  const includedToolIds = new Set();
+  const includedActionIds = new Set();
+  for (const entry of bundle.agents || []) {
+    const currentAgentId = agentEntryId(entry);
+    if (!currentAgentId) continue;
+    const currentConfig = normalizeAgentConfig(entry.config || {});
+
+    for (const subagent of currentConfig.subagents || []) {
+      if (!subagent?.agentId) continue;
+      pushGraphEdge(edges, {
+        from: graphElementId('agent', currentAgentId),
+        to: graphElementId('agent', subagent.agentId),
+        kind: 'uses-subagent',
+      });
+    }
+
+    for (const selectedId of uniqueStrings(currentConfig.loadout?.toolIds)) {
+      const selectedAction = toolActionMap.get(selectedId);
+      if (selectedAction) {
+        includedActionIds.add(selectedAction.id);
+        includedToolIds.add(selectedAction.toolId);
+        pushGraphEdge(edges, {
+          from: graphElementId('agent', currentAgentId),
+          to: graphElementId('tool_action', selectedAction.id),
+          kind: 'uses-tool-action',
+        });
+        continue;
+      }
+
+      includedToolIds.add(selectedId);
+      pushGraphEdge(edges, {
+        from: graphElementId('agent', currentAgentId),
+        to: graphElementId('tool', selectedId),
+        kind: 'uses-tool',
+      });
+    }
+
+    for (const skill of currentConfig.skills || []) {
+      const targetId = skillElementId(skill);
+      if (!targetId) continue;
+      pushGraphEdge(edges, {
+        from: graphElementId('agent', currentAgentId),
+        to: targetId,
+        kind: 'uses-skill',
+      });
+    }
+  }
+
+  for (const toolId of includedToolIds) {
+    const tool = toolMap.get(toolId);
+    pushGraphElement(elements, {
+      id: graphElementId('tool', toolId),
+      type: 'tool',
+      label: tool?.name || toolId,
+      data: tool
+        ? cloneJson(tool)
+        : {
+            id: toolId,
+            name: toolId,
+            origin: systemToolIds.has(toolId) ? 'system' : missingToolIds.has(toolId) ? 'missing' : 'unknown',
+          },
+    });
+  }
+
+  for (const action of Array.isArray(bundle.toolActions) ? bundle.toolActions : []) {
+    if (!includedToolIds.has(action.toolId)) continue;
+    includedActionIds.add(action.id);
+    pushGraphElement(elements, {
+      id: graphElementId('tool_action', action.id),
+      type: 'tool_action',
+      label: action.name || action.id,
+      data: cloneJson(action),
+    });
+    pushGraphEdge(edges, {
+      from: graphElementId('tool_action', action.id),
+      to: graphElementId('tool', action.toolId),
+      kind: 'action-of',
+    });
+  }
+
+  const firstAgentId = agentEntryId(bundle.agents?.[0]);
+  const rootAgentId = typeof bundle.rootAgentId === 'string' && bundle.rootAgentId.trim()
+    ? bundle.rootAgentId.trim()
+    : firstAgentId;
+
+  return {
+    headIds: rootAgentId ? [graphElementId('agent', rootAgentId)] : [],
+    elements: [...elements.values()].sort(compareGraphElements),
+    edges: [...edges.values()].sort(compareGraphEdges),
+  };
+}
+
+function assertClosedFlatBundleGraph(bundle) {
+  if (!Array.isArray(bundle.headIds) || bundle.headIds.length === 0) {
+    throw new Error('bundle graph must include at least one head');
+  }
+
+  const elementIds = new Set();
+  for (const element of Array.isArray(bundle.elements) ? bundle.elements : []) {
+    if (!isObject(element) || typeof element.id !== 'string' || !element.id.trim()) {
+      throw new Error('bundle graph elements must include non-empty ids');
+    }
+    if (elementIds.has(element.id)) {
+      throw new Error(`bundle graph contains duplicate element id: ${element.id}`);
+    }
+    elementIds.add(element.id);
+  }
+
+  for (const headId of bundle.headIds) {
+    if (typeof headId !== 'string' || !elementIds.has(headId)) {
+      throw new Error(`bundle graph head is missing element: ${headId}`);
+    }
+  }
+
+  for (const edge of Array.isArray(bundle.edges) ? bundle.edges : []) {
+    if (!isObject(edge) || typeof edge.from !== 'string' || typeof edge.to !== 'string' || typeof edge.kind !== 'string') {
+      throw new Error('bundle graph edges must include from, to, and kind');
+    }
+    if (!elementIds.has(edge.from)) throw new Error(`bundle graph edge source is missing element: ${edge.from}`);
+    if (!elementIds.has(edge.to)) throw new Error(`bundle graph edge target is missing element: ${edge.to}`);
+  }
+}
+
+function withBundleGraph(bundle) {
+  const graph = buildFlatAgentBundleGraph(bundle);
+  const nextBundle = {
+    ...bundle,
+    headIds: graph.headIds,
+    elements: graph.elements,
+    edges: graph.edges,
+  };
+  assertClosedFlatBundleGraph(nextBundle);
+  return nextBundle;
 }
 
 function collectToolRecords(toolIds, requires) {
@@ -210,7 +457,7 @@ function createAgentBundle(agentId, options = {}) {
     ...(tools.length > 0 ? ['Tools can call external services or local commands. Recipients should reconnect credentials on their own machine.'] : []),
   ];
 
-  const bundle = {
+  const bundle = withBundleGraph({
     kind: BUNDLE_KIND,
     schemaVersion: BUNDLE_SCHEMA_VERSION,
     bundleId: options.bundleId || bundleId(),
@@ -233,7 +480,7 @@ function createAgentBundle(agentId, options = {}) {
       hooks,
       assets: 0,
     },
-  };
+  });
 
   const bytes = Buffer.byteLength(JSON.stringify(bundle));
   return {
@@ -330,7 +577,7 @@ function validateBundle(bundle) {
     throw new Error('bundle must include at least one agent');
   }
   assertClosedAgentBundleGraph(bundle);
-  return bundle;
+  return withBundleGraph(bundle);
 }
 
 function installTools(bundle) {

package/runtime/scripts/amalgm-mcp/tests/agent-bundles.test.js

@@ -83,6 +83,27 @@ test('agent bundle includes recursive subagents, selected user tools, and warnin
   assert.deepEqual(bundle.agents.map((entry) => entry.sourceAgentId), [root.id, child.id]);
   assert.deepEqual(bundle.tools.map((tool) => tool.id), ['acme.cli']);
   assert.deepEqual(bundle.toolActions.map((action) => action.id), ['acme.cli.run']);
+  assert.deepEqual(bundle.headIds, ['agent:bundle-root']);
+  assert.equal(bundle.elements.some((element) => element.id === 'agent:bundle-root' && element.type === 'agent'), true);
+  assert.equal(bundle.elements.some((element) => element.id === 'agent:bundle-child' && element.type === 'agent'), true);
+  assert.equal(bundle.elements.some((element) => element.id === 'tool:acme.cli' && element.type === 'tool'), true);
+  assert.equal(bundle.elements.some((element) => element.id === 'tool:browser' && element.type === 'tool'), true);
+  assert.equal(bundle.elements.some((element) => element.id === 'tool_action:acme.cli.run' && element.type === 'tool_action'), true);
+  assert.equal(bundle.edges.some((edge) => (
+    edge.from === 'agent:bundle-root'
+    && edge.to === 'agent:bundle-child'
+    && edge.kind === 'uses-subagent'
+  )), true);
+  assert.equal(bundle.edges.some((edge) => (
+    edge.from === 'agent:bundle-root'
+    && edge.to === 'tool:acme.cli'
+    && edge.kind === 'uses-tool'
+  )), true);
+  assert.equal(bundle.edges.some((edge) => (
+    edge.from === 'agent:bundle-child'
+    && edge.to === 'tool:browser'
+    && edge.kind === 'uses-tool'
+  )), true);
   assert.equal(bundle.skills.length, 1);
   assert.equal(bundle.summary.hooks, 1);
   assert.equal(bundle.requires.systemTools.includes('browser'), true);
@@ -134,6 +155,7 @@ test('installing an agent bundle creates local copies and rewrites subagent refs
   assert.equal(installedRootConfig.subagents.length, 1);
   assert.notEqual(installedRootConfig.subagents[0].agentId, child.id);
   assert.equal(Boolean(resolveAgent(installedRootConfig.subagents[0].agentId)), true);
+  assert.deepEqual(bundle.headIds, ['agent:install-source-root']);
 });
 
 test('installing an agent bundle rejects missing shared subagents', () => {
@@ -165,3 +187,31 @@ test('installing an agent bundle rejects missing shared subagents', () => {
     /missing shared subagents: missing-child/,
   );
 });
+
+test('installing an agent bundle regenerates stale flat graph fields from canonical agent arrays', () => {
+  const result = installAgentBundle({
+    kind: 'amalgm.agent.bundle',
+    schemaVersion: 1,
+    rootAgentId: 'graph-root',
+    title: 'Graph root',
+    agents: [{
+      sourceAgentId: 'graph-root',
+      agent: {
+        name: 'Graph root',
+        baseHarnessId: 'codex',
+        baseModelId: 'openai/gpt-5.5',
+      },
+      config: {
+        instructions: 'Root',
+        loadout: { toolIds: [] },
+        subagents: [],
+      },
+    }],
+    headIds: ['agent:graph-root'],
+    elements: [{ id: 'agent:graph-root', type: 'agent', label: 'Graph root', data: {} }],
+    edges: [{ from: 'agent:graph-root', to: 'tool:missing', kind: 'uses-tool' }],
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(Boolean(resolveAgent(result.rootAgentId)), true);
+});