@agent-native/core 0.203.0-nightly-20261007064822 → 0.203.0

package/dist/agent/thread-message-projection.d.ts

@@ -0,0 +1,20 @@
+export declare function threadMessageRecord(value: unknown): Record<string, unknown> | undefined;
+/** AgentKit messages that represent durable root assistant messages. */
+export declare function projectRootAssistantMessages(input: {
+    rootMessages: unknown;
+    snapshotMessages: unknown;
+    events?: unknown;
+    runs?: unknown;
+    toolCalls?: unknown;
+}): {
+    representedRootMessageIds: Set<string>;
+    snapshotMessageIdsByRootMessageId: Map<string, string>;
+};
+/** Root assistant IDs represented by the AgentKit snapshot. */
+export declare function representedRootAssistantMessageIds(input: {
+    rootMessages: unknown;
+    snapshotMessages: unknown;
+    events?: unknown;
+    runs?: unknown;
+    toolCalls?: unknown;
+}): Set<string>;

package/dist/agent/thread-message-projection.js

@@ -0,0 +1,300 @@
+const REPOSITORY_PART_MEDIA_TYPE = "application/x-agent-native-repository-part";
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function message(value) {
+    const outer = record(value);
+    return record(outer?.message) ?? outer;
+}
+export function threadMessageRecord(value) {
+    return message(value);
+}
+function parts(value) {
+    const content = value.parts ?? value.content;
+    const values = Array.isArray(content)
+        ? content
+        : typeof content === "string"
+            ? [{ type: "text", text: content }]
+            : [];
+    return values.flatMap((part) => {
+        const entry = record(part);
+        if (!entry)
+            return [];
+        return entry.type === "tool-call"
+            ? [
+                {
+                    type: "data",
+                    mediaType: REPOSITORY_PART_MEDIA_TYPE,
+                    data: entry,
+                },
+            ]
+            : [entry];
+    });
+}
+function explicitRunId(value) {
+    const runId = record(value.metadata)?.runId;
+    return typeof runId === "string" ? runId : undefined;
+}
+function foldedRunIds(value) {
+    const custom = record(record(value.metadata)?.custom);
+    const folded = Array.isArray(custom?.foldedRunIds)
+        ? custom.foldedRunIds.filter((runId) => typeof runId === "string")
+        : [];
+    const runId = explicitRunId(value);
+    return [...new Set([...folded, ...(runId ? [runId] : [])])];
+}
+function eventRunIds(events, runs) {
+    const result = new Map();
+    const remember = (messageId, runId) => {
+        if (typeof messageId !== "string" || typeof runId !== "string")
+            return;
+        const ids = result.get(messageId) ?? new Set();
+        ids.add(runId);
+        result.set(messageId, ids);
+    };
+    for (const value of Array.isArray(events) ? events : []) {
+        const event = record(value);
+        const eventMessage = record(event?.message);
+        if ((event?.type === "message.created" ||
+            event?.type === "message.completed") &&
+            eventMessage?.role === "assistant") {
+            remember(eventMessage.id ?? event?.messageId, event?.runId);
+        }
+    }
+    for (const value of Array.isArray(runs) ? runs : []) {
+        const run = record(value);
+        remember(run?.activeMessageId, run?.id);
+    }
+    return result;
+}
+function eventMessageIdsByRun(runIdsByMessageId) {
+    const result = new Map();
+    for (const [messageId, runIds] of runIdsByMessageId) {
+        for (const runId of runIds) {
+            const messageIds = result.get(runId) ?? new Set();
+            messageIds.add(messageId);
+            result.set(runId, messageIds);
+        }
+    }
+    return result;
+}
+function assistantRunId(value, runIdsByMessageId) {
+    if (value.role !== "assistant")
+        return undefined;
+    const eventRunIds = typeof value.id === "string" ? runIdsByMessageId.get(value.id) : undefined;
+    return eventRunIds?.size === 1 ? [...eventRunIds][0] : explicitRunId(value);
+}
+function text(value, ignoreNonTextParts = false) {
+    if (value.role !== "assistant")
+        return undefined;
+    const messageParts = parts(value);
+    if (!ignoreNonTextParts &&
+        messageParts.some((part) => part.type !== "text" &&
+            part.type !== "reasoning" &&
+            !(part.type === "data" &&
+                part.mediaType === REPOSITORY_PART_MEDIA_TYPE &&
+                record(part.data)?.type === "tool-call"))) {
+        return undefined;
+    }
+    return messageParts
+        .filter((part) => part.type === "text" && typeof part.text === "string")
+        .map((part) => part.text)
+        .join("");
+}
+function reasoning(value) {
+    return parts(value)
+        .flatMap((part) => part.type === "reasoning" && typeof part.text === "string"
+        ? [part.text]
+        : [])
+        .join("");
+}
+function isPrefixCompatible(left, right) {
+    return left.startsWith(right) || right.startsWith(left);
+}
+function rootToolCalls(value) {
+    return parts(value).flatMap((part) => {
+        if (part.type !== "data" || part.mediaType !== REPOSITORY_PART_MEDIA_TYPE) {
+            return [];
+        }
+        const data = record(part.data);
+        return data?.type === "tool-call" ? [data] : [];
+    });
+}
+function sameValue(left, right) {
+    if (Object.is(left, right))
+        return true;
+    if (Array.isArray(left) || Array.isArray(right)) {
+        return (Array.isArray(left) &&
+            Array.isArray(right) &&
+            left.length === right.length &&
+            left.every((value, index) => sameValue(value, right[index])));
+    }
+    const leftRecord = record(left);
+    const rightRecord = record(right);
+    if (!leftRecord || !rightRecord)
+        return false;
+    const leftKeys = Object.keys(leftRecord).sort();
+    const rightKeys = Object.keys(rightRecord).sort();
+    return (leftKeys.length === rightKeys.length &&
+        leftKeys.every((key, index) => key === rightKeys[index] &&
+            sameValue(leftRecord[key], rightRecord[key])));
+}
+function representedToolCallMessageIds(value, toolCalls) {
+    const calls = rootToolCalls(value);
+    const byId = new Map((Array.isArray(toolCalls) ? toolCalls : []).flatMap((entry) => {
+        const call = record(entry);
+        return typeof call?.id === "string" ? [[call.id, call]] : [];
+    }));
+    const messageIds = new Set();
+    for (const rootCall of calls) {
+        const id = typeof rootCall.toolCallId === "string"
+            ? rootCall.toolCallId
+            : typeof rootCall.id === "string"
+                ? rootCall.id
+                : undefined;
+        const call = id ? byId.get(id) : undefined;
+        if (!call ||
+            (typeof rootCall.toolName === "string" &&
+                rootCall.toolName !== call.name) ||
+            (Object.prototype.hasOwnProperty.call(rootCall, "args") &&
+                !sameValue(rootCall.args, call.input)) ||
+            (Object.prototype.hasOwnProperty.call(rootCall, "result") &&
+                !sameValue(rootCall.result, call.output))) {
+            return undefined;
+        }
+        if (typeof call.messageId === "string")
+            messageIds.add(call.messageId);
+    }
+    return messageIds;
+}
+function contentMatches(root, candidate, toolMessageIds) {
+    const rootText = text(root);
+    const candidateText = text(candidate);
+    if (rootText === undefined || candidateText === undefined)
+        return false;
+    const sameText = Boolean(rootText && candidateText && isPrefixCompatible(rootText, candidateText));
+    const reasoningMatches = Boolean(reasoning(root) && reasoning(root) === reasoning(candidate));
+    const toolCallMatch = Boolean(typeof candidate.id === "string" && toolMessageIds?.has(candidate.id));
+    if (rootToolCalls(root).length > 0 && toolMessageIds === undefined) {
+        return false;
+    }
+    return ((sameText && (rootText.length > 0 || candidateText.length > 0)) ||
+        (reasoningMatches && !rootText && !candidateText) ||
+        (toolCallMatch && !rootText && !candidateText));
+}
+function foldedProjectionMatches(root, snapshotMessagesByRunId, foldedIds, messageIdsByRun) {
+    if (foldedIds.length < 2)
+        return false;
+    const groups = foldedIds.map((runId) => (snapshotMessagesByRunId.get(runId) ?? []).filter((candidate) => candidate.id !== root.id));
+    const presentIndices = groups.flatMap((group, index) => group.length > 0 ? [index] : []);
+    if (presentIndices.length === 0)
+        return false;
+    const first = presentIndices[0];
+    const last = presentIndices.at(-1);
+    if (last - first + 1 !== presentIndices.length)
+        return false;
+    const projectedText = groups
+        .slice(first, last + 1)
+        .flatMap((group, index) => {
+        const runId = foldedIds[first + index];
+        if (group.some((candidate) => explicitRunId(candidate) !== runId &&
+            messageIdsByRun.get(runId)?.size !== 1)) {
+            return [undefined];
+        }
+        return group.map((candidate) => text(candidate, true));
+    });
+    if (projectedText.some((value) => value === undefined))
+        return false;
+    const candidateText = projectedText.join("");
+    const rootText = text(root);
+    if (!rootText || !candidateText)
+        return false;
+    const isPrefix = first === 0 && rootText.startsWith(candidateText);
+    const isSuffix = last === foldedIds.length - 1 && rootText.endsWith(candidateText);
+    return isPrefix || isSuffix;
+}
+/** AgentKit messages that represent durable root assistant messages. */
+export function projectRootAssistantMessages(input) {
+    const rootMessages = Array.isArray(input.rootMessages)
+        ? input.rootMessages.flatMap((value) => {
+            const entry = message(value);
+            return entry ? [entry] : [];
+        })
+        : [];
+    const snapshotMessages = Array.isArray(input.snapshotMessages)
+        ? input.snapshotMessages.flatMap((value) => {
+            const entry = message(value);
+            return entry ? [entry] : [];
+        })
+        : [];
+    const runIdsByMessageId = eventRunIds(input.events, input.runs);
+    const messageIdsByRun = eventMessageIdsByRun(runIdsByMessageId);
+    const snapshotMessagesByRunId = new Map();
+    for (const candidate of snapshotMessages) {
+        const runId = assistantRunId(candidate, runIdsByMessageId);
+        if (!runId)
+            continue;
+        const candidates = snapshotMessagesByRunId.get(runId);
+        if (candidates)
+            candidates.push(candidate);
+        else
+            snapshotMessagesByRunId.set(runId, [candidate]);
+    }
+    const represented = new Set();
+    const directMatches = new Map();
+    for (const root of rootMessages) {
+        if (root.role !== "assistant" || typeof root.id !== "string")
+            continue;
+        const runId = explicitRunId(root);
+        if (!runId)
+            continue;
+        const toolMessageIds = representedToolCallMessageIds(root, input.toolCalls);
+        const sameRunCandidates = (snapshotMessagesByRunId.get(runId) ?? []).filter((candidate) => candidate.id !== root.id);
+        const sameRunMatches = sameRunCandidates.filter((candidate) => contentMatches(root, candidate, toolMessageIds));
+        const rootText = text(root);
+        const matchingCandidate = sameRunMatches[0];
+        const exactTextMatch = matchingCandidate !== undefined &&
+            rootText !== undefined &&
+            text(matchingCandidate) === rootText;
+        const clientCanMatchPartial = matchingCandidate !== undefined &&
+            (explicitRunId(matchingCandidate) === runId ||
+                (typeof matchingCandidate.id === "string" &&
+                    runIdsByMessageId.get(matchingCandidate.id)?.size === 1 &&
+                    messageIdsByRun.get(runId)?.size === 1));
+        if (sameRunMatches.length === 1 &&
+            (exactTextMatch ||
+                (sameRunCandidates.length === 1 && clientCanMatchPartial))) {
+            represented.add(root.id);
+            if (typeof matchingCandidate.id === "string") {
+                directMatches.set(root.id, matchingCandidate.id);
+            }
+            continue;
+        }
+        if (toolMessageIds !== undefined &&
+            foldedProjectionMatches(root, snapshotMessagesByRunId, foldedRunIds(root), messageIdsByRun)) {
+            represented.add(root.id);
+        }
+    }
+    const directMatchCountBySnapshotId = new Map();
+    for (const snapshotId of directMatches.values()) {
+        directMatchCountBySnapshotId.set(snapshotId, (directMatchCountBySnapshotId.get(snapshotId) ?? 0) + 1);
+    }
+    const snapshotMessageIdsByRootMessageId = new Map();
+    for (const [rootId, snapshotId] of directMatches) {
+        if (directMatchCountBySnapshotId.get(snapshotId) !== 1) {
+            represented.delete(rootId);
+            continue;
+        }
+        snapshotMessageIdsByRootMessageId.set(rootId, snapshotId);
+    }
+    return {
+        representedRootMessageIds: represented,
+        snapshotMessageIdsByRootMessageId,
+    };
+}
+/** Root assistant IDs represented by the AgentKit snapshot. */
+export function representedRootAssistantMessageIds(input) {
+    return projectRootAssistantMessages(input).representedRootMessageIds;
+}

package/dist/automation/index.d.ts

@@ -139,8 +139,8 @@ export declare function createAutomationCallbackHandler(runtime: AutomationRunti
     duplicate?: undefined;
     eventId?: undefined;
 } | {
-    error?: undefined;
     accepted: boolean;
     duplicate: boolean;
     eventId: string;
+    error?: undefined;
 }>;

package/dist/chat-threads/store.d.ts

@@ -1,4 +1,5 @@
 import type { AgentRunOptions } from "@agent-native/agentkit/protocol";
+import { type ThreadAnnotationSnapshotConflict } from "../agent/thread-data-builder.js";
 import { type AccessContext } from "../sharing/access.js";
 import { type ShareRole } from "../sharing/schema.js";
 export declare function withThreadDataLock<T>(threadId: string, fn: () => Promise<T>): Promise<T>;
@@ -180,6 +181,8 @@ export interface UpdateThreadDataOptions {
     preserveExistingQueuedMessages?: boolean;
     preserveExistingTopLevelKeys?: boolean;
     preserveCurrentMetadata?: boolean;
+    preserveCurrentTitleAndPreview?: boolean;
+    onAnnotationConflict?: (conflict: ThreadAnnotationSnapshotConflict) => void;
     transformThreadData?: (currentThreadData: string) => string | {
         threadData: string;
         preview?: string;
@@ -187,7 +190,7 @@ export interface UpdateThreadDataOptions {
     maxAttempts?: number;
     ignoreConflicts?: boolean;
 }
-export declare function updateThreadData(id: string, threadData: string, title: string, preview: string, messageCount: number, options?: UpdateThreadDataOptions): Promise<void>;
+export declare function updateThreadData(id: string, threadData: string, title: string, preview: string, messageCount: number, options?: UpdateThreadDataOptions): Promise<boolean>;
 export interface ThreadEngineMeta {
     engineName: string;
     model: string;

package/dist/chat-threads/store.js

@@ -1,5 +1,6 @@
 import crypto from "node:crypto";
 import { mergeThreadDataForClientSave, normalizeThreadRepository, normalizeThreadTitle, } from "../agent/thread-data-builder.js";
+import { representedRootAssistantMessageIds, threadMessageRecord, } from "../agent/thread-message-projection.js";
 import { getDbExec } from "../db/client.js";
 import { createGetDb } from "../db/create-get-db.js";
 import { ensureColumnExists, ensureIndexExists, ensureTableExists, } from "../db/ddl-guard.js";
@@ -286,7 +287,78 @@ function countThreadMessages(value, fallback) {
     if (repoMessageCount === undefined && agentKitMessageCount === undefined) {
         return fallback;
     }
-    return Math.max(repoMessageCount ?? 0, agentKitMessageCount ?? 0);
+    const rootMessages = Array.isArray(repo.messages) ? repo.messages : [];
+    const agentKitMessages = Array.isArray(repo.agentKit?.messages)
+        ? repo.agentKit.messages
+        : [];
+    const mirroredRootIds = representedRootAssistantMessageIds({
+        rootMessages,
+        snapshotMessages: agentKitMessages,
+        events: repo.agentKit?.events,
+        runs: repo.agentKit?.runs,
+        toolCalls: repo.agentKit?.toolCalls,
+    });
+    const agentKitUserMessageId = (entry) => {
+        const message = threadMessageRecord(entry);
+        if (message?.role !== "user")
+            return undefined;
+        const metadata = message.metadata;
+        const custom = metadata && typeof metadata === "object" && !Array.isArray(metadata)
+            ? metadata.custom
+            : undefined;
+        const agentKitMessageId = custom && typeof custom === "object" && !Array.isArray(custom)
+            ? custom.agentKitMessageId
+            : undefined;
+        return typeof agentKitMessageId === "string"
+            ? agentKitMessageId
+            : undefined;
+    };
+    const snapshotUserMessageCounts = new Map();
+    for (const entry of agentKitMessages) {
+        const message = threadMessageRecord(entry);
+        if (message?.role !== "user" || typeof message.id !== "string")
+            continue;
+        snapshotUserMessageCounts.set(message.id, (snapshotUserMessageCounts.get(message.id) ?? 0) + 1);
+    }
+    const rootUserMirrorIdsByAgentKitId = new Map();
+    for (const entry of rootMessages) {
+        const message = threadMessageRecord(entry);
+        const agentKitId = agentKitUserMessageId(entry);
+        if (typeof message?.id !== "string" || !agentKitId)
+            continue;
+        const rootIds = rootUserMirrorIdsByAgentKitId.get(agentKitId);
+        if (rootIds)
+            rootIds.push(message.id);
+        else
+            rootUserMirrorIdsByAgentKitId.set(agentKitId, [message.id]);
+    }
+    const mirroredRootUserIds = new Set();
+    for (const [agentKitId, rootIds] of rootUserMirrorIdsByAgentKitId) {
+        if (rootIds.length === 1 &&
+            snapshotUserMessageCounts.get(agentKitId) === 1) {
+            mirroredRootUserIds.add(rootIds[0]);
+        }
+    }
+    const messageIds = new Set();
+    let unkeyedMessages = 0;
+    const countMessage = (entry) => {
+        const message = threadMessageRecord(entry);
+        if (typeof message?.id === "string")
+            messageIds.add(message.id);
+        else
+            unkeyedMessages += 1;
+    };
+    for (const entry of rootMessages) {
+        const message = threadMessageRecord(entry);
+        if (typeof message?.id === "string" &&
+            (mirroredRootIds.has(message.id) || mirroredRootUserIds.has(message.id))) {
+            continue;
+        }
+        countMessage(entry);
+    }
+    for (const entry of agentKitMessages)
+        countMessage(entry);
+    return messageIds.size + unkeyedMessages;
 }
 function forkThreadData(threadData, forkId, fromMessageId) {
     const parsed = normalizeThreadRepository(JSON.parse(threadData));
@@ -1010,32 +1082,31 @@ export async function updateThreadData(id, threadData, title, preview, messageCo
         try {
             const current = await getThread(id);
             if (!current)
-                return;
+                return false;
             const transformed = options.transformThreadData?.(current.threadData);
             const incomingThreadData = typeof transformed === "string"
                 ? transformed
                 : (transformed?.threadData ?? threadData);
             let nextThreadData = incomingThreadData;
             let nextMessageCount = messageCount;
-            try {
-                const merged = mergeThreadDataForClientSave(parseThreadData(current.threadData), parseThreadData(incomingThreadData), {
-                    preserveExistingQueuedMessages: options.preserveExistingQueuedMessages ?? true,
-                    preserveExistingTopLevelKeys: options.preserveExistingTopLevelKeys ?? true,
-                });
-                nextThreadData = JSON.stringify(merged);
-                nextMessageCount = countThreadMessages(merged, messageCount);
-            }
-            catch {
-                // Keep the caller's serialized value if either JSON blob is malformed.
-            }
+            const annotationConflicts = [];
+            const merged = mergeThreadDataForClientSave(parseThreadData(current.threadData), parseThreadData(incomingThreadData), {
+                preserveExistingQueuedMessages: options.preserveExistingQueuedMessages ?? true,
+                preserveExistingTopLevelKeys: options.preserveExistingTopLevelKeys ?? true,
+                onAnnotationConflict: (conflict) => annotationConflicts.push(conflict),
+            });
+            nextThreadData = JSON.stringify(merged);
+            nextMessageCount = countThreadMessages(merged, messageCount);
             const nextUpdatedAt = Math.max(Date.now(), current.updatedAt + 1);
             // Completion persistence can race the separate generated-title save.
             // Keep a title already committed by that save when this caller only has
             // its stale empty snapshot.
-            const nextTitle = options.preserveCurrentMetadata
+            const preserveCurrentTitleAndPreview = options.preserveCurrentMetadata ||
+                options.preserveCurrentTitleAndPreview;
+            const nextTitle = preserveCurrentTitleAndPreview
                 ? current.title
                 : title || current.title;
-            const nextPreview = options.preserveCurrentMetadata
+            const nextPreview = preserveCurrentTitleAndPreview
                 ? current.preview
                 : typeof transformed === "object" && transformed.preview !== undefined
                     ? transformed.preview
@@ -1054,8 +1125,11 @@ export async function updateThreadData(id, threadData, title, preview, messageCo
                 ],
             });
             if (result.rowsAffected > 0) {
+                for (const conflict of annotationConflicts) {
+                    options.onAnnotationConflict?.(conflict);
+                }
                 emitChatThreadChange(id);
-                return;
+                return true;
             }
             lastConflict = true;
         }
@@ -1074,12 +1148,13 @@ export async function updateThreadData(id, threadData, title, preview, messageCo
         throw lastError;
     if (lastConflict) {
         if (options.ignoreConflicts)
-            return;
+            return false;
         const error = new Error(`Failed to update chat thread ${id} after concurrent write conflicts.`);
         error.statusCode = 409;
         error.statusMessage = error.message;
         throw error;
     }
+    return false;
 }
 /**
  * Read the engine pinned to a thread (stored in thread_data JSON).