amalgm 0.1.76 → 0.1.77

package/package.json

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

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

@@ -129,6 +129,49 @@ function ensureClaudeToolState(state) {
   return state;
 }
 
+function ensureClaudeTextState(state) {
+  if (!state) return null;
+  if (!state.claudeTextByIndex) state.claudeTextByIndex = new Map();
+  if (!state.claudeReasoningByIndex) state.claudeReasoningByIndex = new Map();
+  return state;
+}
+
+function blockIndex(value) {
+  const index = Number(value);
+  return Number.isInteger(index) && index >= 0 ? index : null;
+}
+
+function emitIndexedTextDelta(state, index, kind, delta, providerSessionId, raw) {
+  if (!delta) return [];
+  const textState = ensureClaudeTextState(state);
+  const key = blockIndex(index);
+  if (textState && key !== null) {
+    const map = kind === 'reasoning' ? textState.claudeReasoningByIndex : textState.claudeTextByIndex;
+    map.set(key, `${map.get(key) || ''}${delta}`);
+  }
+  return kind === 'reasoning'
+    ? [reasoningDelta(delta, { providerSessionId, ...raw })]
+    : [textDelta(delta, { providerSessionId, ...raw })];
+}
+
+function emitIndexedTextSnapshot(block, field, kind, providerSessionId, state, raw) {
+  const text = block?.[field];
+  if (!text) return [];
+  let delta = text;
+  const textState = ensureClaudeTextState(state);
+  const key = blockIndex(block.index);
+  if (textState && key !== null) {
+    const map = kind === 'reasoning' ? textState.claudeReasoningByIndex : textState.claudeTextByIndex;
+    const streamed = map.get(key) || '';
+    delta = streamed ? (text.startsWith(streamed) ? text.slice(streamed.length) : '') : text;
+    map.set(key, text);
+  }
+  if (!delta) return [];
+  return kind === 'reasoning'
+    ? [reasoningDelta(delta, { providerSessionId, ...raw })]
+    : [textDelta(delta, { providerSessionId, ...raw })];
+}
+
 function stableStringify(value) {
   if (value == null || typeof value !== 'object') return JSON.stringify(value);
   if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;
@@ -259,9 +302,11 @@ function startOrUpdateClaudeTool(block, providerSessionId, state, 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 === 'text' && block.text) {
+    return emitIndexedTextSnapshot(block, 'text', 'text', providerSessionId, state, raw);
+  }
   if ((block.type === 'thinking' || block.type === 'redacted_thinking') && block.thinking) {
-    return [reasoningDelta(block.thinking, { providerSessionId, ...raw })];
+    return emitIndexedTextSnapshot(block, 'thinking', 'reasoning', providerSessionId, state, raw);
   }
   if (TOOL_USE_BLOCK_TYPES.has(block.type)) {
     return startOrUpdateClaudeTool(block, providerSessionId, state, raw);
@@ -315,6 +360,14 @@ function normalizeClaudeStreamEvent(message, providerSessionId, state) {
     return startOrUpdateClaudeTool({ ...block, index: event.index }, providerSessionId, state, raw);
   }
 
+  if (event.type === 'content_block_delta' && event.delta?.type === 'text_delta') {
+    return emitIndexedTextDelta(state, event.index, 'text', event.delta.text, providerSessionId, raw);
+  }
+
+  if (event.type === 'content_block_delta' && event.delta?.type === 'thinking_delta') {
+    return emitIndexedTextDelta(state, event.index, 'reasoning', event.delta.thinking, providerSessionId, 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));
@@ -376,9 +429,9 @@ function normalizeClaudeMessage(message, state) {
 
   if (message.type === 'assistant') {
     const events = [];
-    for (const block of message.message?.content || []) {
+    for (const [index, block] of (message.message?.content || []).entries()) {
       events.push(...normalizeClaudeContentBlock(
-        block,
+        { ...block, index },
         providerSessionId,
         state,
         eventRaw('claude.sdk.message', 'claude/assistant/content_block', message),

package/runtime/scripts/chat-core/tests/claude-normalizer.test.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { normalizeClaudeMessage } = require('../normalizers/claude');
+
+test('claude text stream deltas emit before final assistant snapshot without duplication', () => {
+  const state = { providerSessionId: 'claude-session' };
+
+  const first = normalizeClaudeMessage({
+    type: 'content_block_delta',
+    index: 0,
+    delta: { type: 'text_delta', text: 'hel' },
+  }, state);
+  assert.equal(first.length, 1);
+  assert.equal(first[0].type, 'text.delta');
+  assert.equal(first[0].text, 'hel');
+
+  const second = normalizeClaudeMessage({
+    type: 'content_block_delta',
+    index: 0,
+    delta: { type: 'text_delta', text: 'lo' },
+  }, state);
+  assert.equal(second.length, 1);
+  assert.equal(second[0].type, 'text.delta');
+  assert.equal(second[0].text, 'lo');
+
+  const finalSnapshot = normalizeClaudeMessage({
+    type: 'assistant',
+    message: {
+      content: [{ type: 'text', text: 'hello' }],
+    },
+  }, state);
+  assert.deepEqual(finalSnapshot, []);
+});
+
+test('claude thinking stream deltas emit reasoning before final snapshot without duplication', () => {
+  const state = { providerSessionId: 'claude-session' };
+
+  const streamed = normalizeClaudeMessage({
+    type: 'content_block_delta',
+    index: 0,
+    delta: { type: 'thinking_delta', thinking: 'inspect first' },
+  }, state);
+  assert.equal(streamed.length, 1);
+  assert.equal(streamed[0].type, 'reasoning.delta');
+  assert.equal(streamed[0].text, 'inspect first');
+
+  const finalSnapshot = normalizeClaudeMessage({
+    type: 'assistant',
+    message: {
+      content: [{ type: 'thinking', thinking: 'inspect first' }],
+    },
+  }, state);
+  assert.deepEqual(finalSnapshot, []);
+});