@memorax/memorax-code 0.1.2 → 0.1.4

package/lib/memorax-code-backend/dist/clients/dsh/session-turn.js

@@ -0,0 +1,249 @@
+import { isRecord } from "../../shared/record.js";
+const DSH_SESSION_FORMAT_VERSION = 0;
+// Mirrors the supported DSH persistence catalog. Events outside this
+// vocabulary are safe to skip only when their envelope explicitly says so.
+const KNOWN_SESSION_EVENT_TYPES = new Set([
+    "agent-preset/selected",
+    "agent/inbox/spliced",
+    "approval/asked",
+    "approval/decided",
+    "approval/policy",
+    "turn/start",
+    "turn/end",
+    "step/start",
+    "step/end",
+    "user/message",
+    "assistant/chunk",
+    "assistant/message",
+    "command/done",
+    "command/run",
+    "compaction/end",
+    "compaction/prune",
+    "compaction/start",
+    "compaction/summary",
+    "feedback/record",
+    "goal/change",
+    "hook/invoked",
+    "hook/result",
+    "llm/retry",
+    "llm/retry-started",
+    "permission/preset",
+    "plan/mode",
+    "tool/call",
+    "tool/code-dispatch",
+    "tool/code-dispatch-start",
+    "tool/result",
+    "todo/write",
+    "request/header",
+    "request/context",
+    "sandbox/mode",
+    "schedule/change",
+    "session/end-seed",
+    "session/title",
+    "session/title-llm-request",
+    "subagent/descriptor",
+    "tool-workflow/agent-end",
+    "tool-workflow/agent-start",
+    "tool-workflow/run-end",
+    "tool-workflow/run-start",
+    "web/deepseek-search-llm-request",
+]);
+const TURN_IDENTITY_REQUIRED_EVENT_TYPES = new Set([
+    "turn/start",
+    "turn/end",
+    "assistant/message",
+]);
+export function dshSessionEventTurn(input) {
+    const header = validateSessionHeader(input);
+    if (header)
+        return { ok: false, reason: header };
+    if (input.events.length === 0
+        || input.endSeq - input.startSeq !== input.events.length - 1) {
+        return { ok: false, reason: "interval_length_mismatch" };
+    }
+    const first = input.events[0];
+    const last = input.events[input.events.length - 1];
+    if (!isRecord(first)
+        || first.type !== "turn/start"
+        || !isRecord(last)
+        || last.type !== "turn/end")
+        return { ok: false, reason: "turn_boundary_mismatch" };
+    const userParts = [];
+    const assistantParts = [];
+    let outcome;
+    for (const [index, value] of input.events.entries()) {
+        if (!isRecord(value))
+            return { ok: false, reason: "event_invalid" };
+        const type = stringField(value, "type");
+        const seq = safeIntegerField(value, "seq", 0);
+        if (!type || seq === undefined) {
+            return { ok: false, reason: "event_invalid" };
+        }
+        if (seq !== input.startSeq + index) {
+            return { ok: false, reason: "event_sequence_mismatch" };
+        }
+        if (Object.prototype.hasOwnProperty.call(value, "ignorable") && value.ignorable !== true) {
+            return { ok: false, reason: "event_invalid" };
+        }
+        if (!KNOWN_SESSION_EVENT_TYPES.has(type)) {
+            if (value.ignorable === true)
+                continue;
+            return { ok: false, reason: "unknown_required_event" };
+        }
+        const data = isRecord(value.data) ? value.data : undefined;
+        const carriesTurn = data ? Object.prototype.hasOwnProperty.call(data, "turn") : false;
+        const eventTurn = data && carriesTurn ? safeIntegerField(data, "turn", 1) : undefined;
+        if ((carriesTurn && eventTurn === undefined)
+            || (TURN_IDENTITY_REQUIRED_EVENT_TYPES.has(type) && eventTurn === undefined))
+            return { ok: false, reason: "event_invalid" };
+        if (eventTurn !== undefined && eventTurn !== input.turn) {
+            return { ok: false, reason: "turn_identity_mismatch" };
+        }
+        if ((type === "turn/start" && index !== 0)
+            || (type === "turn/end" && index !== input.events.length - 1)) {
+            return { ok: false, reason: "turn_boundary_mismatch" };
+        }
+        switch (type) {
+            case "turn/start":
+                break;
+            case "turn/end": {
+                const reason = data && isRecord(data.reason) ? stringField(data.reason, "kind") : undefined;
+                if (!reason)
+                    return { ok: false, reason: "event_invalid" };
+                outcome = reason;
+                break;
+            }
+            case "user/message": {
+                if (!data)
+                    return { ok: false, reason: "event_invalid" };
+                const message = messageEnvelope(data, "user");
+                if (!message || !validSurfaceOp(value.surfaceOp)) {
+                    return { ok: false, reason: "event_invalid" };
+                }
+                if (message.source.kind === "user") {
+                    if (value.surfaceOp !== "append") {
+                        return { ok: false, reason: "event_invalid" };
+                    }
+                    const text = textContent(message.content);
+                    if (text === undefined)
+                        return { ok: false, reason: "event_invalid" };
+                    if (text)
+                        userParts.push(text);
+                }
+                break;
+            }
+            case "assistant/message": {
+                if (!data || value.surfaceOp !== "append" || !isRecord(data.message)) {
+                    return { ok: false, reason: "event_invalid" };
+                }
+                const message = messageEnvelope(data.message, "assistant");
+                if (!message
+                    || message.source.kind !== "model"
+                    || !stringField(message.source, "provider")
+                    || !stringField(message.source, "model"))
+                    return { ok: false, reason: "event_invalid" };
+                const text = textContent(message.content);
+                if (text === undefined)
+                    return { ok: false, reason: "event_invalid" };
+                if (text)
+                    assistantParts.push(text);
+                break;
+            }
+        }
+    }
+    if (!outcome)
+        return { ok: false, reason: "turn_boundary_mismatch" };
+    if (outcome !== "completed") {
+        return { ok: false, reason: "turn_not_completed", outcome };
+    }
+    const userPrompt = userParts.join("\n\n").trim();
+    if (!userPrompt)
+        return { ok: false, reason: "user_prompt_missing" };
+    const assistantReply = assistantParts.join("\n\n").trim();
+    if (!assistantReply)
+        return { ok: false, reason: "assistant_message_missing" };
+    return {
+        ok: true,
+        turn: {
+            sessionId: input.sessionId,
+            turn: input.turn,
+            startSeq: input.startSeq,
+            endSeq: input.endSeq,
+            userPrompt,
+            assistantReply,
+            outcome,
+        },
+    };
+}
+function validateSessionHeader(input) {
+    const header = input.sessionHeader;
+    if (header.version !== DSH_SESSION_FORMAT_VERSION
+        || safeIntegerField(header, "createdAt", 0) === undefined)
+        return "session_header_invalid";
+    if (stringField(header, "id") !== input.sessionId)
+        return "session_identity_mismatch";
+    if (stringField(header, "cwd") !== input.cwd)
+        return "workspace_identity_mismatch";
+    if (Object.prototype.hasOwnProperty.call(header, "parentSession")) {
+        if (!stringField(header, "parentSession"))
+            return "session_header_invalid";
+    }
+    if (Object.prototype.hasOwnProperty.call(header, "origin")) {
+        if (header.origin !== "subagent")
+            return "session_header_invalid";
+        return "subagent_session";
+    }
+    const delegationDepth = optionalSafeIntegerField(header, "delegationDepth", 0);
+    if (!delegationDepth.ok)
+        return "session_header_invalid";
+    if ((delegationDepth.value ?? 0) > 0)
+        return "subagent_session";
+    return undefined;
+}
+function messageEnvelope(value, role) {
+    if (value.role !== role
+        || !Array.isArray(value.content)
+        || !isRecord(value.source)
+        || !stringField(value.source, "kind"))
+        return undefined;
+    return { content: value.content, source: value.source };
+}
+function textContent(content) {
+    const parts = [];
+    for (const block of content) {
+        if (!isRecord(block) || !stringField(block, "type"))
+            return undefined;
+        if (block.type !== "text")
+            continue;
+        if (typeof block.text !== "string")
+            return undefined;
+        if (block.text.trim())
+            parts.push(block.text);
+    }
+    return parts.join("\n").trim();
+}
+function validSurfaceOp(value) {
+    if (value === "append")
+        return true;
+    return isRecord(value)
+        && Object.keys(value).length === 3
+        && value.op === "replace"
+        && safeIntegerField(value, "start", 0) !== undefined
+        && safeIntegerField(value, "end", 0) !== undefined;
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function safeIntegerField(record, key, minimum) {
+    const value = record[key];
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= minimum
+        ? value
+        : undefined;
+}
+function optionalSafeIntegerField(record, key, minimum) {
+    if (!Object.prototype.hasOwnProperty.call(record, key))
+        return { ok: true };
+    const value = safeIntegerField(record, key, minimum);
+    return value === undefined ? { ok: false } : { ok: true, value };
+}

package/lib/memorax-code-backend/dist/clients/opencode/lifecycle.js

@@ -0,0 +1,54 @@
+export const openCodeAdapterLifecycle = {
+    async status({ argv, serviceOptions, backendUrl }) {
+        try {
+            return (await loadOpenCodePluginInstaller()).readOpenCodePluginStatus(openCodeAdapterOptions(argv, serviceOptions.home, backendUrl));
+        }
+        catch (error) {
+            return { ok: false, action: "status", error: error instanceof Error ? error.message : String(error) };
+        }
+    },
+    async prepareEnable({ argv, serviceOptions, backendUrl }) {
+        try {
+            return (await loadOpenCodePluginInstaller()).ensureOpenCodePluginInstalled(openCodeAdapterOptions(argv, serviceOptions.home, backendUrl));
+        }
+        catch (error) {
+            return { ok: false, action: "enable", error: error instanceof Error ? error.message : String(error) };
+        }
+    },
+    async disable({ argv, serviceOptions }) {
+        try {
+            return (await loadOpenCodePluginInstaller()).disableOpenCodePlugin(openCodeAdapterOptions(argv, serviceOptions.home));
+        }
+        catch (error) {
+            return { ok: false, action: "disable", error: error instanceof Error ? error.message : String(error) };
+        }
+    },
+    async remove({ argv, serviceOptions }) {
+        try {
+            return (await loadOpenCodePluginInstaller()).removeOpenCodePluginInstallation(openCodeAdapterOptions(argv, serviceOptions.home));
+        }
+        catch (error) {
+            return {
+                ok: false,
+                action: "opencode-plugin-remove",
+                reason: "plugin_remove_failed",
+                message: error instanceof Error ? error.message : String(error),
+            };
+        }
+    },
+};
+function openCodeAdapterOptions(argv, memoraxCodeHome, backendUrl) {
+    const openCodeConfigDir = argValue(argv, "--opencode-config-dir");
+    return {
+        ...(openCodeConfigDir ? { openCodeConfigDir } : {}),
+        memoraxCodeHome,
+        ...(backendUrl ? { backendUrl } : {}),
+    };
+}
+async function loadOpenCodePluginInstaller() {
+    return await import(new URL("../../../../memorax-code-opencode-adapter/src/plugin-install.mjs", import.meta.url).href);
+}
+function argValue(argv, name) {
+    const index = argv.indexOf(name);
+    return index >= 0 ? argv[index + 1] : undefined;
+}

package/lib/memorax-code-backend/dist/clients/opencode/memory-hook-runtime.js

@@ -0,0 +1,277 @@
+import { createAutomaticMemoryWritebackRuntime, } from "../../memory/automatic-writeback.js";
+import { retrieveAutomaticMemoryContext } from "../../memory/automatic-retrieval.js";
+import { createMemoryTurnCoordinator, } from "../../memory/turn-coordinator.js";
+import { createRepositoryMemorySessionRuntime, resolvedRepoMemoryWorktree, } from "../../memory/repository-session.js";
+import { traceContextFromOpenCodeHookBody } from "../../trace/context.js";
+import { markCurrentTraceTurnOutcome, recordTraceEvent, traceTurnEventId, writeCurrentTraceTurn, } from "../../trace/store.js";
+import { openCodeMessageTurn, } from "./message-turn.js";
+const OPENCODE_MEMORY_TURN_CLIENT = "opencode";
+export function createOpenCodeMemoryHookRuntime(options = {}) {
+    const now = options.now ?? (() => Date.now());
+    const automaticWritebackRuntime = options.turnCoordinator
+        ? undefined
+        : options.automaticWriteback
+            ? { enqueue: options.automaticWriteback }
+            : createAutomaticMemoryWritebackRuntime({ diagnosticLogger: options.diagnosticLogger });
+    const turnCoordinator = options.turnCoordinator ?? createMemoryTurnCoordinator({
+        automaticWriteback: automaticWritebackRuntime.enqueue,
+        now,
+        ttlMs: options.ttlMs,
+        maxEntries: options.maxEntries,
+        cleanupIntervalMs: options.cleanupIntervalMs,
+    });
+    const ownsTurnCoordinator = options.turnCoordinator === undefined;
+    const repositoryMemorySession = options.repositoryMemorySession ?? createRepositoryMemorySessionRuntime({
+        onScopeUpgrade: automaticWritebackRuntime?.discardForScopeUpgrade,
+    });
+    const ownsRepositoryMemorySession = options.repositoryMemorySession === undefined;
+    const retrievalTurns = new Set();
+    const retrievalTurnLimit = positiveInteger(options.maxEntries, 256);
+    return {
+        async recordTurnStart(command) {
+            turnCoordinator.pruneExpired();
+            const createdAt = now();
+            const traceContext = traceContextFromOpenCodeHookBody(command, new Date(createdAt).toISOString());
+            const repositoryMemory = await resolveHookRepositoryMemory(command, options, repositoryMemorySession);
+            const repoMemoryWorktree = resolvedRepoMemoryWorktree(repositoryMemory);
+            turnCoordinator.recordTurnStart({
+                client: OPENCODE_MEMORY_TURN_CLIENT,
+                sessionId: command.sessionId,
+                clientTurnId: command.userMessageId,
+                cwd: command.cwd,
+                workspaceKind: command.workspaceKind,
+                createdAt,
+                traceContext,
+                repositoryMemory,
+            });
+            await recordTraceBestEffort("opencode_memory.turn_start_event", recordTraceEvent({
+                eventId: traceTurnEventId(traceContext, "turn_start"),
+                memoraxCodeHome: options.memoraxCodeHome,
+                env: options.env,
+                traceContext,
+                type: "turn_start",
+                source: "opencode-plugin",
+                operation: "query",
+                ok: true,
+                request: {
+                    prompt: command.prompt,
+                    cwd: command.cwd,
+                },
+            }), options.diagnosticLogger);
+            await recordTraceBestEffort("opencode_memory.current_turn_write", writeCurrentTraceTurn(traceContext, {
+                client: "opencode",
+                memoraxCodeHome: options.memoraxCodeHome,
+                env: options.env,
+                now: () => new Date(now()),
+            }), options.diagnosticLogger);
+            options.diagnosticLogger?.("opencode_memory.turn_start", {
+                sessionId: command.sessionId,
+                userMessageId: command.userMessageId,
+                cacheSize: turnCoordinator.size(OPENCODE_MEMORY_TURN_CLIENT),
+                workspace: repositoryMemory.ok ? repositoryMemory.memory.scope?.repositorySlug : undefined,
+                workspaceScopeReason: repositoryMemory.ok ? undefined : repositoryMemory.reason,
+            });
+            const retrievalKey = JSON.stringify([command.sessionId, command.userMessageId]);
+            if (retrievalTurns.has(retrievalKey)) {
+                return {
+                    ok: true,
+                    ...(repoMemoryWorktree ? { repoMemoryWorktree } : {}),
+                };
+            }
+            retrievalTurns.add(retrievalKey);
+            while (retrievalTurns.size > retrievalTurnLimit) {
+                const oldest = retrievalTurns.values().next().value;
+                if (typeof oldest !== "string")
+                    break;
+                retrievalTurns.delete(oldest);
+            }
+            const retrieval = await retrieveAutomaticMemoryContext({
+                diagnosticLogger: options.diagnosticLogger,
+                env: options.env ?? process.env,
+                fetchImpl: options.fetchImpl,
+                memoryObservability: options.memoryObservability,
+                memoryObservabilitySource: "opencode_plugin_retrieval",
+                query: command.prompt,
+                repositoryMemory,
+                sessionKey: command.sessionId,
+                traceContext,
+            });
+            return {
+                ok: true,
+                ...(repoMemoryWorktree ? { repoMemoryWorktree } : {}),
+                ...(retrieval.context ? { additionalContext: retrieval.context } : {}),
+            };
+        },
+        async writeback(command) {
+            turnCoordinator.pruneExpired();
+            const key = openCodeTurnKey(command.sessionId, command.userMessageId);
+            const entry = turnCoordinator.getTurn(key);
+            const materialized = openCodeMessageTurn(command.messages, command);
+            if (!materialized.ok) {
+                options.diagnosticLogger?.("opencode_memory.writeback", {
+                    scheduled: false,
+                    reason: materialized.reason,
+                    sessionId: command.sessionId,
+                    userMessageId: command.userMessageId,
+                    assistantMessageId: command.assistantMessageId,
+                });
+                return { ok: true, scheduled: false, reason: materialized.reason };
+            }
+            if (materialized.turn.outcome === "interrupted") {
+                if (!entry) {
+                    options.diagnosticLogger?.("opencode_memory.writeback", {
+                        scheduled: false,
+                        reason: "turn_metadata_mismatch",
+                        sessionId: command.sessionId,
+                        userMessageId: command.userMessageId,
+                        assistantMessageId: command.assistantMessageId,
+                    });
+                    return { ok: true, scheduled: false, reason: "turn_metadata_mismatch" };
+                }
+                const traceContext = entry.traceContext;
+                await recordTraceBestEffort("opencode_memory.interrupted_turn_end_event", recordTraceEvent({
+                    eventId: traceTurnEventId(traceContext, "turn_end"),
+                    memoraxCodeHome: options.memoraxCodeHome,
+                    env: options.env,
+                    traceContext,
+                    type: "turn_end",
+                    source: "opencode-plugin",
+                    operation: "reply",
+                    ok: true,
+                    outcome: "interrupted",
+                    response: {
+                        assistantMessage: materialized.turn.assistantReply,
+                    },
+                }), options.diagnosticLogger);
+                await recordTraceBestEffort("opencode_memory.interrupted_current_turn_close", markCurrentTraceTurnOutcome(traceContext, "interrupted", {
+                    client: "opencode",
+                    memoraxCodeHome: options.memoraxCodeHome,
+                    env: options.env,
+                }), options.diagnosticLogger);
+                turnCoordinator.discardTurn(key, "interrupted");
+                options.diagnosticLogger?.("opencode_memory.writeback", {
+                    scheduled: false,
+                    reason: "interrupted",
+                    metadataDisposition: "consumed",
+                    sessionId: command.sessionId,
+                    userMessageId: command.userMessageId,
+                    assistantMessageId: command.assistantMessageId,
+                });
+                return { ok: true, scheduled: false, reason: "interrupted" };
+            }
+            const traceContext = entry?.traceContext
+                ?? traceContextFromOpenCodeHookBody(command, new Date(now()).toISOString());
+            await recordTraceBestEffort("opencode_memory.turn_end_event", recordTraceEvent({
+                eventId: traceTurnEventId(traceContext, "turn_end"),
+                memoraxCodeHome: options.memoraxCodeHome,
+                env: options.env,
+                traceContext,
+                type: "turn_end",
+                source: "opencode-plugin",
+                operation: "writeback",
+                ok: true,
+                outcome: materialized.turn.outcome,
+                response: {
+                    content: materialized.turn.assistantReply,
+                },
+            }), options.diagnosticLogger);
+            await recordTraceBestEffort("opencode_memory.current_turn_close", markCurrentTraceTurnOutcome(traceContext, "completed", {
+                client: "opencode",
+                memoraxCodeHome: options.memoraxCodeHome,
+                env: options.env,
+            }), options.diagnosticLogger);
+            const writeback = await turnCoordinator.completeMaterializedTurn({
+                key,
+                metadata: entry,
+                resolveRepositoryMemory: () => resolveCurrentHookRepositoryMemory(entry, command, options, repositoryMemorySession),
+                userText: materialized.turn.userPrompt,
+                assistantText: materialized.turn.assistantReply,
+                writeback: {
+                    client: OPENCODE_MEMORY_TURN_CLIENT,
+                    sessionKey: command.sessionId,
+                    env: options.env ?? process.env,
+                    fetchImpl: options.fetchImpl,
+                    memoryObservability: options.memoryObservability,
+                    memoryObservabilitySource: "opencode_plugin_writeback",
+                    traceContext,
+                },
+            });
+            if (!writeback.scheduled) {
+                options.diagnosticLogger?.("opencode_memory.writeback", {
+                    scheduled: false,
+                    reason: writeback.reason,
+                    metadataDisposition: writeback.metadataDisposition,
+                    sessionId: command.sessionId,
+                    userMessageId: command.userMessageId,
+                    assistantMessageId: command.assistantMessageId,
+                });
+                return { ok: true, scheduled: false, reason: writeback.reason };
+            }
+            options.diagnosticLogger?.("opencode_memory.writeback", {
+                scheduled: true,
+                metadataDisposition: writeback.metadataDisposition,
+                sessionId: command.sessionId,
+                userMessageId: command.userMessageId,
+                assistantMessageId: command.assistantMessageId,
+                promptChars: materialized.turn.userPrompt.length,
+                assistantChars: materialized.turn.assistantReply.length,
+                contentSource: "opencode_sdk_messages",
+            });
+            return { ok: true, scheduled: true };
+        },
+        size() {
+            return turnCoordinator.size(OPENCODE_MEMORY_TURN_CLIENT);
+        },
+        close() {
+            retrievalTurns.clear();
+            if (ownsTurnCoordinator)
+                turnCoordinator.close();
+            if (ownsRepositoryMemorySession)
+                repositoryMemorySession.close();
+            automaticWritebackRuntime?.close?.();
+        },
+    };
+}
+function openCodeTurnKey(sessionId, userMessageId) {
+    return {
+        client: OPENCODE_MEMORY_TURN_CLIENT,
+        sessionId,
+        clientTurnId: userMessageId,
+    };
+}
+async function resolveHookRepositoryMemory(command, options, repositoryMemorySession) {
+    return await repositoryMemorySession.resolve({
+        client: OPENCODE_MEMORY_TURN_CLIENT,
+        sessionId: command.sessionId,
+        workspaceRoot: command.cwd,
+        workspaceKind: command.workspaceKind,
+        memoraxCodeHome: options.memoraxCodeHome ?? options.env?.MEMORAX_CODE_HOME,
+        env: options.env,
+    });
+}
+async function resolveCurrentHookRepositoryMemory(entry, command, options, repositoryMemorySession) {
+    return await repositoryMemorySession.resolve({
+        client: OPENCODE_MEMORY_TURN_CLIENT,
+        sessionId: command.sessionId,
+        workspaceRoot: command.cwd ?? entry?.cwd,
+        workspaceKind: command.workspaceKind ?? entry?.workspaceKind,
+        requireBoundScope: true,
+        memoraxCodeHome: options.memoraxCodeHome ?? options.env?.MEMORAX_CODE_HOME,
+        env: options.env,
+    });
+}
+async function recordTraceBestEffort(label, promise, diagnosticLogger) {
+    try {
+        await promise;
+    }
+    catch (error) {
+        diagnosticLogger?.("opencode_trace.write_failed", {
+            label,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+function positiveInteger(value, fallback) {
+    const parsed = Number(value);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}

package/lib/memorax-code-backend/dist/clients/opencode/message-turn.js

@@ -0,0 +1,78 @@
+import { isRecord } from "../../shared/record.js";
+export function openCodeMessageTurn(messages, input) {
+    const user = messages.find((message) => messageId(message) === input.userMessageId);
+    if (!isMessageRecord(user) || user.info.role !== "user") {
+        return { ok: false, reason: "user_message_not_found" };
+    }
+    const assistant = messages.find((message) => messageId(message) === input.assistantMessageId);
+    if (!isMessageRecord(assistant) || assistant.info.role !== "assistant") {
+        return { ok: false, reason: "assistant_message_not_found" };
+    }
+    if (stringField(user.info, "sessionID") !== input.sessionId
+        || stringField(assistant.info, "sessionID") !== input.sessionId
+        || stringField(assistant.info, "parentID") !== input.userMessageId) {
+        return { ok: false, reason: "message_identity_mismatch" };
+    }
+    const assistantTime = isRecord(assistant.info.time) ? assistant.info.time : undefined;
+    if (!Number.isFinite(assistantTime?.completed)) {
+        return { ok: false, reason: "assistant_not_completed" };
+    }
+    const assistantError = assistant.info.error;
+    const interrupted = isRecord(assistantError) && assistantError.name === "MessageAbortedError";
+    if (assistantError !== undefined && assistantError !== null && !interrupted) {
+        return { ok: false, reason: "assistant_error" };
+    }
+    if (assistant.info.summary === true) {
+        return { ok: false, reason: "summary_message" };
+    }
+    if (hasCompactionPart(user.parts) || hasCompactionPart(assistant.parts)) {
+        return { ok: false, reason: "compaction_message" };
+    }
+    const userPrompt = messageText(user, input.sessionId, input.userMessageId);
+    if (!userPrompt)
+        return { ok: false, reason: "user_prompt_missing" };
+    const assistantReply = messageText(assistant, input.sessionId, input.assistantMessageId);
+    if (!assistantReply && !interrupted)
+        return { ok: false, reason: "assistant_message_missing" };
+    return {
+        ok: true,
+        turn: {
+            sessionId: input.sessionId,
+            userMessageId: input.userMessageId,
+            assistantMessageId: input.assistantMessageId,
+            userPrompt,
+            assistantReply,
+            outcome: interrupted ? "interrupted" : "completed",
+        },
+    };
+}
+function isMessageRecord(value) {
+    return isRecord(value) && isRecord(value.info) && Array.isArray(value.parts);
+}
+function messageId(value) {
+    return isMessageRecord(value) ? stringField(value.info, "id") : undefined;
+}
+function messageText(message, sessionId, messageId) {
+    return message.parts
+        .flatMap((part) => {
+        if (!isRecord(part)
+            || part.type !== "text"
+            || part.synthetic === true
+            || part.ignored === true
+            || stringField(part, "sessionID") !== sessionId
+            || stringField(part, "messageID") !== messageId) {
+            return [];
+        }
+        const text = stringField(part, "text");
+        return text ? [text] : [];
+    })
+        .join("\n\n")
+        .trim();
+}
+function hasCompactionPart(parts) {
+    return parts.some((part) => isRecord(part) && part.type === "compaction");
+}
+function stringField(value, key) {
+    const field = value[key];
+    return typeof field === "string" && field.trim() ? field.trim() : undefined;
+}