amalgm 0.1.79 → 0.1.80

package/runtime/scripts/chat-core/chat-payload.js

@@ -0,0 +1,165 @@
+'use strict';
+
+const { chatInputToLegacyFields, normalizeChatInput } = require('../../lib/chatInput');
+const { getChatPayload } = require('../amalgm-mcp/lib/chat-payloads');
+const { buildLocalMcpServerConfigs } = require('../amalgm-mcp/lib/mcp-resolver');
+const { normalizeLoadout } = require('../amalgm-mcp/agent-config/loadout');
+
+function isObject(value) {
+  return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function nullableString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function uniqueStrings(value) {
+  if (!Array.isArray(value)) return [];
+  return [...new Set(value
+    .filter((item) => typeof item === 'string')
+    .map((item) => item.trim())
+    .filter(Boolean))];
+}
+
+function harnessToAgent(harness) {
+  if (harness === 'codex') return 'codex';
+  if (harness === 'opencode') return 'opencode';
+  return 'claude';
+}
+
+function applyPayloadRecord(body, record) {
+  const payload = isObject(record?.payload) ? record.payload : {};
+  const rawChatInput = isObject(body.chatInput) ? body.chatInput : {};
+  const rawAgent = isObject(rawChatInput.agent) ? rawChatInput.agent : {};
+  const rawTools = isObject(rawChatInput.tools) ? rawChatInput.tools : {};
+  const rawExecution = isObject(rawChatInput.execution) ? rawChatInput.execution : {};
+  const modelSettings = isObject(payload.modelSettings)
+    ? payload.modelSettings
+    : isObject(body.modelSettings)
+      ? body.modelSettings
+      : {};
+  const harness =
+    nullableString(payload.resolvedHarnessId)
+    || nullableString(payload.harness)
+    || nullableString(rawAgent.harness)
+    || nullableString(body.harness)
+    || 'claude_code';
+  const modelId =
+    nullableString(payload.modelId)
+    || nullableString(rawAgent.model)
+    || nullableString(body.modelId)
+    || nullableString(body.model);
+  const authMethod =
+    nullableString(payload.authMethod)
+    || nullableString(rawAgent.authMethod)
+    || nullableString(body.authMethod);
+  const customAgentId =
+    nullableString(payload.customAgentId)
+    || nullableString(rawAgent.customAgentId);
+  const systemPrompt =
+    nullableString(payload.systemPrompt)
+    || nullableString(rawAgent.systemPrompt)
+    || nullableString(body.systemPrompt);
+  const cwd =
+    nullableString(body.cwd)
+    || nullableString(rawExecution.cwd)
+    || nullableString(payload.cwd);
+  const computerId =
+    nullableString(payload.machineId)
+    || nullableString(body.computerId)
+    || nullableString(rawExecution.computerId)
+    || nullableString(process.env.AMALGM_COMPUTER_ID)
+    || nullableString(process.env.AMALGM_CONTAINER_ID);
+  const mcpAppIds = uniqueStrings(payload.mcpAppIds);
+  const toolIds = normalizeLoadout(payload.loadout || payload.tools).toolIds;
+  const chatInput = normalizeChatInput({
+    ...rawChatInput,
+    agent: {
+      ...rawAgent,
+      harness,
+      ...(modelId ? { model: modelId } : {}),
+      ...(authMethod ? { authMethod } : {}),
+      customAgentId,
+      systemPrompt,
+    },
+    tools: {
+      ...rawTools,
+      mcpAppIds,
+      toolIds,
+    },
+    execution: {
+      ...rawExecution,
+      cwd,
+      computerId,
+    },
+  }, {
+    prompt: body.prompt,
+    userParts: body.userParts,
+    harness,
+    modelId,
+    authMethod,
+    cwd,
+    computerId,
+    mcpAppIds,
+    systemPrompt,
+  });
+  const legacy = chatInputToLegacyFields(chatInput, { prompt: body.prompt });
+  const reasoningEffort =
+    nullableString(modelSettings.effort)
+    || nullableString(modelSettings.reasoningEffort)
+    || nullableString(modelSettings.reasoning);
+
+  const next = {
+    ...body,
+    chatInput,
+    ...legacy,
+    harness,
+    ...(modelId ? { modelId, model: modelId } : {}),
+    ...(authMethod ? { authMethod } : {}),
+    ...(systemPrompt ? { systemPrompt } : {}),
+    ...(cwd ? { cwd, projectPath: cwd } : {}),
+    ...(computerId ? { computerId } : {}),
+    mcpAppIds,
+    modelSettings,
+    agentId: customAgentId || harnessToAgent(harness),
+    ...(customAgentId ? { agentConfigId: customAgentId } : {}),
+    ...(reasoningEffort ? { reasoningEffort } : {}),
+    ...(modelSettings.fastMode === true ? { fastMode: true } : {}),
+  };
+
+  delete next.cliModel;
+  delete next.internalModelId;
+  delete next.contextWindow;
+  delete next.maxTokens;
+  return next;
+}
+
+async function resolveMachineChatPayload(body) {
+  const payloadId = nullableString(body?.chatPayloadId);
+  if (!payloadId) return body;
+
+  const record = getChatPayload(payloadId);
+  if (!record || !isObject(record.payload)) {
+    throw Object.assign(new Error(`Chat payload not found: ${payloadId}`), { status: 404 });
+  }
+
+  const expectedRevision = nullableString(body.chatPayloadRevision);
+  const actualRevision = nullableString(record.revision);
+  if (expectedRevision && actualRevision && expectedRevision !== actualRevision) {
+    throw Object.assign(
+      new Error('Chat payload changed before launch; retry with the latest machine payload.'),
+      { status: 409 },
+    );
+  }
+
+  const resolved = applyPayloadRecord(body, record);
+  return {
+    ...resolved,
+    mcpServers: await buildLocalMcpServerConfigs(resolved.mcpAppIds || []),
+  };
+}
+
+module.exports = {
+  applyPayloadRecord,
+  resolveMachineChatPayload,
+};

package/runtime/scripts/chat-core/server.js

@@ -12,6 +12,7 @@ const { forwardMcpRelay, parseMcpRelayPath } = require('./tooling/mcp-relay');
 const { RuntimeController } = require('./runtime');
 const { writeChatStream, writeRawTempStream } = require('./streams');
 const { TurnStore } = require('./stores');
+const { resolveMachineChatPayload } = require('./chat-payload');
 const { authorizeRuntimeHttp } = require('../runtime-auth');
 
 function readBody(req) {
@@ -108,12 +109,13 @@ function createServer(core = createCore()) {
       }
       if (route.handler === 'chat') {
         if (req.method !== 'POST') return sendJson(res, 405, { error: 'Method not allowed' });
-        const payload = await readBody(req);
+        const payload = await resolveMachineChatPayload(await readBody(req));
         return await writeChatStream(core, payload, res);
       }
     } catch (err) {
       console.error('[ChatCore] error:', err);
-      if (!res.headersSent) sendJson(res, 500, { error: err.message || 'Internal server error' });
+      const status = Number.isInteger(err?.status) ? err.status : 500;
+      if (!res.headersSent) sendJson(res, status, { error: err.message || 'Internal server error' });
       else {
         res.write(`data: ${JSON.stringify({ _type: 'error', message: err.message || 'Internal server error' })}\n\n`);
         res.write(`data: ${JSON.stringify({ _type: 'complete', stopReason: 'error' })}\n\n`);

package/runtime/scripts/chat-core/tests/chat-payload.test.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-chat-core-payload-test-'));
+process.env.AMALGM_DIR = path.join(tempRoot, '.amalgm');
+process.env.AMALGM_COMPUTER_ID = 'machine-local';
+
+const { closeLocalDb } = require('../../amalgm-mcp/state/db');
+const { writeChatPayload } = require('../../amalgm-mcp/lib/chat-payloads');
+const { resolveMachineChatPayload } = require('../chat-payload');
+
+test.after(() => {
+  closeLocalDb();
+  fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+test('chat-core resolves launch payload from the local machine cache', async () => {
+  writeChatPayload({
+    id: 'chat-view:test',
+    revision: 'rev-1',
+    payload: {
+      machineId: 'machine-local',
+      harness: 'codex',
+      resolvedHarnessId: 'codex',
+      modelId: 'openai/gpt-5.5',
+      modelSettings: { effort: 'high', fastMode: true },
+      authMethod: 'amalgm',
+      cwd: '/tmp/amalgm-project',
+      customAgentId: null,
+      systemPrompt: 'local payload prompt',
+      mcpAppIds: [],
+      loadout: { toolIds: ['tool.search'] },
+      pendingWorktree: false,
+    },
+  });
+
+  const resolved = await resolveMachineChatPayload({
+    chatPayloadId: 'chat-view:test',
+    chatPayloadRevision: 'rev-1',
+    prompt: 'hello',
+    chatInput: {
+      parts: [{ type: 'text', text: 'hello' }],
+      agent: {},
+      tools: {},
+      execution: {},
+    },
+  });
+
+  assert.equal(resolved.harness, 'codex');
+  assert.equal(resolved.modelId, 'openai/gpt-5.5');
+  assert.equal(resolved.authMethod, 'amalgm');
+  assert.equal(resolved.cwd, '/tmp/amalgm-project');
+  assert.equal(resolved.computerId, 'machine-local');
+  assert.equal(resolved.reasoningEffort, 'high');
+  assert.equal(resolved.fastMode, true);
+  assert.deepEqual(resolved.chatInput.tools.toolIds, ['tool.search']);
+  assert.deepEqual(resolved.mcpServers, []);
+  assert.equal(resolved.cliModel, undefined);
+});
+
+test('chat-core rejects stale chat payload revisions', async () => {
+  await assert.rejects(
+    () => resolveMachineChatPayload({
+      chatPayloadId: 'chat-view:test',
+      chatPayloadRevision: 'rev-stale',
+      prompt: 'hello',
+    }),
+    (error) => {
+      assert.equal(error.status, 409);
+      return true;
+    },
+  );
+});

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

@@ -1,42 +0,0 @@
-'use strict';
-
-const FIRST_PARTY_TOOL_IDS = new Set([
-  'automations',
-  'notifications',
-  'agents',
-  'apps',
-  'browser',
-]);
-
-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 selectedHas(selectedToolIds, id) {
-  if (!id) return false;
-  if (selectedToolIds.has(id)) return true;
-  const value = String(id || '').trim();
-  const toolId = value.split('.')[0];
-  if (FIRST_PARTY_TOOL_IDS.has(toolId) && selectedToolIds.has(`amalgm.${value}`)) return true;
-  if (value === 'notifications.notify_user' && selectedToolIds.has('amalgm.notify_user')) return true;
-  if (value === 'agents.talk_to_agent' && selectedToolIds.has('amalgm.talk_to_agent')) return true;
-  if (FIRST_PARTY_TOOL_IDS.has(value) && selectedToolIds.has(`amalgm.${value}`)) return true;
-  return false;
-}
-
-function selectedContainsToolOrAction(selectedToolIds, toolId, actionId) {
-  if (!selectedToolIds) return true;
-  return selectedHas(selectedToolIds, toolId) || selectedHas(selectedToolIds, actionId);
-}
-
-module.exports = {
-  selectedContainsToolOrAction,
-  selectedToolIdsForContext,
-};