amalgm 0.0.0 → 0.0.32

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

@@ -0,0 +1,343 @@
+'use strict';
+
+const { calculateCost } = require('../chat-server/model-catalog');
+const {
+  PROXY_BASE_URL,
+  PROXY_TOKEN,
+  ensureFreshProxyToken,
+  readProxyToken,
+} = require('../chat-server/config');
+
+function n(value) {
+  const parsed = Number(value || 0);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function normalizeTokenList(input = {}) {
+  const tokenList = input.tokenList && typeof input.tokenList === 'object' ? input.tokenList : {};
+  const inputTokens = n(tokenList.input ?? tokenList.inputTokens ?? input.inputTokens);
+  const outputTokens = n(tokenList.output ?? tokenList.outputTokens ?? input.outputTokens);
+  const cacheReadTokens = n(tokenList.cacheRead ?? tokenList.cacheReadTokens ?? input.cacheReadTokens);
+  const cacheWriteTokens = n(tokenList.cacheWrite ?? tokenList.cacheWriteTokens ?? input.cacheWriteTokens);
+  const thoughtTokens = n(tokenList.thought ?? tokenList.thoughtTokens ?? input.thoughtTokens);
+  const computedTotal = inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens;
+  const total = nonNegativeOrNull(tokenList.total ?? tokenList.totalTokens ?? input.totalTokens)
+    ?? computedTotal;
+  return {
+    input: inputTokens,
+    output: outputTokens,
+    cacheRead: cacheReadTokens,
+    cacheWrite: cacheWriteTokens,
+    thought: thoughtTokens,
+    total,
+  };
+}
+
+function hasTokenListBuckets(tokenList = {}) {
+  return ['input', 'output', 'cacheRead', 'cacheWrite', 'thought', 'total']
+    .some((key) => Number.isFinite(Number(tokenList[key])));
+}
+
+function zeroTokenList() {
+  return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, thought: 0, total: 0 };
+}
+
+function addTokenLists(a = {}, b = {}) {
+  return normalizeTokenList({
+    inputTokens: n(a.input) + n(b.input),
+    outputTokens: n(a.output) + n(b.output),
+    cacheReadTokens: n(a.cacheRead) + n(b.cacheRead),
+    cacheWriteTokens: n(a.cacheWrite) + n(b.cacheWrite),
+    thoughtTokens: n(a.thought) + n(b.thought),
+  });
+}
+
+function subtractTokenLists(after = {}, before = {}) {
+  return normalizeTokenList({
+    inputTokens: Math.max(0, n(after.input) - n(before.input)),
+    outputTokens: Math.max(0, n(after.output) - n(before.output)),
+    cacheReadTokens: Math.max(0, n(after.cacheRead) - n(before.cacheRead)),
+    cacheWriteTokens: Math.max(0, n(after.cacheWrite) - n(before.cacheWrite)),
+    thoughtTokens: Math.max(0, n(after.thought) - n(before.thought)),
+  });
+}
+
+function normalizeUsage(input = {}) {
+  const cacheRead = n(input.cacheReadTokens ?? input.cachedInputTokens ?? input.cache_read_input_tokens);
+  const cacheWrite = n(input.cacheWriteTokens ?? input.cacheCreationInputTokens ?? input.cache_creation_input_tokens);
+  const output = n(input.outputTokens ?? input.completionTokens ?? input.output_tokens);
+  const thought = n(input.thoughtTokens ?? input.reasoningTokens);
+  const totalInput = input.totalInputTokens ?? input.promptTokens ?? (input.inputTokensAreTotal ? input.inputTokens : null);
+  const nonCachedInput = totalInput == null
+    ? n(input.inputTokens ?? input.input_tokens ?? input.nonCachedInputTokens)
+    : Math.max(0, n(totalInput) - cacheRead - cacheWrite);
+  const tokenList = normalizeTokenList({
+    tokenList: input.tokenList,
+    inputTokens: nonCachedInput,
+    outputTokens: output,
+    cacheReadTokens: cacheRead,
+    cacheWriteTokens: cacheWrite,
+    thoughtTokens: thought,
+  });
+  const inputContextSize = nonNegativeOrNull(input.inputContextSize ?? input.input_context_size)
+    ?? tokenList.total;
+  return {
+    tokenList,
+    cumulativeTokenList: input.cumulativeTokenList && typeof input.cumulativeTokenList === 'object'
+      ? normalizeTokenList({ tokenList: input.cumulativeTokenList })
+      : null,
+    previousCumulativeTokenList: input.previousCumulativeTokenList && typeof input.previousCumulativeTokenList === 'object'
+      ? normalizeTokenList({ tokenList: input.previousCumulativeTokenList })
+      : null,
+    inputTokens: nonCachedInput,
+    outputTokens: output,
+    cacheReadTokens: cacheRead,
+    cacheWriteTokens: cacheWrite,
+    thoughtTokens: thought,
+    inputContextSize,
+    contextUsedTokens: positiveOrNull(input.contextUsedTokens ?? input.usedTokens ?? inputContextSize),
+    contextLimit: positiveOrNull(input.contextLimit ?? input.maxTokens ?? input.modelContextWindow),
+    usedTokens: positiveOrNull(input.usedTokens ?? input.contextUsedTokens ?? inputContextSize),
+    lastUsedTokens: positiveOrNull(input.lastUsedTokens ?? input.contextUsedTokens ?? input.usedTokens ?? inputContextSize),
+    maxTokens: positiveOrNull(input.maxTokens ?? input.contextLimit ?? input.modelContextWindow),
+    totalProcessedTokens: positiveOrNull(input.totalProcessedTokens),
+    costUsd: input.costUsd ?? input.costUSD ?? input.cost ?? null,
+    marketCostUsd: input.marketCostUsd ?? null,
+    operation: String(input.operation || input.usageOperation || 'chat_step'),
+    billable: input.billable !== false,
+    source: input.source || 'runtime',
+    exact: input.exact === true,
+  };
+}
+
+function positiveOrNull(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+
+function nonNegativeOrNull(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
+}
+
+function totalUsageTokens(usage = {}) {
+  return n(usage.tokenList?.total)
+    || n(usage.inputContextSize)
+    || n(usage.inputTokens) + n(usage.outputTokens) + n(usage.cacheReadTokens) + n(usage.cacheWriteTokens);
+}
+
+async function currentProxyToken(options = {}) {
+  if (typeof ensureFreshProxyToken === 'function') {
+    try {
+      const fresh = await ensureFreshProxyToken(options);
+      if (fresh) return fresh;
+    } catch (err) {
+      console.warn('[ChatCore:Billing] Proxy token refresh failed:', err.message);
+    }
+  }
+  if (typeof readProxyToken === 'function') {
+    const stored = readProxyToken();
+    if (stored) return stored;
+  }
+  return PROXY_TOKEN || '';
+}
+
+async function beginProxyTurn(contract) {
+  if (contract.authMethod !== 'amalgm') {
+    return { skipped: true, reason: 'not_amalgm' };
+  }
+
+  const baseUrl = String(PROXY_BASE_URL || '').replace(/\/$/, '');
+  let token = await currentProxyToken();
+  if (!baseUrl || !token) {
+    throw Object.assign(new Error('Amalgm proxy billing is not configured'), {
+      status: 503,
+      code: 'AMALGM_PROXY_NOT_CONFIGURED',
+    });
+  }
+
+  const bodyPayload = {
+      sessionId: contract.sessionId,
+      messageId: contract.assistantMessageId,
+      agentId: contract.agentId,
+      harnessId: contract.harness,
+      authMethod: contract.authMethod,
+      usageOwner: contract.usageOwner || 'platform_proxy',
+      modelId: contract.usageModelId || contract.modelId,
+      internalModelId: contract.modelId,
+      cliModel: contract.cliModel,
+      contextWindow: contract.contextWindow ?? null,
+      maxTokens: contract.maxTokens ?? null,
+      cwd: contract.cwd,
+      mcpServers: contract.mcpServers,
+  };
+
+  const requestTurnStart = (authToken) => fetch(`${baseUrl}/internal/turn-start`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${authToken}`,
+    },
+    body: JSON.stringify(bodyPayload),
+  });
+
+  let response = await requestTurnStart(token);
+  if (response.status === 401) {
+    console.warn('[ChatCore:Billing] turn-start got 401; refreshing proxy token and retrying once');
+    token = await currentProxyToken({ force: true });
+    if (token) response = await requestTurnStart(token);
+  }
+
+  const body = await response.json().catch(() => null);
+  if (!response.ok) {
+    const message = body?.message || body?.error || `Amalgm turn start failed (${response.status})`;
+    throw Object.assign(new Error(message), {
+      status: response.status,
+      code: body?.error || 'AMALGM_TURN_START_FAILED',
+      balanceUsd: body?.balanceUsd,
+    });
+  }
+
+  return body || { ok: true };
+}
+
+function providerFromModel(modelId) {
+  return typeof modelId === 'string' && modelId.includes('/') ? modelId.split('/')[0] : null;
+}
+
+function usageFromTokenList(tokenList, base = {}) {
+  const normalized = normalizeTokenList({ tokenList });
+  return normalizeUsage({
+    ...base,
+    tokenList: normalized,
+    inputTokens: normalized.input,
+    outputTokens: normalized.output,
+    cacheReadTokens: normalized.cacheRead,
+    cacheWriteTokens: normalized.cacheWrite,
+    thoughtTokens: normalized.thought,
+    inputContextSize: base.inputContextSize ?? normalized.total,
+    operation: 'chat_turn',
+    billable: true,
+    exact: true,
+  });
+}
+
+function summedTurnUsage(records, base = {}) {
+  const sum = records.reduce((acc, entry) => addTokenLists(acc, entry.tokenList), zeroTokenList());
+  if (!hasTokenListBuckets(sum) || sum.total <= 0) return null;
+  return usageFromTokenList(sum, {
+    ...base,
+    source: base.source || 'turn_sum',
+  });
+}
+
+function codexTurnUsage(records, base = {}) {
+  const cumulativeRecords = records.filter((entry) => (
+    entry?.cumulativeTokenList
+    && hasTokenListBuckets(entry.cumulativeTokenList)
+    && entry.cumulativeTokenList.total > 0
+  ));
+  if (cumulativeRecords.length > 0) {
+    const first = cumulativeRecords[0];
+    const last = cumulativeRecords[cumulativeRecords.length - 1];
+    const baseline = first.previousCumulativeTokenList && hasTokenListBuckets(first.previousCumulativeTokenList)
+      ? first.previousCumulativeTokenList
+      : zeroTokenList();
+    const delta = subtractTokenLists(last.cumulativeTokenList, baseline);
+    if (delta.total > 0) {
+      return usageFromTokenList(delta, {
+        ...base,
+        inputContextSize: last.inputContextSize,
+        contextLimit: last.contextLimit,
+        totalProcessedTokens: last.cumulativeTokenList.total,
+        source: 'codex_app_server_turn_delta',
+      });
+    }
+  }
+  return summedTurnUsage(records.filter((entry) => entry.exact === true), {
+    ...base,
+    source: 'codex_app_server_step_sum',
+  });
+}
+
+function finalizeTurnUsage({ contract, usage, usageRecords } = {}) {
+  const records = Array.isArray(usageRecords) && usageRecords.length > 0
+    ? usageRecords
+    : usage
+      ? [usage]
+      : [];
+
+  if (contract?.harness === 'codex') {
+    const codexUsage = codexTurnUsage(records, {
+      contextLimit: usage?.contextLimit,
+      inputContextSize: usage?.inputContextSize,
+      costUsd: null,
+      marketCostUsd: null,
+    });
+    if (codexUsage) return codexUsage;
+  }
+
+  const billableRecords = records.filter((entry) => entry && entry.billable !== false);
+  if (billableRecords.length === 0) return null;
+
+  const base = {
+    contextLimit: usage?.contextLimit,
+    inputContextSize: usage?.inputContextSize,
+    costUsd: null,
+    marketCostUsd: null,
+  };
+
+  const exactTurnRecord = billableRecords.find((entry) => (
+    entry.exact === true && entry.operation === 'chat_turn' && entry.tokenList?.total > 0
+  ));
+  if (exactTurnRecord) {
+    return usageFromTokenList(exactTurnRecord.tokenList, {
+      ...base,
+      inputContextSize: exactTurnRecord.inputContextSize,
+      contextLimit: exactTurnRecord.contextLimit,
+      totalProcessedTokens: exactTurnRecord.totalProcessedTokens,
+      source: exactTurnRecord.source || 'native_chat_turn',
+    });
+  }
+  return summedTurnUsage(billableRecords.filter((entry) => entry.exact === true), base);
+}
+
+async function logTurnUsage({ db, contract, messageId, usage, usageRecords }) {
+  if (contract.authMethod === 'amalgm') {
+    return { skipped: true, source: 'proxy_owned_provider_usage', reason: 'proxy_persists_usage_immediately' };
+  }
+
+  const turnUsage = finalizeTurnUsage({ contract, usage, usageRecords });
+  if (!turnUsage) return { skipped: true, reason: 'no_turn_usage' };
+  const marketCostUsd = turnUsage.marketCostUsd ?? calculateCost(
+    contract.usageModelId || contract.modelId,
+    turnUsage.inputTokens,
+    turnUsage.outputTokens,
+    turnUsage.cacheReadTokens,
+    turnUsage.cacheWriteTokens,
+  );
+  await db.logUsage({
+    userId: contract.userId,
+    sessionId: contract.sessionId,
+    messageId,
+    agentId: contract.agentId,
+    harnessId: contract.harness,
+    authMethod: contract.authMethod,
+    modelId: contract.usageModelId || contract.modelId,
+    usage: turnUsage,
+    marketCostUsd,
+  });
+  return { skipped: false, source: 'local_turn_exact', count: 1 };
+}
+
+module.exports = {
+  addTokenLists,
+  beginProxyTurn,
+  finalizeTurnUsage,
+  logTurnUsage,
+  normalizeTokenList,
+  normalizeUsage,
+  providerFromModel,
+  subtractTokenLists,
+  totalUsageTokens,
+};

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

@@ -0,0 +1,110 @@
+/**
+ * Configuration — env vars, constants, proxy URLs.
+ *
+ * Single source of truth for all chat-server configuration.
+ * No business logic here — just read env, compute derived values, export.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const {
+  DEFAULT_PROXY_BASE_URL,
+  ensureFreshProxyToken,
+  proxyBaseUrl,
+  readProxyToken,
+} = require('../proxy-token-store');
+
+// ── Paths ──────────────────────────────────────────────────────────────────
+// Set by the orchestrator (entrypoint.sh or electron/main.ts).
+// The code never decides these — it just reads them.
+
+const AMALGM_DIR = process.env.AMALGM_DIR || path.join(os.homedir(), '.amalgm');
+const DEFAULT_CWD = process.env.AMALGM_DEFAULT_CWD || '/workspace';
+
+// ── Server ──────────────────────────────────────────────────────────────────
+
+const PORT = parseInt(process.env.CHAT_SERVER_PORT || '8084', 10);
+const BIND_HOST = process.env.AMALGM_BIND_HOST || '0.0.0.0';
+
+// ── API keys / proxy ────────────────────────────────────────────────────────
+
+const RAW_OPENAI_API_KEY = process.env.OPENAI_API_KEY || '';
+const OPENAI_API_KEY_TITLE = /^sk-/.test(RAW_OPENAI_API_KEY) ? RAW_OPENAI_API_KEY : '';
+const AI_GATEWAY_API_KEY_TITLE = process.env.AI_GATEWAY_API_KEY || process.env.VERCEL_AI_GATEWAY_API_KEY || '';
+const AI_GATEWAY_URL_TITLE = process.env.AI_GATEWAY_URL || 'https://ai-gateway.vercel.sh';
+
+// All sensitive keys live on the API proxy (Fly.io). Containers get an HMAC proxy token.
+const PROXY_TOKEN = readProxyToken()
+  || (process.env.AMALGM_RUNTIME_SOURCE === 'npm' ? '' : process.env.ANTHROPIC_API_KEY || '');
+const PROXY_BASE_URL = proxyBaseUrl() || (PROXY_TOKEN ? DEFAULT_PROXY_BASE_URL : '');
+const OPENAI_PROXY_URL = PROXY_BASE_URL ? `${PROXY_BASE_URL}/openai` : '';
+const AI_GATEWAY_PROXY_URL = PROXY_BASE_URL ? `${PROXY_BASE_URL}/ai_gateway/v1` : '';
+const SUPABASE_PROXY_URL = PROXY_BASE_URL ? `${PROXY_BASE_URL}/supabase` : '';
+
+// ── Supabase ────────────────────────────────────────────────────────────────
+
+const SUPABASE_URL_DIRECT = process.env.SUPABASE_URL || process.env.NEXT_PUBLIC_SUPABASE_URL || '';
+const SUPABASE_KEY_DIRECT = process.env.SUPABASE_SERVICE_ROLE_KEY || '';
+
+// Prefer direct Supabase when service-role creds are available (local dev / tests).
+// The proxy is only needed when SUPABASE_KEY_DIRECT is unavailable (in-container runs).
+const SUPABASE_USES_DIRECT = !!(SUPABASE_URL_DIRECT && SUPABASE_KEY_DIRECT);
+const SUPABASE_URL = SUPABASE_USES_DIRECT ? SUPABASE_URL_DIRECT : (SUPABASE_PROXY_URL || SUPABASE_URL_DIRECT);
+const SUPABASE_AUTH_HEADERS = SUPABASE_USES_DIRECT
+  ? { apikey: SUPABASE_KEY_DIRECT, Authorization: `Bearer ${SUPABASE_KEY_DIRECT}` }
+  : (SUPABASE_PROXY_URL
+      ? { Authorization: `Bearer ${PROXY_TOKEN}` }
+      : { apikey: SUPABASE_KEY_DIRECT, Authorization: `Bearer ${SUPABASE_KEY_DIRECT}` });
+
+// ── Platform context (injected into every prompt) ───────────────────────────
+
+let PLATFORM_CONTEXT = '';
+try {
+  const ctxPath = path.join(__dirname, '..', 'platform-context.txt');
+  if (fs.existsSync(ctxPath)) {
+    PLATFORM_CONTEXT = fs.readFileSync(ctxPath, 'utf-8');
+  }
+} catch {
+  // Fall through — will use empty string
+}
+// Wrap in XML tags if loaded from file and not already wrapped
+if (PLATFORM_CONTEXT && !PLATFORM_CONTEXT.startsWith('<amalgm-platform>')) {
+  PLATFORM_CONTEXT = `<amalgm-platform>\n${PLATFORM_CONTEXT}\n</amalgm-platform>\n\n`;
+} else if (PLATFORM_CONTEXT) {
+  PLATFORM_CONTEXT = PLATFORM_CONTEXT + '\n\n';
+}
+
+// ── Startup log ─────────────────────────────────────────────────────────────
+
+console.log('[ChatServer] Config:', {
+  port: PORT,
+  bindHost: BIND_HOST,
+  proxyConfigured: !!PROXY_BASE_URL,
+  proxyBase: PROXY_BASE_URL || '(none)',
+  supabaseVia: SUPABASE_USES_DIRECT ? 'direct' : (SUPABASE_PROXY_URL ? 'proxy' : 'direct'),
+  titleVia: AI_GATEWAY_API_KEY_TITLE ? 'vercel_ai_sdk_gateway' : (AI_GATEWAY_PROXY_URL && PROXY_TOKEN ? 'ai_gateway_proxy' : (OPENAI_API_KEY_TITLE ? 'direct_openai' : 'disabled')),
+  amalgmDir: AMALGM_DIR,
+  defaultCwd: DEFAULT_CWD,
+  hasDirectOpenaiKey: !!OPENAI_API_KEY_TITLE,
+  hasPlatformContext: PLATFORM_CONTEXT.length > 0,
+});
+
+module.exports = {
+  PORT,
+  BIND_HOST,
+  OPENAI_API_KEY_TITLE,
+  AI_GATEWAY_API_KEY_TITLE,
+  AI_GATEWAY_URL_TITLE,
+  PROXY_TOKEN,
+  ensureFreshProxyToken,
+  readProxyToken,
+  PROXY_BASE_URL,
+  OPENAI_PROXY_URL,
+  AI_GATEWAY_PROXY_URL,
+  SUPABASE_URL,
+  SUPABASE_AUTH_HEADERS,
+  AMALGM_DIR,
+  DEFAULT_CWD,
+  PLATFORM_CONTEXT,
+};