agentel 0.2.5 → 0.2.6

package/src/canonical-events.js

@@ -3,7 +3,7 @@
 const crypto = require("crypto");
 const { parserVersionForSource } = require("./parser-versions");
 
-const CANONICAL_EVENT_SCHEMA_VERSION = "agentlog.events.v1";
+const CANONICAL_EVENT_SCHEMA_VERSION = "agentlog.events.v2";
 
 const EVENT_KINDS = {
   SESSION_STARTED: "session.started",
@@ -93,6 +93,10 @@ const TOOL_CATEGORY_DEFINITIONS = [
 
 function normalizeSessionEvents(session, messages, options = {}) {
   const parserVersion = options.parserVersion ?? session.parserVersion ?? parserVersionForSource(session.sourceType);
+  const state = {
+    toolCallEventIdsByKey: new Map(),
+    unmatchedToolCallEventIds: []
+  };
   const events = [
     baseEvent(session, {
       messageIndex: -1,
@@ -114,7 +118,7 @@ function normalizeSessionEvents(session, messages, options = {}) {
     })
   ];
   for (let index = 0; index < messages.length; index++) {
-    events.push(...messageToCanonicalEvents(messages[index], session, { ...options, parserVersion, messageIndex: index }));
+    events.push(...messageToCanonicalEvents(messages[index], session, { ...options, parserVersion, messageIndex: index, state }));
   }
   return events;
 }
@@ -174,31 +178,32 @@ function messageToCanonicalEvents(message, session, options = {}) {
     const toolCall = normalizeToolCall(toolCalls[index], metadata.provider || session.provider);
     if (!toolCall) continue;
     const rendered = renderToolCallText(toolCall);
-    events.push(
-      baseEvent(session, {
-        messageIndex,
-        ordinal: index + 1,
-        kind: EVENT_KINDS.TOOL_CALLED,
-        occurredAt,
-        parserVersion,
-        role: "assistant",
-        parentEventId: responseEventId,
-        indexed: {
-          title: toolCall.title || toolCall.displayName || titleCaseToolName(toolCall.name || "tool"),
-          summary: summarize(rendered || toolCall.rawInputSummary || toolCall.argument || ""),
-          toolName: toolCall.name || toolCall.displayName || "",
-          toolCategory: toolCall.category || "",
-          toolIcon: toolCall.icon || "",
-          target: toolCall.target || "",
-          status: toolCall.status || "tool_call"
-        },
-        body: { text: rendered, toolCall, toolResult: null }
-      })
-    );
+    const event = baseEvent(session, {
+      messageIndex,
+      ordinal: index + 1,
+      kind: EVENT_KINDS.TOOL_CALLED,
+      occurredAt,
+      parserVersion,
+      role: "assistant",
+      parentEventId: responseEventId,
+      indexed: {
+        title: toolCall.title || toolCall.displayName || titleCaseToolName(toolCall.name || "tool"),
+        summary: summarize(rendered || toolCall.rawInputSummary || toolCall.argument || ""),
+        toolName: toolCall.name || toolCall.displayName || "",
+        toolCategory: toolCall.category || "",
+        toolIcon: toolCall.icon || "",
+        target: toolCall.target || "",
+        status: toolCall.status || "tool_call"
+      },
+      body: { text: rendered, toolCall, toolResult: null }
+    });
+    rememberToolCallEvent(options.state, toolCall, event.eventId);
+    events.push(event);
   }
 
   const toolResult = metadata.toolResult ? normalizeToolResult(metadata.toolResult, metadata.provider || session.provider) : role === "tool" ? normalizeToolResult(content, metadata.provider || session.provider) : null;
   if (toolResult) {
+    const parentEventId = consumeToolCallEventId(options.state, toolResult);
     events.push(
       baseEvent(session, {
         messageIndex,
@@ -210,11 +215,12 @@ function messageToCanonicalEvents(message, session, options = {}) {
         indexed: {
           title: toolResult.title || toolResult.kind || "Tool result",
           summary: summarize(toolResult.summary || toolResult.output || content),
-          toolName: toolResult.kind || "",
+          toolName: toolResult.name || toolResult.kind || "",
           toolCategory: toolResult.category || "",
           toolIcon: toolResult.icon || "",
           status: toolResult.status || "completed"
         },
+        parentEventId,
         body: { text: toolResult.output || content, toolCall: null, toolResult }
       })
     );
@@ -223,6 +229,46 @@ function messageToCanonicalEvents(message, session, options = {}) {
   return events;
 }
 
+function rememberToolCallEvent(state, toolCall, eventId) {
+  if (!state || !eventId) return;
+  for (const key of toolPairKeys(toolCall)) {
+    if (!state.toolCallEventIdsByKey.has(key)) state.toolCallEventIdsByKey.set(key, []);
+    state.toolCallEventIdsByKey.get(key).push(eventId);
+  }
+  state.unmatchedToolCallEventIds.push(eventId);
+}
+
+function consumeToolCallEventId(state, toolResult) {
+  if (!state) return "";
+  for (const key of toolPairKeys(toolResult)) {
+    const values = state.toolCallEventIdsByKey.get(key);
+    while (values && values.length) {
+      const eventId = values.shift();
+      if (consumeUnmatchedToolEventId(state, eventId)) return eventId;
+    }
+  }
+  return state.unmatchedToolCallEventIds.shift() || "";
+}
+
+function consumeUnmatchedToolEventId(state, eventId) {
+  const index = state.unmatchedToolCallEventIds.indexOf(eventId);
+  if (index < 0) return false;
+  state.unmatchedToolCallEventIds.splice(index, 1);
+  return true;
+}
+
+function toolPairKeys(tool) {
+  const keys = new Set();
+  for (const value of [tool?.id, tool?.callId, tool?.toolCallId, tool?.tool_call_id]) {
+    if (value) keys.add(`id:${String(value).trim()}`);
+  }
+  for (const value of [tool?.name, tool?.toolName, tool?.displayName, tool?.kind]) {
+    const key = normalizeToolKey(value);
+    if (key) keys.add(`name:${key}`);
+  }
+  return [...keys];
+}
+
 function baseEvent(session, options) {
   const body = options.body || {};
   const indexed = {
@@ -371,7 +417,7 @@ function normalizeToolCall(raw, provider = "") {
   const target = firstString(raw.target, targetFromArguments(parsedArguments));
   return {
     provider: firstString(raw.provider, provider),
-    id: firstString(raw.id, raw.callId, raw.tool_call_id) || undefined,
+    id: firstString(raw.id, raw.callId, raw.call_id, raw.toolCallId, raw.tool_call_id, raw.toolUseId, raw.tool_use_id) || undefined,
     name,
     displayName,
     rawCategory: rawCategory || undefined,
@@ -423,6 +469,7 @@ function normalizeToolResult(raw, provider = "") {
     const classification = classifyTool("tool_output");
     return {
       provider,
+      id: undefined,
       kind: "Tool output",
       title: "Tool result",
       category: classification.category,
@@ -443,6 +490,8 @@ function normalizeToolResult(raw, provider = "") {
   const classification = classifyTool(firstString(raw.toolName, raw.name, kind), rawCategory);
   return {
     provider: firstString(raw.provider, provider),
+    id: firstString(raw.id, raw.callId, raw.call_id, raw.toolCallId, raw.tool_call_id, raw.toolUseId, raw.tool_use_id) || undefined,
+    name: firstString(raw.name, raw.toolName, raw.tool_name) || undefined,
     kind,
     title: firstString(raw.title, raw.kind, "Tool result"),
     rawCategory: rawCategory || undefined,