@martian-engineering/lossless-claw 0.5.0 → 0.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@martian-engineering/lossless-claw",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Lossless Context Management plugin for OpenClaw — DAG-based conversation summarization with incremental compaction",
   "type": "module",
   "main": "index.ts",

package/src/assembler.ts

@@ -238,9 +238,12 @@ export function toolCallBlockFromPart(part: MessagePartRecord, rawType?: string)
     return block;
   }
 
-  if (typeof part.toolCallId === "string" && part.toolCallId.length > 0) {
-    block.id = part.toolCallId;
-  }
+  // Always set id — downstream providers (e.g. Anthropic) call
+  // normalizeToolCallId(block.id) which crashes on undefined.
+  block.id =
+    typeof part.toolCallId === "string" && part.toolCallId.length > 0
+      ? part.toolCallId
+      : `toolu_lcm_${part.partId ?? "unknown"}`;
   if (typeof part.toolName === "string" && part.toolName.length > 0) {
     block.name = part.toolName;
   }
@@ -362,6 +365,37 @@ export function blockFromPart(part: MessagePartRecord): unknown {
     if (!isToolBlock) {
       return metadata.raw;
     }
+
+    // When tool blocks are routed through toolCallBlockFromPart (below) instead
+    // of returning raw directly, the function reads part.toolCallId / part.toolName
+    // from the DB columns.  For rows stored as part_type='text' those columns are
+    // often NULL — the values only live inside metadata.raw.  Backfill them here
+    // so the reconstructed block keeps the original id/name.
+    const rawRecord = metadata.raw as Record<string, unknown>;
+    const rawToolCallId =
+      typeof rawRecord.id === "string" && rawRecord.id.length > 0
+        ? rawRecord.id
+        : typeof rawRecord.call_id === "string" && rawRecord.call_id.length > 0
+          ? rawRecord.call_id
+          : undefined;
+    if (rawToolCallId) {
+      if (typeof part.toolCallId !== "string" || part.toolCallId.length === 0) {
+        part.toolCallId = rawToolCallId;
+      }
+    }
+    if (typeof rawRecord.name === "string" && rawRecord.name.length > 0) {
+      if (typeof part.toolName !== "string" || part.toolName.length === 0) {
+        part.toolName = rawRecord.name;
+      }
+    }
+    // Backfill toolInput from raw arguments/input so toolCallBlockFromPart
+    // can reconstruct the full block.
+    if (part.toolInput == null || part.toolInput === "") {
+      const rawArgs = rawRecord.arguments ?? rawRecord.input;
+      if (rawArgs !== undefined) {
+        part.toolInput = typeof rawArgs === "string" ? rawArgs : JSON.stringify(rawArgs);
+      }
+    }
   }
 
   if (part.partType === "reasoning") {

package/src/db/migration.ts

@@ -363,6 +363,68 @@ function backfillSummaryMetadata(db: DatabaseSync): void {
   }
 }
 
+/**
+ * Backfill tool_call_id, tool_name, and tool_input from metadata JSON for rows
+ * where the DB columns are NULL but the values exist in metadata.  This covers
+ * legacy text-type parts where the string-content ingestion path stored tool
+ * info only in the metadata JSON (see #158).
+ */
+function backfillToolCallColumns(db: DatabaseSync): void {
+  db.exec(
+    `UPDATE message_parts
+     SET tool_call_id = COALESCE(
+       json_extract(metadata, '$.toolCallId'),
+       json_extract(metadata, '$.raw.id'),
+       json_extract(metadata, '$.raw.call_id'),
+       json_extract(metadata, '$.raw.toolCallId'),
+       json_extract(metadata, '$.raw.tool_call_id')
+     )
+     WHERE tool_call_id IS NULL
+       AND metadata IS NOT NULL
+       AND COALESCE(
+         json_extract(metadata, '$.toolCallId'),
+         json_extract(metadata, '$.raw.id'),
+         json_extract(metadata, '$.raw.call_id'),
+         json_extract(metadata, '$.raw.toolCallId'),
+         json_extract(metadata, '$.raw.tool_call_id')
+       ) IS NOT NULL`,
+  );
+
+  db.exec(
+    `UPDATE message_parts
+     SET tool_name = COALESCE(
+       json_extract(metadata, '$.toolName'),
+       json_extract(metadata, '$.raw.name'),
+       json_extract(metadata, '$.raw.toolName'),
+       json_extract(metadata, '$.raw.tool_name')
+     )
+     WHERE tool_name IS NULL
+       AND metadata IS NOT NULL
+       AND COALESCE(
+         json_extract(metadata, '$.toolName'),
+         json_extract(metadata, '$.raw.name'),
+         json_extract(metadata, '$.raw.toolName'),
+         json_extract(metadata, '$.raw.tool_name')
+       ) IS NOT NULL`,
+  );
+
+  db.exec(
+    `UPDATE message_parts
+     SET tool_input = COALESCE(
+       json_extract(metadata, '$.raw.input'),
+       json_extract(metadata, '$.raw.arguments'),
+       json_extract(metadata, '$.raw.toolInput')
+     )
+     WHERE tool_input IS NULL
+       AND metadata IS NOT NULL
+       AND COALESCE(
+         json_extract(metadata, '$.raw.input'),
+         json_extract(metadata, '$.raw.arguments'),
+         json_extract(metadata, '$.raw.toolInput')
+       ) IS NOT NULL`,
+  );
+}
+
 export function runLcmMigrations(
   db: DatabaseSync,
   options?: { fts5Available?: boolean },
@@ -523,6 +585,7 @@ export function runLcmMigrations(
   ensureSummaryModelColumn(db);
   backfillSummaryDepths(db);
   backfillSummaryMetadata(db);
+  backfillToolCallColumns(db);
 
   const fts5Available = options?.fts5Available ?? getLcmDbFeatures(db).fts5Available;
   if (!fts5Available) {

package/src/store/conversation-store.ts

@@ -804,14 +804,24 @@ export class ConversationStore {
       )
       .all(...args) as unknown as MessageRow[];
 
-    return rows.map((row) => ({
-      messageId: row.message_id,
-      conversationId: row.conversation_id,
-      role: row.role,
-      snippet: createFallbackSnippet(row.content, plan.terms),
-      createdAt: new Date(row.created_at),
-      rank: 0,
-    }));
+    return rows
+      .map((row) => {
+        const normalizedContent = normalizeMessageContentForFullTextIndex(row.content) ?? row.content;
+        const haystack = normalizedContent.toLowerCase();
+        const matchesAllTerms = plan.terms.every((term) => haystack.includes(term));
+        if (!matchesAllTerms) {
+          return null;
+        }
+        return {
+          messageId: row.message_id,
+          conversationId: row.conversation_id,
+          role: row.role,
+          snippet: createFallbackSnippet(normalizedContent, plan.terms),
+          createdAt: new Date(row.created_at),
+          rank: 0,
+        };
+      })
+      .filter((row): row is MessageSearchResult => row !== null);
   }
 
   private searchRegex(

package/src/summarize.ts

@@ -897,11 +897,14 @@ export async function createLcmSummarizeFromLegacyParams(params: {
     console.error(`[lcm] createLcmSummarize: empty provider="${provider}" or model="${model}"`);
     return undefined;
   }
-  const authProfileId =
+  const legacyAuthProfileId =
     typeof params.legacyParams.authProfileId === "string" &&
     params.legacyParams.authProfileId.trim()
       ? params.legacyParams.authProfileId.trim()
       : undefined;
+  // When LCM selects a dedicated summarizer model/provider, do not leak the
+  // active session's auth profile into that separate credential lookup.
+  const authProfileId = resolvedSummary === undefined ? legacyAuthProfileId : undefined;
   const agentDir =
     typeof params.legacyParams.agentDir === "string" && params.legacyParams.agentDir.trim()
       ? params.legacyParams.agentDir.trim()