@rvboris/opencode-mempalace 0.1.0 → 0.2.0

package/dist/bridge/mempalace_adapter.py

@@ -1,7 +1,13 @@
 #!/usr/bin/env python3
 import json
 import sys
+import tempfile
+from contextlib import redirect_stdout
+from io import StringIO
+from pathlib import Path
 
+from mempalace.config import MempalaceConfig
+from mempalace.convo_miner import mine_convos
 from mempalace.mcp_server import (
     tool_add_drawer,
     tool_diary_write,
@@ -10,43 +16,69 @@ from mempalace.mcp_server import (
 )
 
 
-def main() -> int:
-    payload = json.load(sys.stdin)
-
-    mode = payload["mode"]
-    if mode == "search":
-        result = tool_search(
-            query=payload["query"],
-            limit=payload.get("limit", 5),
-            wing=payload.get("wing"),
-            room=payload.get("room"),
-        )
-    elif mode == "save":
-        result = tool_add_drawer(
-            wing=payload["wing"],
-            room=payload["room"],
-            content=payload["content"],
-            added_by=payload.get("added_by", "opencode"),
-        )
-    elif mode == "kg_add":
-        result = tool_kg_add(
-            subject=payload["subject"],
-            predicate=payload["predicate"],
-            object=payload["object"],
-            valid_from=payload.get("valid_from", ""),
-            source_closet=payload.get("source_closet", ""),
-        )
-    elif mode == "diary_write":
-        result = tool_diary_write(
-            agent_name=payload["agent_name"],
-            entry=payload["entry"],
-            topic=payload.get("topic", "autosave"),
-        )
-    else:
-        result = {"success": False, "error": f"Unknown mode: {mode}"}
-
+def write_result(result: dict) -> None:
     output = json.dumps(result, ensure_ascii=False)
     sys.stdout.buffer.write(output.encode("utf-8", errors="replace"))
+
+
+def main() -> int:
+    try:
+        payload = json.load(sys.stdin)
+
+        mode = payload["mode"]
+        if mode == "search":
+            result = tool_search(
+                query=payload["query"],
+                limit=payload.get("limit", 5),
+                wing=payload.get("wing"),
+                room=payload.get("room"),
+            )
+        elif mode == "save":
+            result = tool_add_drawer(
+                wing=payload["wing"],
+                room=payload["room"],
+                content=payload["content"],
+                added_by=payload.get("added_by", "opencode"),
+            )
+        elif mode == "kg_add":
+            result = tool_kg_add(
+                subject=payload["subject"],
+                predicate=payload["predicate"],
+                object=payload["object"],
+                valid_from=payload.get("valid_from", ""),
+                source_closet=payload.get("source_closet", ""),
+            )
+        elif mode == "diary_write":
+            result = tool_diary_write(
+                agent_name=payload["agent_name"],
+                entry=payload["entry"],
+                topic=payload.get("topic", "autosave"),
+            )
+        elif mode == "mine_messages":
+            palace_path = payload.get("palace_path") or MempalaceConfig().palace_path
+            extract_mode = payload.get("extract_mode", "general")
+            with tempfile.TemporaryDirectory(prefix="mempalace-autosave-") as tmpdir:
+                transcript_path = Path(tmpdir) / "session.txt"
+                transcript_path.write_text(payload["transcript"], encoding="utf-8")
+                with redirect_stdout(StringIO()):
+                    mine_convos(
+                        convo_dir=tmpdir,
+                        palace_path=palace_path,
+                        wing=payload.get("wing"),
+                        agent=payload.get("agent", "opencode"),
+                        extract_mode=extract_mode,
+                    )
+            result = {
+                "success": True,
+                "mode": "mine_messages",
+                "wing": payload.get("wing"),
+            }
+        else:
+            result = {"success": False, "error": f"Unknown mode: {mode}"}
+    except Exception as error:
+        result = {"success": False, "error": str(error)}
+
+    write_result(result)
     return 0
 
 

package/dist/plugin/hooks/event.d.ts

@@ -1,13 +1,7 @@
-type PluginContext = {
-    client: any;
-    project: any;
-    directory: string;
-    worktree: string;
-    $: any;
-};
-export declare const eventHooks: (ctx: PluginContext) => {
+import { type EventHookContext, type SessionEvent } from "../lib/types";
+export declare const eventHooks: (ctx: EventHookContext) => {
     event: ({ event }: {
-        event: any;
+        event: SessionEvent;
     }) => Promise<void>;
     "experimental.session.compacting": (input: {
         sessionID?: string;
@@ -16,4 +10,3 @@ export declare const eventHooks: (ctx: PluginContext) => {
         prompt?: string;
     }) => Promise<void>;
 };
-export {};

package/dist/plugin/hooks/event.js

@@ -1,7 +1,28 @@
-import { AutosaveReason, AutosaveStatus, buildTranscriptDigest, buildUserDigest, extractLastUserMessage, finalizeAutosave, getSessionState, markKeywordSavePending, markFailed, markPending, markRetrievalPending, shouldScheduleAutosave, } from "../lib/autosave";
+import { AutosaveReason, AutosaveStatus, buildMessageSnapshot, getMessageSnapshot, getSessionState, markAutosaveComplete, markKeywordSavePending, markFailed, markRetrievalPending, setMessageSnapshot, shouldScheduleAutosave, } from "../lib/autosave";
+import { executeAdapter } from "../lib/adapter";
 import { loadConfig } from "../lib/config";
+import { COMPACTION_CONTEXT_MESSAGE, DEFAULT_AGENT_NAME, LOG_MESSAGES } from "../lib/constants";
+import { getProjectName, loadSessionMessages } from "../lib/opencode";
+import { redactSecrets } from "../lib/privacy";
+import { getProjectScope } from "../lib/scope";
 import { writeLog } from "../lib/log";
+import { SESSION_EVENT_TYPES } from "../lib/types";
 const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const TRACKED_EVENT_TYPES = new Set(SESSION_EVENT_TYPES);
+const AUTOSAVE_TRIGGER_EVENT_TYPES = new Set([
+    "session.idle",
+    "session.compacted",
+    "session.deleted",
+    "session.error",
+]);
+const isTrackedEventType = (value) => TRACKED_EVENT_TYPES.has(value);
+const isAutosaveTriggerEventType = (value) => {
+    return AUTOSAVE_TRIGGER_EVENT_TYPES.has(value);
+};
+const getSessionId = (event) => {
+    const properties = event.properties;
+    return properties?.sessionID ?? properties?.info?.id;
+};
 const toReason = (eventType) => {
     if (eventType === "session.compacted")
         return AutosaveReason.Compacted;
@@ -9,55 +30,42 @@ const toReason = (eventType) => {
         return AutosaveReason.Error;
     return AutosaveReason.Idle;
 };
-const loadMessages = async (ctx, sessionId) => {
-    const response = await ctx.client.session.messages({ path: { id: sessionId } });
-    return response?.data ?? response ?? [];
-};
 export const eventHooks = (ctx) => {
     return {
         event: async ({ event }) => {
             try {
-                if (!["session.idle", "session.compacted", "session.error", "session.updated", "message.updated"].includes(event?.type))
+                if (!isTrackedEventType(event.type))
                     return;
-                const sessionId = event?.properties?.sessionID;
+                const sessionId = getSessionId(event);
                 if (!sessionId) {
-                    await writeLog("WARN", "autosave event missing sessionID", { eventType: event?.type });
+                    await writeLog("WARN", LOG_MESSAGES.autosaveEventMissingSessionId, { eventType: event.type });
                     return;
                 }
                 const config = await loadConfig();
-                if (event?.type === "session.updated" || event?.type === "message.updated") {
-                    const messages = await loadMessages(ctx, sessionId);
-                    const userDigest = buildUserDigest(messages);
+                if (event.type === "session.updated" || event.type === "message.updated") {
+                    const snapshot = buildMessageSnapshot(await loadSessionMessages(ctx.client, sessionId));
+                    setMessageSnapshot(sessionId, snapshot);
                     if (config.retrievalEnabled) {
-                        markRetrievalPending(sessionId, userDigest);
+                        markRetrievalPending(sessionId, snapshot.userDigest);
                     }
-                    const lastUserMessage = extractLastUserMessage(messages);
+                    const lastUserMessage = snapshot.lastUserMessage;
                     if (lastUserMessage && config.keywordSaveEnabled && config.keywordPatterns.length) {
                         const keywordPattern = new RegExp(`\\b(${config.keywordPatterns.map(escapeRegex).join("|")})\\b`, "i");
                         if (config.keywordSaveEnabled && keywordPattern.test(lastUserMessage)) {
                             markKeywordSavePending(sessionId);
-                            await writeLog("INFO", "keyword-triggered autosave hint detected", { sessionId });
+                            await writeLog("INFO", LOG_MESSAGES.keywordTriggeredAutosaveHintDetected, { sessionId });
                         }
                     }
                 }
-                if (!["session.idle", "session.compacted", "session.error"].includes(event?.type))
+                if (!isAutosaveTriggerEventType(event.type))
                     return;
-                await writeLog("INFO", "autosave trigger received", {
-                    eventType: event?.type,
+                await writeLog("INFO", LOG_MESSAGES.autosaveTriggerReceived, {
+                    eventType: event.type,
                     sessionId,
                 });
-                const state = getSessionState(sessionId);
-                if (state.status === AutosaveStatus.Running && event?.type === "session.idle") {
-                    const finalized = finalizeAutosave(sessionId);
-                    await writeLog("INFO", "finalized autosave turn", {
-                        sessionId,
-                        status: finalized.status,
-                        toolCalls: finalized.successfulToolCalls.length,
-                    });
-                }
-                if (event?.type === "session.error") {
+                if (event.type === "session.error") {
                     const failed = markFailed(sessionId);
-                    await writeLog("ERROR", "autosave failed on session error", {
+                    await writeLog("ERROR", LOG_MESSAGES.autosaveFailedOnSessionError, {
                         sessionId,
                         retryCount: failed.retryCount,
                     });
@@ -65,45 +73,70 @@ export const eventHooks = (ctx) => {
                 }
                 if (!config.autosaveEnabled)
                     return;
-                const messages = await loadMessages(ctx, sessionId);
-                const userDigest = buildUserDigest(messages);
-                const transcriptDigest = buildTranscriptDigest(messages);
+                const cachedSnapshot = getMessageSnapshot(sessionId);
+                const snapshot = cachedSnapshot ?? buildMessageSnapshot(await loadSessionMessages(ctx.client, sessionId));
+                if (!cachedSnapshot) {
+                    setMessageSnapshot(sessionId, snapshot);
+                }
+                const { transcript, transcriptDigest, userDigest } = snapshot;
                 if (!shouldScheduleAutosave(sessionId, userDigest, transcriptDigest)) {
-                    await writeLog("INFO", "skipping autosave state", {
+                    await writeLog("INFO", LOG_MESSAGES.skippingAutosaveState, {
                         sessionId,
-                        reason: toReason(event?.type),
+                        reason: toReason(event.type),
                         userDigest,
                         transcriptDigest,
                         status: getSessionState(sessionId).status,
                     });
                     return;
                 }
-                markPending(sessionId, toReason(event?.type), userDigest, transcriptDigest);
-                await writeLog("INFO", "marked autosave pending", {
+                const redactedTranscript = redactSecrets(transcript);
+                if (!redactedTranscript.trim()) {
+                    markAutosaveComplete(sessionId, userDigest, transcriptDigest, AutosaveStatus.Noop);
+                    await writeLog("INFO", LOG_MESSAGES.autosaveSkippedEmptyTranscript, { sessionId });
+                    return;
+                }
+                const wing = getProjectScope(getProjectName(ctx.project), config.projectWingPrefix).wing;
+                const result = await executeAdapter(ctx.$, {
+                    mode: "mine_messages",
+                    transcript: redactedTranscript,
+                    wing,
+                    extract_mode: config.autoMineExtractMode,
+                    agent: DEFAULT_AGENT_NAME,
+                });
+                if (result?.success === false) {
+                    const failed = markFailed(sessionId);
+                    await writeLog("ERROR", LOG_MESSAGES.autosaveMiningFailed, {
+                        sessionId,
+                        retryCount: failed.retryCount,
+                        result,
+                    });
+                    return;
+                }
+                const completed = markAutosaveComplete(sessionId, userDigest, transcriptDigest, AutosaveStatus.Saved);
+                await writeLog("INFO", LOG_MESSAGES.autosaveMinedSessionContext, {
                     sessionId,
-                    reason: toReason(event?.type),
+                    reason: toReason(event.type),
                     userDigest,
                     transcriptDigest,
+                    status: completed.status,
+                    wing,
                 });
             }
             catch (error) {
-                await writeLog("ERROR", "event hook failed", {
+                await writeLog("ERROR", LOG_MESSAGES.eventHookFailed, {
                     error: error instanceof Error ? error.message : String(error),
                 });
             }
         },
         "experimental.session.compacting": async (input, output) => {
             if (!input.sessionID) {
-                await writeLog("WARN", "compaction hook missing sessionID", {});
+                await writeLog("WARN", LOG_MESSAGES.compactionHookMissingSessionId, {});
                 return;
             }
-            const state = getSessionState(input.sessionID);
-            if (state.status !== AutosaveStatus.Pending)
-                return;
-            output.context.push("MemPalace autosave is pending. Before answering after compaction, persist durable facts, decisions, preferences, outcomes, and diary notes using MemPalace MCP tools. Do not dump the full transcript.");
-            await writeLog("INFO", "injected compaction autosave context", {
+            output.context.push(COMPACTION_CONTEXT_MESSAGE);
+            await writeLog("INFO", LOG_MESSAGES.injectedCompactionAutosaveContext, {
                 sessionId: input.sessionID,
-                reason: state.pendingReason,
+                reason: AutosaveReason.Compacted,
             });
         },
     };

package/dist/plugin/hooks/system.d.ts

@@ -1,10 +1,8 @@
-type PluginContext = {
-    client: any;
-    project: any;
-};
-export declare const systemHooks: (ctx: PluginContext) => {
-    "experimental.chat.system.transform": (_input: {}, output: {
+import type { SystemHookContext } from "../lib/types";
+export declare const systemHooks: (ctx: SystemHookContext) => {
+    "experimental.chat.system.transform": (input: {
+        sessionID?: string;
+    }, output: {
         system: string[];
     }) => Promise<void>;
 };
-export {};

package/dist/plugin/hooks/system.js

@@ -1,22 +1,27 @@
-import { AutosaveStatus, clearKeywordSavePending, extractLastUserMessage, getCurrentTurnSessionId, getSessionState, markRetrievalInjected, startAutosave, } from "../lib/autosave";
+import { buildMessageSnapshot, clearKeywordSavePending, getMessageSnapshot, getSessionState, markRetrievalInjected, setMessageSnapshot, } from "../lib/autosave";
 import { loadConfig } from "../lib/config";
-import { buildAutosaveInstruction, buildKeywordSaveInstruction, buildRetrievalInstruction } from "../lib/context";
+import { LOG_MESSAGES } from "../lib/constants";
+import { buildKeywordSaveInstruction, buildRetrievalInstruction } from "../lib/context";
 import { writeLog } from "../lib/log";
+import { getProjectName, loadSessionMessages } from "../lib/opencode";
 export const systemHooks = (ctx) => {
     return {
-        "experimental.chat.system.transform": async (_input, output) => {
+        "experimental.chat.system.transform": async (input, output) => {
             try {
-                const sessionId = getCurrentTurnSessionId();
+                const sessionId = input.sessionID;
                 if (!sessionId)
                     return;
                 const config = await loadConfig();
                 const state = getSessionState(sessionId);
-                const response = await ctx.client.session.messages({ path: { id: sessionId } });
-                const messages = response?.data ?? response ?? [];
-                const lastUserMessage = extractLastUserMessage(messages);
+                const cachedSnapshot = getMessageSnapshot(sessionId);
+                const snapshot = cachedSnapshot ?? buildMessageSnapshot(await loadSessionMessages(ctx.client, sessionId));
+                if (!cachedSnapshot) {
+                    setMessageSnapshot(sessionId, snapshot);
+                }
+                const lastUserMessage = snapshot.lastUserMessage;
                 if (config.retrievalEnabled && state.retrievalPending && lastUserMessage) {
                     output.system.push(buildRetrievalInstruction({
-                        projectName: ctx.project?.name,
+                        projectName: getProjectName(ctx.project),
                         projectWingPrefix: config.projectWingPrefix,
                         userWingPrefix: config.userWingPrefix,
                         maxInjectedItems: config.maxInjectedItems,
@@ -24,24 +29,16 @@ export const systemHooks = (ctx) => {
                         lastUserMessage,
                     }));
                     markRetrievalInjected(sessionId);
-                    await writeLog("INFO", "injected retrieval instruction", { sessionId });
+                    await writeLog("INFO", LOG_MESSAGES.injectedRetrievalInstruction, { sessionId });
                 }
                 if (state.keywordSavePending) {
                     output.system.push(buildKeywordSaveInstruction());
                     clearKeywordSavePending(sessionId);
-                    await writeLog("INFO", "injected keyword save instruction", { sessionId });
+                    await writeLog("INFO", LOG_MESSAGES.injectedKeywordSaveInstruction, { sessionId });
                 }
-                if (state.status !== AutosaveStatus.Pending || !state.pendingReason)
-                    return;
-                output.system.push(buildAutosaveInstruction(state.pendingReason));
-                startAutosave(sessionId);
-                await writeLog("INFO", "injected hidden autosave instruction", {
-                    sessionId,
-                    reason: state.pendingReason,
-                });
             }
             catch (error) {
-                await writeLog("ERROR", "system transform hook failed", {
+                await writeLog("ERROR", LOG_MESSAGES.systemTransformHookFailed, {
                     error: error instanceof Error ? error.message : String(error),
                 });
             }

package/dist/plugin/hooks/tool.d.ts

@@ -3,15 +3,7 @@ export declare const toolHooks: () => {
         tool: string;
         sessionID?: string;
         callID?: string;
-    }, output: {
-        args: any;
-    }) => Promise<void>;
-    "tool.execute.after": (input: {
-        tool: string;
-        sessionID?: string;
-        callID?: string;
-    }, output: {
-        output: string;
-        metadata: any;
+    }, _output: {
+        args: Record<string, unknown>;
     }) => Promise<void>;
 };

package/dist/plugin/hooks/tool.js

@@ -1,60 +1,15 @@
+import { LOG_MESSAGES, TOOL_ERROR_MESSAGES } from "../lib/constants";
 import { writeLog } from "../lib/log";
-import { AutosaveStatus, getSessionState, markMutationToolCall, recordSuccessfulTool, shouldCountSuccessfulTool } from "../lib/autosave";
 import { isDirectMempalaceMutationTool } from "../lib/enforcement";
-const isMempalaceTool = (tool) => tool === "mempalace_memory";
-const isSuccessfulToolOutput = (output) => {
-    const text = `${output.output || ""} ${JSON.stringify(output.metadata || {})}`.toLowerCase();
-    return !text.includes("\"success\":false") && !text.includes("error");
-};
-const getMetadataSessionId = (metadata) => {
-    return metadata?.sessionID || metadata?.sessionId || metadata?.session?.id;
-};
 export const toolHooks = () => {
     return {
-        "tool.execute.before": async (input, output) => {
+        "tool.execute.before": async (input, _output) => {
             if (isDirectMempalaceMutationTool(input.tool)) {
-                await writeLog("WARN", "blocked direct mempalace mutation tool", {
+                await writeLog("WARN", LOG_MESSAGES.blockedDirectMempalaceMutationTool, {
                     tool: input.tool,
                     sessionId: input.sessionID,
                 });
-                throw new Error("Use mempalace_memory instead of direct MemPalace mutation tools");
-            }
-            if (input.tool !== "mempalace_memory" || !input.sessionID)
-                return;
-            const mode = output.args?.mode;
-            if (mode === "save" || mode === "kg_add" || mode === "diary_write") {
-                markMutationToolCall(input.sessionID, input.callID);
-            }
-        },
-        "tool.execute.after": async (input, output) => {
-            try {
-                if (!input.sessionID) {
-                    await writeLog("WARN", "tool.execute.after missing sessionID", { tool: input.tool });
-                    return;
-                }
-                if (!isMempalaceTool(input.tool))
-                    return;
-                const state = getSessionState(input.sessionID);
-                if (state.status !== AutosaveStatus.Running)
-                    return;
-                const metadataSessionId = getMetadataSessionId(output.metadata);
-                if (metadataSessionId && metadataSessionId !== input.sessionID)
-                    return;
-                if (!isSuccessfulToolOutput(output))
-                    return;
-                if (!shouldCountSuccessfulTool(input.sessionID, input.tool, input.callID))
-                    return;
-                recordSuccessfulTool(input.sessionID, input.tool, input.callID);
-                await writeLog("INFO", "observed mempalace tool during autosave", {
-                    sessionId: input.sessionID,
-                    tool: input.tool,
-                    count: getSessionState(input.sessionID).successfulToolCalls.length,
-                });
-            }
-            catch (error) {
-                await writeLog("ERROR", "tool.execute.after hook failed", {
-                    error: error instanceof Error ? error.message : String(error),
-                });
+                throw new Error(TOOL_ERROR_MESSAGES.directMutationBlocked);
             }
         },
     };

package/dist/plugin/index.js

@@ -1,4 +1,3 @@
-import { chatParamHooks } from "./hooks/chat-params";
 import { eventHooks } from "./hooks/event";
 import { systemHooks } from "./hooks/system";
 import { toolHooks } from "./hooks/tool";
@@ -7,7 +6,6 @@ import { mempalaceMemoryTool } from "./tools/mempalace-memory";
 export const MempalaceAutosavePlugin = async (ctx) => {
     setLogger(ctx.client);
     return {
-        ...chatParamHooks(),
         ...eventHooks(ctx),
         ...systemHooks(ctx),
         ...toolHooks(),

package/dist/plugin/lib/adapter.d.ts

@@ -1 +1,2 @@
-export declare const executeAdapter: (_shell: any, payload: Record<string, unknown>, retries?: number) => Promise<any>;
+import type { AdapterRequest, AdapterResponse } from "./types";
+export declare const executeAdapter: (_shell: unknown, payload: AdapterRequest, retries?: number) => Promise<AdapterResponse>;

package/dist/plugin/lib/adapter.js

@@ -1,35 +1,68 @@
 import { spawn } from "node:child_process";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { DEFAULT_ADAPTER_TIMEOUT_MS, ENV_KEYS, TOOL_ERROR_MESSAGES } from "./constants";
 const getAdapterPath = () => {
     const here = path.dirname(fileURLToPath(import.meta.url));
     return path.resolve(here, "..", "..", "bridge", "mempalace_adapter.py");
 };
-const getPythonCommand = () => process.env.MEMPALACE_ADAPTER_PYTHON || "python";
+const getPythonCommand = () => process.env[ENV_KEYS.adapterPython] || "python";
+const getAdapterTimeoutMs = () => {
+    const raw = process.env[ENV_KEYS.adapterTimeoutMs];
+    if (!raw)
+        return DEFAULT_ADAPTER_TIMEOUT_MS;
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_ADAPTER_TIMEOUT_MS;
+};
+const isAdapterResponse = (value) => {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+};
 export const executeAdapter = async (_shell, payload, retries = 3) => {
     let lastError;
+    const timeoutMs = getAdapterTimeoutMs();
     for (let attempt = 0; attempt <= retries; attempt += 1) {
         try {
             const text = await new Promise((resolve, reject) => {
                 const child = spawn(getPythonCommand(), [getAdapterPath()], {
                     stdio: ["pipe", "pipe", "pipe"],
                 });
+                let settled = false;
                 const stdout = [];
                 const stderr = [];
+                const timeoutId = setTimeout(() => {
+                    child.kill();
+                    if (settled)
+                        return;
+                    settled = true;
+                    reject(new Error(`${TOOL_ERROR_MESSAGES.adapterTimedOut} after ${timeoutMs}ms`));
+                }, timeoutMs);
+                const finish = (handler) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    clearTimeout(timeoutId);
+                    handler();
+                };
                 child.stdout.on("data", (chunk) => stdout.push(Buffer.from(chunk)));
                 child.stderr.on("data", (chunk) => stderr.push(Buffer.from(chunk)));
-                child.on("error", reject);
+                child.on("error", (error) => finish(() => reject(error)));
                 child.on("close", (code) => {
-                    if (code === 0) {
-                        resolve(Buffer.concat(stdout).toString("utf8"));
-                        return;
-                    }
-                    reject(new Error(Buffer.concat(stderr).toString("utf8") || `Adapter exited with code ${code}`));
+                    finish(() => {
+                        if (code === 0) {
+                            resolve(Buffer.concat(stdout).toString("utf8"));
+                            return;
+                        }
+                        reject(new Error(Buffer.concat(stderr).toString("utf8") || `Adapter exited with code ${code}`));
+                    });
                 });
                 child.stdin.write(JSON.stringify(payload), "utf8");
                 child.stdin.end();
             });
-            return JSON.parse(text);
+            const parsed = JSON.parse(text);
+            if (!isAdapterResponse(parsed)) {
+                throw new Error(TOOL_ERROR_MESSAGES.invalidAdapterPayload);
+            }
+            return parsed;
         }
         catch (error) {
             lastError = error;