amalgm 0.0.0 → 0.0.1

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

@@ -0,0 +1,529 @@
+/**
+ * Database — Supabase REST client, message persistence, title generation, history.
+ *
+ * All Supabase interactions live here. The rest of the server treats this
+ * as a black box: save message, load history, generate title.
+ */
+
+const {
+  SUPABASE_URL,
+  SUPABASE_AUTH_HEADERS,
+  PROXY_TOKEN,
+  ensureFreshProxyToken,
+  readProxyToken,
+  OPENAI_API_KEY_TITLE,
+  AI_GATEWAY_API_KEY_TITLE,
+  AI_GATEWAY_URL_TITLE,
+  OPENAI_PROXY_URL,
+  AI_GATEWAY_PROXY_URL,
+} = require('./config');
+
+// ── Supabase primitives ─────────────────────────────────────────────────────
+
+function usesSupabaseProxy() {
+  return Boolean(SUPABASE_URL && !SUPABASE_AUTH_HEADERS.apikey && /\/supabase\/?$/.test(SUPABASE_URL));
+}
+
+function hasSupabase() {
+  return !!(SUPABASE_URL && (SUPABASE_AUTH_HEADERS.apikey || PROXY_TOKEN || readProxyToken?.()));
+}
+
+async function currentSupabaseAuthHeaders({ forceRefresh = false } = {}) {
+  if (!usesSupabaseProxy()) return SUPABASE_AUTH_HEADERS;
+
+  let token = '';
+  try {
+    token = await ensureFreshProxyToken?.({ force: forceRefresh, logger: console }) || '';
+  } catch (err) {
+    console.warn('[DB] Proxy token refresh failed:', err.message);
+  }
+  token = token || readProxyToken?.() || PROXY_TOKEN || '';
+
+  return token
+    ? { Authorization: `Bearer ${token}` }
+    : SUPABASE_AUTH_HEADERS;
+}
+
+async function supabaseFetch(operation, table, url, init) {
+  const buildInit = async (forceRefresh = false) => ({
+    ...init,
+    headers: {
+      ...(await currentSupabaseAuthHeaders({ forceRefresh })),
+      ...(init.headers || {}),
+    },
+  });
+
+  let res = await fetch(url, await buildInit(false));
+  if (res.status === 401 && usesSupabaseProxy()) {
+    console.warn(`[DB] ${operation} ${table} got 401; refreshing proxy token and retrying once`);
+    res = await fetch(url, await buildInit(true));
+  }
+  return res;
+}
+
+async function supabaseInsert(table, data) {
+  const res = await supabaseFetch('INSERT', table, `${SUPABASE_URL}/rest/v1/${table}`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Prefer: 'return=representation',
+    },
+    body: JSON.stringify(data),
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    console.error(`[DB] INSERT ${table} failed: ${res.status} ${text.slice(0, 200)}`);
+    return null;
+  }
+  const rows = await res.json();
+  return Array.isArray(rows) ? rows[0] : rows;
+}
+
+async function supabaseUpsert(table, data, onConflict = 'id') {
+  void onConflict;
+  const res = await supabaseFetch('UPSERT', table, `${SUPABASE_URL}/rest/v1/${table}`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Prefer: `return=representation,resolution=merge-duplicates`,
+    },
+    body: JSON.stringify(data),
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    console.error(`[DB] UPSERT ${table} failed: ${res.status} ${text.slice(0, 200)}`);
+    return null;
+  }
+  const rows = await res.json();
+  return Array.isArray(rows) ? rows[0] : rows;
+}
+
+async function supabasePatch(table, matchCol, matchVal, data) {
+  const res = await supabaseFetch('PATCH', table, `${SUPABASE_URL}/rest/v1/${table}?${matchCol}=eq.${matchVal}`, {
+    method: 'PATCH',
+    headers: {
+      'Content-Type': 'application/json',
+      Prefer: 'return=representation',
+    },
+    body: JSON.stringify(data),
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    console.error(`[DB] PATCH ${table} failed: ${res.status} ${text.slice(0, 200)}`);
+    return null;
+  }
+  return res.json();
+}
+
+async function supabaseSelect(table, query) {
+  const res = await supabaseFetch('SELECT', table, `${SUPABASE_URL}/rest/v1/${table}?${query}`, {
+    headers: {
+      Accept: 'application/json',
+    },
+  });
+  if (!res.ok) return [];
+  return res.json();
+}
+
+// ── Title generation ────────────────────────────────────────────────────────
+
+const DEFAULT_SESSION_TITLES = new Set(['', 'New Chat', 'New session', 'New code session']);
+const TITLE_PROMPT = 'Generate a concise chat title. Return only the title, no quotes. Use 2 to 5 words. If the prompt is only a greeting, return "Quick Greeting".';
+const TITLE_TIMEOUT_MS = Number(process.env.AMALGM_TITLE_TIMEOUT_MS || 5000);
+const TITLE_MODEL = process.env.AMALGM_TITLE_MODEL || 'openai/gpt-5.4-nano';
+
+function isDefaultSessionTitle(title) {
+  return DEFAULT_SESSION_TITLES.has(String(title || '').trim());
+}
+
+function gatewayTitleModel(model) {
+  const clean = String(model || '').trim() || 'openai/gpt-5.4-nano';
+  if (clean.startsWith('vercel/openai/')) return clean.slice('vercel/'.length);
+  if (clean.startsWith('openai/')) return clean;
+  if (/^(gpt-|gpt\d|o-|o\d)/i.test(clean)) return `openai/${clean}`;
+  return clean;
+}
+
+function openAiTitleModel(model) {
+  return gatewayTitleModel(model).replace(/^openai\//, '');
+}
+
+function gatewaySdkBaseUrl(baseUrl) {
+  const clean = String(baseUrl || 'https://ai-gateway.vercel.sh').replace(/\/$/, '');
+  return clean.endsWith('/v1/ai') ? clean : `${clean}/v1/ai`;
+}
+
+function titleEndpoints() {
+  const endpoints = [];
+  if (AI_GATEWAY_API_KEY_TITLE) {
+    endpoints.push({
+      name: 'vercel_ai_sdk_gateway',
+      kind: 'ai_sdk_gateway',
+      baseURL: gatewaySdkBaseUrl(AI_GATEWAY_URL_TITLE),
+      token: AI_GATEWAY_API_KEY_TITLE,
+      model: gatewayTitleModel(TITLE_MODEL),
+    });
+  }
+  if (AI_GATEWAY_PROXY_URL && PROXY_TOKEN) {
+    endpoints.push({
+      name: 'ai_gateway_proxy',
+      kind: 'openai_compat',
+      url: `${AI_GATEWAY_PROXY_URL}/chat/completions`,
+      token: PROXY_TOKEN,
+      model: gatewayTitleModel(TITLE_MODEL),
+    });
+  }
+  if (OPENAI_PROXY_URL && PROXY_TOKEN) {
+    endpoints.push({
+      name: 'openai_proxy',
+      kind: 'openai_compat',
+      url: `${OPENAI_PROXY_URL}/v1/chat/completions`,
+      token: PROXY_TOKEN,
+      model: openAiTitleModel(TITLE_MODEL),
+    });
+  }
+  if (OPENAI_API_KEY_TITLE) {
+    endpoints.push({
+      name: 'direct_openai',
+      kind: 'openai_compat',
+      url: 'https://api.openai.com/v1/chat/completions',
+      token: OPENAI_API_KEY_TITLE,
+      model: openAiTitleModel(TITLE_MODEL),
+    });
+  }
+  return endpoints;
+}
+
+async function requestTitleWithAiSdkGateway(endpoint, prompt, signal) {
+  const [{ generateText }, { createGatewayProvider }] = await Promise.all([
+    import('ai'),
+    import('@ai-sdk/gateway'),
+  ]);
+  const gateway = createGatewayProvider({
+    apiKey: endpoint.token,
+    baseURL: endpoint.baseURL,
+  });
+  const result = await generateText({
+    model: gateway(endpoint.model),
+    system: TITLE_PROMPT,
+    prompt: String(prompt || '').slice(0, 2000),
+    maxOutputTokens: 32,
+    abortSignal: signal,
+  });
+  return cleanGeneratedTitle(result.text);
+}
+
+async function requestTitle(endpoint, prompt, signal) {
+  if (endpoint.kind === 'ai_sdk_gateway') {
+    return requestTitleWithAiSdkGateway(endpoint, prompt, signal);
+  }
+  const res = await fetch(endpoint.url, {
+    method: 'POST',
+    signal,
+    headers: {
+      Authorization: `Bearer ${endpoint.token}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      model: endpoint.model,
+      messages: [
+        { role: 'system', content: TITLE_PROMPT },
+        { role: 'user', content: String(prompt || '').slice(0, 2000) },
+      ],
+      max_completion_tokens: 32,
+    }),
+  });
+  if (!res.ok) {
+    const detail = await res.text().catch(() => '');
+    throw new Error(`${endpoint.name} ${res.status} ${detail.slice(0, 160)}`.trim());
+  }
+  return cleanGeneratedTitle(extractResponseText(await res.json()));
+}
+
+async function generateTitle(prompt) {
+  const text = String(prompt || '').trim();
+  if (!text) return '';
+
+  const endpoints = titleEndpoints();
+  if (endpoints.length === 0) {
+    console.warn('[DB] Title generation skipped: no gateway/proxy credentials');
+    return '';
+  }
+
+  for (const endpoint of endpoints) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), TITLE_TIMEOUT_MS);
+    try {
+      const title = await requestTitle(endpoint, text, controller.signal);
+      if (title) return title;
+    } catch (err) {
+      console.warn('[DB] Title generation endpoint failed:', err.message);
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  return '';
+}
+
+async function generateAndSaveTitle(sessionId, prompt, onTitle) {
+  if (!sessionId || !hasSupabase()) return null;
+
+  const initialRows = await supabaseSelect('sessions', `id=eq.${sessionId}&select=title`);
+  if (!isDefaultSessionTitle(initialRows?.[0]?.title)) return null;
+
+  const title = await generateTitle(prompt);
+  if (!title) return null;
+
+  const rows = await supabaseSelect('sessions', `id=eq.${sessionId}&select=title`);
+  if (!isDefaultSessionTitle(rows?.[0]?.title)) return null;
+
+  const updated = await supabasePatch('sessions', 'id', sessionId, { title });
+  if (!updated) return null;
+
+  try {
+    if (onTitle) onTitle(title);
+  } catch {}
+  return title;
+}
+
+function extractResponseText(data) {
+  const choiceText = data?.choices?.[0]?.message?.content;
+  if (typeof choiceText === 'string') return choiceText;
+  if (typeof data?.output_text === 'string') return data.output_text;
+  const output = Array.isArray(data?.output) ? data.output : [];
+  const texts = [];
+  for (const item of output) {
+    const content = Array.isArray(item?.content) ? item.content : [];
+    for (const part of content) {
+      if (typeof part?.text === 'string') texts.push(part.text);
+    }
+  }
+  return texts.join(' ');
+}
+
+function cleanGeneratedTitle(title) {
+  const cleaned = String(title || '')
+    .replace(/^["'`]+|["'`]+$/g, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+  if (!cleaned) return '';
+  return cleaned.length > 60 ? cleaned.slice(0, 57).trim() + '...' : cleaned;
+}
+
+// ── Conversation history loader ─────────────────────────────────────────────
+
+async function loadConversationHistory(codeSessionId, excludeMessageId) {
+  if (!hasSupabase()) return '';
+  try {
+    const messages = await supabaseSelect(
+      'messages',
+      `session_id=eq.${codeSessionId}&order=created_at.asc&select=id,role,parts,content_plain`
+    );
+    if (!messages || messages.length === 0) return '';
+
+    const history = messages
+      .filter((msg) => msg.id !== excludeMessageId)
+      .slice(-20);
+    if (history.length === 0) return '';
+    const lines = history.map((msg) => {
+      const label = msg.role === 'user' ? 'Human' : 'Assistant';
+      let text = '';
+      if (Array.isArray(msg.parts)) {
+        const textParts = msg.parts.filter((p) => p.type === 'text' && p.text).map((p) => p.text);
+        text = textParts.join('\n');
+        const toolParts = msg.parts.filter((p) => typeof p.type === 'string' && p.type.startsWith('tool-'));
+        if (toolParts.length > 0) {
+          const toolNames = toolParts.map((t) => t.toolName || t.type.replace('tool-', '')).join(', ');
+          text += `\n[Used tools: ${toolNames}]`;
+        }
+      }
+      if (!text) text = msg.content_plain || '';
+      const truncated = text.length > 2000 ? text.slice(0, 2000) + '...' : text;
+      return `${label}: ${truncated}`;
+    });
+    return `<conversation_history>\n${lines.join('\n')}\n</conversation_history>\n\n`;
+  } catch (err) {
+    console.warn('[DB] Failed to load conversation history:', err.message);
+    return '';
+  }
+}
+
+// ── Message helpers ─────────────────────────────────────────────────────────
+
+function extractContentPlain(parts) {
+  if (!Array.isArray(parts)) return null;
+  return parts
+    .filter((p) => p.type === 'text' && p.text)
+    .map((p) => p.text)
+    .join('\n') || null;
+}
+
+async function saveUserMessage(config) {
+  if (!config.userMessageId || !hasSupabase()) return true;
+  const parts = Array.isArray(config.userParts) && config.userParts.length > 0
+    ? config.userParts
+    : Array.isArray(config.chatInput?.parts) && config.chatInput.parts.length > 0
+      ? config.chatInput.parts
+    : [{ type: 'text', text: config.prompt }];
+  const contentPlain = extractContentPlain(parts);
+  const originMetadata = {};
+  if (config.originName) originMetadata.originName = config.originName;
+  if (config.originHarnessId) originMetadata.originHarnessId = config.originHarnessId;
+  if (config.originBaseHarnessId) originMetadata.originBaseHarnessId = config.originBaseHarnessId;
+  const data = {
+    id: config.userMessageId,
+    session_id: config.codeSessionId,
+    role: 'user',
+    parts,
+    ...(config.origin ? { origin: config.origin } : {}),
+    ...(config.originId ? { origin_id: config.originId } : {}),
+    ...(Object.keys(originMetadata).length > 0 ? { metadata: originMetadata } : {}),
+  };
+  let result = await supabaseUpsert('messages', { ...data, content_plain: contentPlain });
+  if (!result) {
+    result = await supabaseUpsert('messages', data);
+  }
+  if (!result) return false;
+
+  await supabasePatch('sessions', 'id', config.codeSessionId, {
+    last_message_at: new Date().toISOString(),
+  }).catch((err) => {
+    console.warn('[DB] Failed to update session metadata during user save:', err.message);
+  });
+  return true;
+}
+
+async function ensureAssistantMessage(config) {
+  if (!config.assistantMessageId || !hasSupabase()) return true;
+
+  const data = {
+    id: config.assistantMessageId,
+    session_id: config.codeSessionId,
+    role: 'assistant',
+    parts: [],
+    model: config.modelId || null,
+  };
+
+  let result = await supabaseUpsert('messages', { ...data, content_plain: null });
+  if (!result) {
+    result = await supabaseUpsert('messages', data);
+  }
+  return !!result;
+}
+
+async function saveAssistantMessage(config, parts, providerSessionId, usage) {
+  if (!hasSupabase()) return true;
+  const contentPlain = extractContentPlain(parts);
+
+  const data = {
+    id: config.assistantMessageId,
+    session_id: config.codeSessionId,
+    role: 'assistant',
+    parts,
+    model: config.modelId || null,
+  };
+  // Usage data goes to usage_logs (via proxy), not messages table
+  let result = await supabaseUpsert('messages', { ...data, content_plain: contentPlain });
+  if (!result) {
+    result = await supabaseUpsert('messages', data);
+  }
+  if (!result) return false;
+  const sessionPatch = {
+    last_message_at: new Date().toISOString(),
+    status: 'complete',
+    new_messages: true,
+    ...(providerSessionId ? { provider_session_id: providerSessionId } : {}),
+  };
+  await supabasePatch('sessions', 'id', config.codeSessionId, sessionPatch);
+  return true;
+}
+
+async function persistSseResumeState(codeSessionId) {
+  // Raw-temp reconnect is now owned by chat-core's in-memory turn store and
+  // clears after DB save. Keep this exported as a compatibility no-op while
+  // old callers are deleted.
+  void codeSessionId;
+}
+
+function shallowMergeObject(current, patch) {
+  return {
+    ...(current && typeof current === 'object' && !Array.isArray(current) ? current : {}),
+    ...(patch && typeof patch === 'object' && !Array.isArray(patch) ? patch : {}),
+  };
+}
+
+async function mergeSessionMetadata(codeSessionId, metadataPatch) {
+  if (!hasSupabase() || !codeSessionId || !metadataPatch) return;
+  try {
+    const rows = await supabaseSelect('sessions', `id=eq.${codeSessionId}&select=metadata`);
+    const current = rows?.[0]?.metadata && typeof rows[0].metadata === 'object'
+      ? rows[0].metadata
+      : {};
+    const merged = {
+      ...current,
+      ...metadataPatch,
+      agent: shallowMergeObject(current.agent, metadataPatch.agent),
+      persistence: shallowMergeObject(current.persistence, metadataPatch.persistence),
+    };
+    await supabasePatch('sessions', 'id', codeSessionId, { metadata: merged });
+  } catch (err) {
+    console.warn('[DB] Failed to merge session metadata:', err.message);
+  }
+}
+
+/**
+ * Log usage to usage_logs table.
+ * Called after each assistant turn with full context.
+ */
+function buildUsageLogRow({ userId, sessionId, messageId, agentId, harnessId, authMethod, modelId, usage, marketCostUsd }) {
+  const provider = modelId?.split('/')[0] || null;
+  return {
+    user_id: userId,
+    session_id: sessionId || null,
+    message_id: messageId || null,
+    agent_id: agentId || null,
+    harness_id: harnessId || null,
+    auth_method: authMethod || null,
+    provider,
+    model: modelId || null,
+    input_tokens: usage.inputTokens || 0,
+    output_tokens: usage.outputTokens || 0,
+    cache_read_tokens: usage.cacheReadTokens || 0,
+    cache_write_tokens: usage.cacheWriteTokens || 0,
+    cost_usd: usage.costUsd ?? 0,
+    market_cost_usd: marketCostUsd ?? usage.costUsd ?? 0,
+    container_id: process.env.AMALGM_CONTAINER_ID || null,
+  };
+}
+
+async function logUsage({ userId, sessionId, messageId, agentId, harnessId, authMethod, modelId, usage, marketCostUsd }) {
+  if (!hasSupabase() || !usage) return;
+  if (!userId) {
+    console.warn('[DB] logUsage skipped: no userId');
+    return;
+  }
+
+  const data = buildUsageLogRow({ userId, sessionId, messageId, agentId, harnessId, authMethod, modelId, usage, marketCostUsd });
+
+  try {
+    const result = await supabaseUpsert('usage_logs', data);
+    if (result) console.log('[DB] logUsage OK:', { agent: agentId, model: modelId, cost: data.cost_usd });
+  } catch (err) {
+    console.error('[DB] logUsage failed:', err.message);
+  }
+}
+
+module.exports = {
+  hasSupabase,
+  supabasePatch,
+  supabaseSelect,
+  generateAndSaveTitle,
+  loadConversationHistory,
+  saveUserMessage,
+  ensureAssistantMessage,
+  saveAssistantMessage,
+  persistSseResumeState,
+  mergeSessionMetadata,
+  buildUsageLogRow,
+  logUsage,
+};

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

@@ -0,0 +1,33 @@
+'use strict';
+
+/**
+ * Chat server entrypoint.
+ *
+ * The middle of the chat path lives in scripts/chat-core:
+ * UI payload -> frozen contract -> native runtime adapter -> normalized events
+ * -> temp/raw-temp -> DB save -> usage policy.
+ */
+
+const { BIND_HOST, PORT } = require('./config');
+const { hasSupabase } = require('./db');
+const { createCore, createServer } = require('../chat-core/server');
+
+const core = createCore({
+  port: PORT,
+  localBaseUrl: process.env.CHAT_CORE_LOCAL_BASE_URL || `http://127.0.0.1:${PORT}`,
+});
+const server = createServer(core);
+
+process.on('unhandledRejection', (reason) => {
+  console.error('[ChatServer] Unhandled rejection:', reason);
+});
+
+process.on('uncaughtException', (err) => {
+  console.error('[ChatServer] Uncaught exception:', err);
+});
+
+server.listen(PORT, BIND_HOST, () => {
+  console.log(`[ChatServer] Listening on ${BIND_HOST}:${PORT}`);
+  console.log('[ChatServer] Runtime: chat-core');
+  console.log(`[ChatServer] Supabase: ${hasSupabase() ? 'configured' : 'NOT configured'}`);
+});