amalgm 0.0.0 → 0.0.1

package/runtime/scripts/chat-core/normalizers/claude.js

@@ -0,0 +1,450 @@
+'use strict';
+
+const { compactionFinished, compactionStarted, reasoningDelta, textDelta, toolCompleted, toolStarted, toolUpdated, usageFinal } = require('../events');
+const { summarizeToolRequest } = require('../tool-display');
+const { mcpMetadataFromName, normalizeError, titleForTool, toolKind } = require('../tool-shape');
+const { normalizeUsage } = require('../usage');
+
+const TOOL_USE_BLOCK_TYPES = new Set(['tool_use', 'server_tool_use', 'mcp_tool_use']);
+
+function usageFromClaude(usage = {}, contextLimit, options = {}) {
+  return normalizeUsage({
+    inputTokens: usage.input_tokens,
+    outputTokens: usage.output_tokens,
+    cacheReadTokens: usage.cache_read_input_tokens,
+    cacheWriteTokens: usage.cache_creation_input_tokens,
+    contextLimit,
+    inputContextSize: options.inputContextSize,
+    totalProcessedTokens: options.totalProcessedTokens,
+    operation: options.operation || 'chat_step',
+    billable: options.billable,
+    source: options.source || 'claude_agent_sdk',
+    exact: options.exact === false ? false : true,
+  });
+}
+
+function usageFromClaudeModelUsage(modelUsage = {}, contextLimit, options = {}) {
+  return normalizeUsage({
+    inputTokens: modelUsage.inputTokens,
+    outputTokens: modelUsage.outputTokens,
+    cacheReadTokens: modelUsage.cacheReadInputTokens,
+    cacheWriteTokens: modelUsage.cacheCreationInputTokens,
+    contextLimit: contextLimit || modelUsage.contextWindow,
+    inputContextSize: options.inputContextSize,
+    totalProcessedTokens: options.totalProcessedTokens,
+    operation: options.operation || 'chat_turn',
+    billable: options.billable,
+    source: options.source || 'claude_agent_sdk_model_usage',
+    exact: options.exact === false ? false : true,
+  });
+}
+
+function claudeUsageTotal(usage = {}) {
+  const explicitTotal = Number(usage.total_tokens);
+  if (Number.isFinite(explicitTotal) && explicitTotal > 0) return explicitTotal;
+  return Number(usage.input_tokens || 0)
+    + Number(usage.output_tokens || 0)
+    + Number(usage.cache_read_input_tokens || 0)
+    + Number(usage.cache_creation_input_tokens || 0);
+}
+
+function hasClaudeTokenBuckets(usage = {}) {
+  return [
+    usage.input_tokens,
+    usage.output_tokens,
+    usage.cache_read_input_tokens,
+    usage.cache_creation_input_tokens,
+  ].some((value) => Number(value || 0) > 0);
+}
+
+function hasClaudeModelUsageBuckets(usage = {}) {
+  return [
+    usage.inputTokens,
+    usage.outputTokens,
+    usage.cacheReadInputTokens,
+    usage.cacheCreationInputTokens,
+  ].some((value) => Number(value || 0) > 0);
+}
+
+function claudeModelUsageTotal(usage = {}) {
+  return Number(usage.inputTokens || 0)
+    + Number(usage.outputTokens || 0)
+    + Number(usage.cacheReadInputTokens || 0)
+    + Number(usage.cacheCreationInputTokens || 0);
+}
+
+function selectClaudeModelUsage(modelUsage = {}) {
+  if (!modelUsage || typeof modelUsage !== 'object') return null;
+  const entries = Object.values(modelUsage).filter((entry) => (
+    entry && typeof entry === 'object' && hasClaudeModelUsageBuckets(entry)
+  ));
+  return entries[0] || null;
+}
+
+function claudeUsageFingerprint(usage = {}) {
+  return [
+    usage.input_tokens,
+    usage.output_tokens,
+    usage.cache_read_input_tokens,
+    usage.cache_creation_input_tokens,
+  ].map((value) => Number(value || 0)).join(':');
+}
+
+function usageRecordsFromClaudeResult(resultOrUsage = {}, contextLimit) {
+  const result = resultOrUsage && resultOrUsage.usage
+    ? resultOrUsage
+    : { usage: resultOrUsage };
+  const usage = result.usage || {};
+  const iterations = Array.isArray(usage.iterations)
+    ? usage.iterations.filter(hasClaudeTokenBuckets)
+    : [];
+  const latestIterationTotal = iterations.length > 0
+    ? claudeUsageTotal(iterations[iterations.length - 1])
+    : 0;
+  const inputContextSize = latestIterationTotal > 0 ? latestIterationTotal : undefined;
+  const modelUsage = selectClaudeModelUsage(result.modelUsage);
+  if (modelUsage) {
+    const totalProcessedTokens = claudeModelUsageTotal(modelUsage);
+    return [usageFromClaudeModelUsage(modelUsage, contextLimit, {
+      inputContextSize,
+      totalProcessedTokens: totalProcessedTokens > 0 ? totalProcessedTokens : undefined,
+    })];
+  }
+  const totalProcessedTokens = claudeUsageTotal(usage);
+  if (!hasClaudeTokenBuckets(usage)) return [];
+  return [usageFromClaude(usage, contextLimit, {
+    operation: 'chat_turn',
+    source: 'claude_agent_sdk_result',
+    inputContextSize,
+    totalProcessedTokens: totalProcessedTokens > 0 ? totalProcessedTokens : undefined,
+  })];
+}
+
+function ensureClaudeToolState(state) {
+  if (!state) return null;
+  if (!state.claudeTools) state.claudeTools = new Map();
+  if (!state.claudeToolsByIndex) state.claudeToolsByIndex = new Map();
+  if (!state.claudeStartedTools) state.claudeStartedTools = new Set();
+  if (!state.claudeCompletedTools) state.claudeCompletedTools = new Set();
+  return state;
+}
+
+function stableStringify(value) {
+  if (value == null || typeof value !== 'object') return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;
+  return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+}
+
+function tryParseJsonRecord(text) {
+  try {
+    const parsed = JSON.parse(text);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function eventRaw(source, method, payload) {
+  return { raw: { source, method, payload } };
+}
+
+function stringifyClaudeContent(content) {
+  if (content == null) return '';
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content.map((entry) => {
+      if (entry == null) return '';
+      if (typeof entry === 'string') return entry;
+      if (typeof entry === 'object') {
+        if (typeof entry.text === 'string') return entry.text;
+        if (typeof entry.content === 'string') return entry.content;
+      }
+      try {
+        return JSON.stringify(entry);
+      } catch {
+        return String(entry);
+      }
+    }).filter(Boolean).join('\n');
+  }
+  if (typeof content === 'object') {
+    if (typeof content.text === 'string') return content.text;
+    if (typeof content.content === 'string') return content.content;
+  }
+  try {
+    return JSON.stringify(content);
+  } catch {
+    return String(content);
+  }
+}
+
+function rememberClaudeTool(state, id, data, index) {
+  const toolState = ensureClaudeToolState(state);
+  if (!toolState || !id) return;
+  const key = String(id);
+  const previous = toolState.claudeTools.get(key) || {};
+  const next = { ...previous, ...data, id: key };
+  toolState.claudeTools.set(key, next);
+  if (index !== undefined && index !== null) toolState.claudeToolsByIndex.set(Number(index), next);
+}
+
+function startOrUpdateClaudeTool(block, providerSessionId, state, raw) {
+  const toolName = block.name || block.tool_name || block.type || 'unknown';
+  const id = block.id || block.tool_use_id;
+  if (!id) return [];
+
+  const input = block.input && typeof block.input === 'object' ? block.input : {};
+  const detail = summarizeToolRequest(toolName, input);
+  const metadata = {
+    blockType: block.type,
+    ...mcpMetadataFromName(toolName),
+  };
+  const kind = toolKind(toolName, input, metadata);
+  const title = titleForTool({ name: toolName, input, metadata, fallback: toolName });
+  const toolState = ensureClaudeToolState(state);
+  const key = String(id);
+  const fingerprint = stableStringify(input);
+  const known = toolState?.claudeTools.get(key);
+  rememberClaudeTool(state, key, {
+    toolName,
+    title,
+    kind,
+    metadata,
+    detail,
+    input,
+    blockType: block.type,
+    lastEmittedInputFingerprint: known?.lastEmittedInputFingerprint,
+  }, block.index);
+
+  if (!toolState?.claudeStartedTools.has(key)) {
+    toolState?.claudeStartedTools.add(key);
+    const next = toolState?.claudeTools.get(key);
+    if (next) next.lastEmittedInputFingerprint = fingerprint;
+    return [toolStarted(key, {
+      providerSessionId,
+      toolName,
+      title,
+      kind,
+      detail,
+      input,
+      metadata,
+      data: {
+        toolName,
+        input,
+        blockType: block.type,
+      },
+      ...raw,
+    })];
+  }
+
+  if (!fingerprint || known?.lastEmittedInputFingerprint === fingerprint) return [];
+  const next = toolState?.claudeTools.get(key);
+  if (next) next.lastEmittedInputFingerprint = fingerprint;
+  return [toolUpdated(key, {
+    providerSessionId,
+    toolName,
+    title,
+    kind,
+    detail,
+    inputDelta: input,
+    status: 'in_progress',
+    metadata,
+    data: {
+      toolName,
+      input,
+      blockType: block.type,
+    },
+    ...raw,
+  })];
+}
+
+function normalizeClaudeContentBlock(block, providerSessionId, state, raw = undefined) {
+  if (!block || typeof block !== 'object') return [];
+  if (block.type === 'text' && block.text) return [textDelta(block.text, { providerSessionId, ...raw })];
+  if ((block.type === 'thinking' || block.type === 'redacted_thinking') && block.thinking) {
+    return [reasoningDelta(block.thinking, { providerSessionId, ...raw })];
+  }
+  if (TOOL_USE_BLOCK_TYPES.has(block.type)) {
+    return startOrUpdateClaudeTool(block, providerSessionId, state, raw);
+  }
+  if (block.type === 'tool_result') {
+    const toolId = block.tool_use_id || block.id;
+    if (!toolId) return [];
+    const toolKey = String(toolId);
+    const toolState = ensureClaudeToolState(state);
+    if (toolState?.claudeCompletedTools.has(toolKey)) return [];
+    toolState?.claudeCompletedTools.add(toolKey);
+    const known = toolState?.claudeTools.get(toolKey);
+    const result = stringifyClaudeContent(block.content);
+    const toolName = known?.toolName || 'tool';
+    const input = known?.input || {};
+    const metadata = known?.metadata || mcpMetadataFromName(toolName);
+    const error = block.is_error === true
+      ? normalizeError(result || block.content || 'Tool failed')
+      : undefined;
+    return [toolCompleted(toolKey, {
+      providerSessionId,
+      toolName,
+      title: known?.title || titleForTool({ name: toolName, input, metadata, fallback: toolName }),
+      kind: known?.kind || toolKind(toolName, input, metadata),
+      detail: known?.detail || summarizeToolRequest(toolName, input),
+      input,
+      output: block.content || '',
+      result,
+      isError: block.is_error === true,
+      error,
+      metadata,
+      data: {
+        toolName,
+        input,
+        result: block,
+      },
+      ...raw,
+    })];
+  }
+  return [];
+}
+
+function normalizeClaudeStreamEvent(message, providerSessionId, state) {
+  const event = message?.event && typeof message.event === 'object' ? message.event : message;
+  if (!event || typeof event !== 'object') return [];
+  const raw = eventRaw('claude.sdk.message', `claude/${event.type || 'unknown'}`, message);
+
+  if (event.type === 'content_block_start') {
+    const block = event.content_block || event.block;
+    if (!block || !TOOL_USE_BLOCK_TYPES.has(block.type)) return [];
+    return startOrUpdateClaudeTool({ ...block, index: event.index }, providerSessionId, state, raw);
+  }
+
+  if (event.type === 'content_block_delta' && event.delta?.type === 'input_json_delta') {
+    const toolState = ensureClaudeToolState(state);
+    const tool = toolState?.claudeToolsByIndex.get(Number(event.index));
+    const partial = event.delta.partial_json;
+    if (!tool || typeof partial !== 'string') return [];
+    const partialInputJson = `${tool.partialInputJson || ''}${partial}`;
+    const parsedInput = tryParseJsonRecord(partialInputJson);
+    const nextTool = { ...tool, partialInputJson, ...(parsedInput ? { input: parsedInput } : {}) };
+    toolState.claudeToolsByIndex.set(Number(event.index), nextTool);
+    toolState.claudeTools.set(String(tool.id), nextTool);
+    if (!parsedInput) return [];
+
+    const fingerprint = stableStringify(parsedInput);
+    if (!fingerprint || tool.lastEmittedInputFingerprint === fingerprint) return [];
+    nextTool.lastEmittedInputFingerprint = fingerprint;
+    return [toolUpdated(tool.id, {
+      providerSessionId,
+      toolName: tool.toolName,
+      title: tool.title || tool.toolName,
+      kind: tool.kind,
+      detail: summarizeToolRequest(tool.toolName, parsedInput),
+      inputDelta: parsedInput,
+      status: 'in_progress',
+      metadata: tool.metadata,
+      data: {
+        toolName: tool.toolName,
+        input: parsedInput,
+        blockType: tool.blockType,
+      },
+      ...raw,
+    })];
+  }
+
+  return [];
+}
+
+function normalizeClaudeMessage(message, state) {
+  if (!message || typeof message !== 'object') return [];
+  const providerSessionId = state?.providerSessionId || message.session_id || null;
+
+  if (message.type === 'system' && message.subtype === 'status' && message.status === 'compacting') {
+    return [compactionStarted({
+      providerSessionId,
+      trigger: 'auto',
+      ...eventRaw('claude.sdk.message', 'system/status/compacting', message),
+    })];
+  }
+  if (message.type === 'system' && message.subtype === 'compact_boundary') {
+    const meta = message.compact_metadata || {};
+    return [compactionFinished({
+      providerSessionId,
+      trigger: meta.trigger || 'auto',
+      preTokens: meta.pre_tokens,
+      postTokens: meta.post_tokens,
+      durationMs: meta.duration_ms,
+      ...eventRaw('claude.sdk.message', 'system/compact_boundary', message),
+    })];
+  }
+
+  if (message.type === 'assistant') {
+    const events = [];
+    for (const block of message.message?.content || []) {
+      events.push(...normalizeClaudeContentBlock(
+        block,
+        providerSessionId,
+        state,
+        eventRaw('claude.sdk.message', 'claude/assistant/content_block', message),
+      ));
+    }
+    const usage = message.message?.usage || message.usage;
+    if (hasClaudeTokenBuckets(usage)) {
+      if (state && !state.claudeUsageSnapshotFingerprints) state.claudeUsageSnapshotFingerprints = new Set();
+      const fingerprint = claudeUsageFingerprint(usage);
+      if (!state?.claudeUsageSnapshotFingerprints?.has(fingerprint)) {
+        state?.claudeUsageSnapshotFingerprints?.add(fingerprint);
+        events.push(usageFinal(usageFromClaude(usage, state?.contextLimit, {
+          billable: false,
+          exact: false,
+          source: 'claude_agent_sdk_snapshot',
+        }), {
+          providerSessionId,
+          ...eventRaw('claude.sdk.message', 'claude/assistant/usage', message),
+        }));
+      }
+    }
+    return events;
+  }
+
+  if (message.type === 'user') {
+    const events = [];
+    for (const block of message.message?.content || []) {
+      if (block?.type === 'tool_result') {
+        events.push(...normalizeClaudeContentBlock(
+          block,
+          providerSessionId,
+          state,
+          eventRaw('claude.sdk.message', 'claude/user/tool_result', message),
+        ));
+      }
+    }
+    return events;
+  }
+
+  const streamEvents = normalizeClaudeStreamEvent(message, providerSessionId, state);
+  if (streamEvents.length > 0) return streamEvents;
+
+  if (message.type === 'tool_progress' && message.tool_use_id) {
+    const toolName = message.tool_name || 'tool';
+    const metadata = mcpMetadataFromName(toolName);
+    return [toolUpdated(message.tool_use_id, {
+      providerSessionId,
+      toolName,
+      title: titleForTool({ name: toolName, input: {}, metadata, fallback: toolName }),
+      kind: toolKind(toolName, {}, metadata),
+      status: 'in_progress',
+      outputDelta: message.output || message.summary || undefined,
+      metadata,
+      ...eventRaw('claude.sdk.message', 'claude/tool_progress', message),
+    })];
+  }
+
+  return [];
+}
+
+module.exports = {
+  normalizeClaudeContentBlock,
+  normalizeClaudeMessage,
+  stableStringify,
+  stringifyClaudeContent,
+  usageRecordsFromClaudeResult,
+  usageFromClaude,
+  usageFromClaudeModelUsage,
+};