opencode-graphiti 0.1.0 → 0.1.2

package/esm/src/index.js

@@ -1,22 +1,14 @@
 import { loadConfig } from "./config.js";
+import { createChatHandler } from "./handlers/chat.js";
+import { createCompactingHandler } from "./handlers/compacting.js";
+import { createEventHandler } from "./handlers/event.js";
 import { GraphitiClient } from "./services/client.js";
-import { createPreemptiveCompactionHandler, getCompactionContext, handleCompaction, } from "./services/compaction.js";
-import { formatMemoryContext } from "./services/context.js";
 import { logger } from "./services/logger.js";
-export const makeGroupId = (prefix, directory) => {
-    const parts = directory?.split("/").filter(Boolean) ?? [];
-    const projectName = parts[parts.length - 1] || "default";
-    const rawGroupId = `${prefix}_${projectName}`;
-    return rawGroupId.replace(/[^A-Za-z0-9_-]/g, "_");
-};
-const isTextPart = (value) => {
-    if (!value || typeof value !== "object")
-        return false;
-    const part = value;
-    return part.type === "text" && typeof part.text === "string" &&
-        !part.synthetic;
-};
-const extractTextFromParts = (parts) => parts.filter(isTextPart).map((part) => part.text).join(" ").trim();
+import { SessionManager } from "./session.js";
+import { makeGroupId, makeUserGroupId } from "./utils.js";
+/**
+ * OpenCode plugin entry point for Graphiti memory integration.
+ */
 export const graphiti = async (input) => {
     const config = loadConfig();
     const client = new GraphitiClient(config.endpoint);
@@ -27,410 +19,27 @@ export const graphiti = async (input) => {
         logger.warn("Memory features will be unavailable until connection is established");
     }
     const defaultGroupId = makeGroupId(config.groupIdPrefix, input.directory);
+    const defaultUserGroupId = makeUserGroupId(config.groupIdPrefix);
     logger.info("Plugin initialized. Group ID:", defaultGroupId);
-    const sessions = new Map();
-    const parentIdCache = new Map();
-    const pendingAssistantMessages = new Map();
-    const bufferedAssistantMessageIds = new Set();
-    const resolveParentId = async (sessionId) => {
-        if (parentIdCache.has(sessionId)) {
-            return parentIdCache.get(sessionId) ?? null;
-        }
-        try {
-            const response = await sdkClient.session.get({
-                path: { id: sessionId },
-            });
-            const sessionInfo = typeof response === "object" && response !== null &&
-                "data" in response
-                ? response.data
-                : response;
-            if (!sessionInfo)
-                return undefined;
-            const parentId = sessionInfo.parentID ?? null;
-            parentIdCache.set(sessionId, parentId);
-            return parentId;
-        }
-        catch (err) {
-            logger.debug("Failed to resolve session parentID", { sessionId, err });
-            return undefined;
-        }
-    };
-    const resolveSessionState = async (sessionId) => {
-        const parentId = await resolveParentId(sessionId);
-        if (parentId === undefined)
-            return { state: null, resolved: false };
-        if (parentId) {
-            sessions.delete(sessionId);
-            return { state: null, resolved: true };
-        }
-        let state = sessions.get(sessionId);
-        if (!state) {
-            state = {
-                groupId: defaultGroupId,
-                injectedMemories: false,
-                messageCount: 0,
-                pendingMessages: [],
-                isMain: true,
-            };
-            sessions.set(sessionId, state);
-        }
-        return { state, resolved: true };
-    };
-    const isSubagentSession = async (sessionId) => {
-        const parentId = await resolveParentId(sessionId);
-        return !!parentId;
-    };
-    const fetchLatestAssistantMessage = async (sessionId) => {
-        try {
-            const response = await sdkClient.session.messages({
-                sessionID: sessionId,
-                limit: 20,
-            });
-            const payload = response && typeof response === "object" &&
-                "data" in response
-                ? response.data
-                : response;
-            const messages = Array.isArray(payload)
-                ? payload
-                : [];
-            if (messages.length === 0)
-                return null;
-            const lastAssistant = [...messages]
-                .reverse()
-                .find((message) => message.info?.role === "assistant");
-            if (!lastAssistant)
-                return null;
-            const text = extractTextFromParts(lastAssistant.parts);
-            if (!text)
-                return null;
-            return { id: lastAssistant.info?.id, text };
-        }
-        catch (err) {
-            logger.debug("Failed to list session messages for fallback", {
-                sessionId,
-                err,
-            });
-            return null;
-        }
-    };
-    const finalizeAssistantMessage = (state, sessionId, messageId, source) => {
-        const key = `${sessionId}:${messageId}`;
-        if (bufferedAssistantMessageIds.has(key))
-            return;
-        const buffered = pendingAssistantMessages.get(key);
-        pendingAssistantMessages.delete(key);
-        bufferedAssistantMessageIds.add(key);
-        const messageText = buffered?.text?.trim() ?? "";
-        const messagePreview = messageText.slice(0, 120);
-        logger.info("Assistant message completed", {
-            hook: source,
-            sessionId,
-            messageID: messageId,
-            source,
-            messageLength: messageText.length,
-            preview: messagePreview,
-        });
-        if (!messageText) {
-            logger.debug("Assistant message completed without buffered text", {
-                hook: source,
-                sessionId,
-                messageID: messageId,
-                source,
-            });
-            return;
-        }
-        state.pendingMessages.push(`Assistant: ${messageText}`);
-        logger.info("Buffered assistant reply", {
-            hook: source,
-            sessionId,
-            messageID: messageId,
-            source,
-            messageLength: messageText.length,
-            preview: messagePreview,
-        });
-    };
-    const flushPendingMessages = async (sessionId, sourceDescription, minBytes) => {
-        const state = sessions.get(sessionId);
-        if (!state || state.pendingMessages.length === 0)
-            return;
-        const lastMessage = state.pendingMessages.at(-1);
-        if (lastMessage) {
-            const separatorIndex = lastMessage.indexOf(":");
-            const role = separatorIndex === -1
-                ? lastMessage.trim().toLowerCase()
-                : lastMessage.slice(0, separatorIndex).trim().toLowerCase();
-            if (role === "user") {
-                const fallback = await fetchLatestAssistantMessage(sessionId);
-                if (fallback?.text) {
-                    const fallbackKey = fallback.id
-                        ? `${sessionId}:${fallback.id}`
-                        : undefined;
-                    const alreadyBuffered = fallbackKey
-                        ? bufferedAssistantMessageIds.has(fallbackKey)
-                        : state.pendingMessages.some((message) => message.startsWith("Assistant:") &&
-                            message.includes(fallback.text));
-                    if (!alreadyBuffered) {
-                        state.pendingMessages.push(`Assistant: ${fallback.text}`);
-                        if (fallbackKey) {
-                            bufferedAssistantMessageIds.add(fallbackKey);
-                        }
-                        logger.info("Fallback assistant fetch used", {
-                            sessionId,
-                            messageID: fallback.id,
-                            messageLength: fallback.text.length,
-                        });
-                    }
-                }
-            }
-        }
-        const combined = state.pendingMessages.join("\n\n");
-        if (combined.length < minBytes)
-            return;
-        const messagesToFlush = [...state.pendingMessages];
-        state.pendingMessages = [];
-        const messageLines = messagesToFlush.map((message) => {
-            const separatorIndex = message.indexOf(":");
-            const role = separatorIndex === -1
-                ? "Unknown"
-                : message.slice(0, separatorIndex).trim();
-            const text = separatorIndex === -1
-                ? message
-                : message.slice(separatorIndex + 1).trim();
-            return `${role}: ${text}`;
-        });
-        try {
-            const name = combined.slice(0, 80).replace(/\n/g, " ");
-            logger.info(`Flushing ${messagesToFlush.length} buffered message(s).`);
-            logger.info(`Buffered message contents:\n${messageLines.join("\n")}`, { sessionId });
-            await client.addEpisode({
-                name: `Buffered messages: ${name}`,
-                episodeBody: combined,
-                groupId: state.groupId,
-                source: "text",
-                sourceDescription,
-            });
-            logger.info("Flushed buffered messages to Graphiti");
-        }
-        catch (err) {
-            logger.error(`Failed to flush messages for ${sessionId}:`, err);
-            const currentState = sessions.get(sessionId);
-            if (currentState) {
-                currentState.pendingMessages = [
-                    ...messagesToFlush,
-                    ...currentState.pendingMessages,
-                ];
-            }
-        }
-    };
-    const preemptiveCompaction = createPreemptiveCompactionHandler({
-        compactionThreshold: config.compactionThreshold,
-        minTokensForCompaction: config.minTokensForCompaction,
-        compactionCooldownMs: config.compactionCooldownMs,
-        autoResumeAfterCompaction: config.autoResumeAfterCompaction,
-    }, {
-        sdkClient: sdkClient,
-        directory: input.directory,
-    });
+    const sessionManager = new SessionManager(defaultGroupId, defaultUserGroupId, sdkClient, client);
     return {
-        event: async ({ event }) => {
-            try {
-                if (event.type === "session.created") {
-                    const info = event.properties.info;
-                    const sessionId = info.id;
-                    const parentId = info.parentID ?? null;
-                    const isMain = !parentId;
-                    parentIdCache.set(sessionId, parentId);
-                    logger.info("Session created:", {
-                        sessionId,
-                        isMain,
-                        parentID: info.parentID,
-                    });
-                    if (isMain) {
-                        sessions.set(sessionId, {
-                            groupId: defaultGroupId,
-                            injectedMemories: false,
-                            messageCount: 0,
-                            pendingMessages: [],
-                            isMain,
-                        });
-                    }
-                    else {
-                        logger.debug("Ignoring subagent session:", sessionId);
-                    }
-                    return;
-                }
-                if (event.type === "session.compacted") {
-                    const sessionId = event.properties.sessionID;
-                    const { state, resolved } = await resolveSessionState(sessionId);
-                    if (!resolved) {
-                        logger.debug("Unable to resolve session compaction:", sessionId);
-                        return;
-                    }
-                    if (!state?.isMain) {
-                        logger.debug("Ignoring non-main compaction:", sessionId);
-                        return;
-                    }
-                    const summary = event.properties.summary ||
-                        "";
-                    await flushPendingMessages(sessionId, "Buffered messages flushed before compaction", 0);
-                    if (summary) {
-                        await handleCompaction({
-                            client,
-                            config,
-                            groupId: state.groupId,
-                            summary,
-                            sessionId,
-                        });
-                    }
-                    return;
-                }
-                if (event.type === "session.idle") {
-                    const sessionId = event.properties.sessionID;
-                    const { state, resolved } = await resolveSessionState(sessionId);
-                    if (!resolved) {
-                        logger.debug("Unable to resolve idle session:", sessionId);
-                        return;
-                    }
-                    if (!state?.isMain) {
-                        logger.debug("Ignoring non-main idle session:", sessionId);
-                        return;
-                    }
-                    await flushPendingMessages(sessionId, "Buffered messages from OpenCode session", 50);
-                    return;
-                }
-                if (event.type === "message.updated") {
-                    const info = event.properties.info;
-                    const sessionId = info.sessionID;
-                    logger.info("Message event fired", {
-                        hook: "message.updated",
-                        eventType: "message.updated",
-                        sessionId,
-                        role: info.role,
-                        messageID: info.id,
-                    });
-                    const { state, resolved } = await resolveSessionState(sessionId);
-                    if (!resolved) {
-                        logger.debug("Unable to resolve session for message update:", {
-                            sessionId,
-                            messageID: info.id,
-                            role: info.role,
-                        });
-                        return;
-                    }
-                    if (!state?.isMain) {
-                        logger.debug("Ignoring non-main message update:", sessionId);
-                        return;
-                    }
-                    if (info.role !== "assistant") {
-                        pendingAssistantMessages.delete(`${sessionId}:${info.id}`);
-                        return;
-                    }
-                    const key = `${sessionId}:${info.id}`;
-                    const time = info.time;
-                    if (!time?.completed)
-                        return;
-                    if (bufferedAssistantMessageIds.has(key))
-                        return;
-                    finalizeAssistantMessage(state, sessionId, info.id, "message.updated");
-                    if (info.tokens && info.providerID && info.modelID) {
-                        preemptiveCompaction
-                            .checkAndTriggerCompaction(sessionId, info.tokens, info.providerID, info.modelID)
-                            .catch((err) => logger.error("Preemptive compaction check failed", err));
-                    }
-                    return;
-                }
-                if (event.type === "message.part.updated") {
-                    const part = event.properties.part;
-                    if (part.type !== "text" || part.synthetic)
-                        return;
-                    const sessionId = part.sessionID;
-                    const messageId = part.messageID;
-                    const key = `${sessionId}:${messageId}`;
-                    pendingAssistantMessages.set(key, {
-                        sessionId,
-                        text: part.text,
-                    });
-                }
-            }
-            catch (err) {
-                logger.error("Event handler error", { type: event.type, err });
-            }
-        },
-        "chat.message": async ({ sessionID }, output) => {
-            if (await isSubagentSession(sessionID)) {
-                logger.debug("Ignoring subagent chat message:", sessionID);
-                return;
-            }
-            const { state, resolved } = await resolveSessionState(sessionID);
-            if (!resolved) {
-                output.allow_buffering = true;
-                logger.debug("Unable to resolve session for message:", { sessionID });
-                return;
-            }
-            if (!state?.isMain) {
-                logger.debug("Ignoring subagent chat message:", sessionID);
-                return;
-            }
-            state.messageCount++;
-            const messageText = extractTextFromParts(output.parts);
-            if (!messageText)
-                return;
-            state.pendingMessages.push(`User: ${messageText}`);
-            logger.info("Buffered user message", {
-                hook: "chat.message",
-                sessionID,
-                messageLength: messageText.length,
-            });
-            if (!state.injectedMemories && config.injectOnFirstMessage) {
-                state.injectedMemories = true;
-                try {
-                    const [facts, nodes] = await Promise.all([
-                        client.searchFacts({
-                            query: messageText,
-                            groupIds: [state.groupId],
-                            maxFacts: config.maxFacts,
-                        }),
-                        client.searchNodes({
-                            query: messageText,
-                            groupIds: [state.groupId],
-                            maxNodes: config.maxNodes,
-                        }),
-                    ]);
-                    const memoryContext = formatMemoryContext(facts, nodes);
-                    if (memoryContext) {
-                        output.parts.unshift({
-                            type: "text",
-                            text: memoryContext,
-                            id: `graphiti-memory-${Date.now()}`,
-                            sessionID: output.message.sessionID,
-                            messageID: output.message.id,
-                            synthetic: true,
-                        });
-                        logger.info(`Injected ${facts.length} facts and ${nodes.length} nodes`);
-                    }
-                }
-                catch (err) {
-                    logger.error("Failed to inject memories:", err);
-                }
-            }
-        },
-        "experimental.session.compacting": async ({ sessionID }, output) => {
-            const state = sessions.get(sessionID);
-            if (!state?.isMain) {
-                logger.debug("Ignoring non-main compaction context:", sessionID);
-                return;
-            }
-            const groupId = state.groupId || defaultGroupId;
-            const additionalContext = await getCompactionContext({
-                client,
-                config,
-                groupId,
-                contextStrings: output.context,
-            });
-            if (additionalContext.length > 0) {
-                output.context.push(...additionalContext);
-                logger.info("Injected persistent knowledge into compaction context");
-            }
-        },
+        event: createEventHandler({
+            sessionManager,
+            client,
+            defaultGroupId,
+            sdkClient: sdkClient,
+            directory: input.directory,
+            groupIdPrefix: config.groupIdPrefix,
+        }),
+        "chat.message": createChatHandler({
+            sessionManager,
+            injectionInterval: config.injectionInterval,
+            client,
+        }),
+        "experimental.session.compacting": createCompactingHandler({
+            sessionManager,
+            client,
+            defaultGroupId,
+        }),
     };
 };

package/esm/src/services/client.d.ts

@@ -1,16 +1,39 @@
-import type { GraphitiEpisode, GraphitiFact, GraphitiNode } from "../types/index.js";
+import type { GraphitiFact, GraphitiNode } from "../types/index.js";
+/**
+ * Graphiti MCP client wrapper for connecting, querying,
+ * and persisting episodes with basic reconnection handling.
+ */
 export declare class GraphitiClient {
     private client;
     private transport;
     private connected;
     private endpoint;
+    /**
+     * Create a Graphiti client bound to the given MCP endpoint URL.
+     */
     constructor(endpoint: string);
+    /** Create a fresh MCP Client and Transport pair. */
+    private createClientAndTransport;
+    /**
+     * Establish a connection to the Graphiti MCP server.
+     * Creates a fresh Client/Transport if a previous attempt failed.
+     */
     connect(): Promise<boolean>;
+    /**
+     * Close the underlying MCP client connection.
+     */
     disconnect(): Promise<void>;
     private callTool;
     private isSessionExpired;
     private reconnect;
+    /**
+     * Parse MCP tool results into JSON when possible.
+     * Public for testing.
+     */
     parseToolResult(result: unknown): unknown;
+    /**
+     * Add an episode to Graphiti memory.
+     */
     addEpisode(params: {
         name: string;
         episodeBody: string;
@@ -18,20 +41,25 @@ export declare class GraphitiClient {
         source?: "text" | "json" | "message";
         sourceDescription?: string;
     }): Promise<void>;
+    /**
+     * Search Graphiti facts matching the provided query.
+     */
     searchFacts(params: {
         query: string;
         groupIds?: string[];
         maxFacts?: number;
     }): Promise<GraphitiFact[]>;
+    /**
+     * Search Graphiti nodes matching the provided query.
+     */
     searchNodes(params: {
         query: string;
         groupIds?: string[];
         maxNodes?: number;
     }): Promise<GraphitiNode[]>;
-    getEpisodes(params: {
-        groupIds?: string[];
-        maxEpisodes?: number;
-    }): Promise<GraphitiEpisode[]>;
+    /**
+     * Check whether the Graphiti MCP server is reachable.
+     */
     getStatus(): Promise<boolean>;
 }
 //# sourceMappingURL=client.d.ts.map

package/esm/src/services/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/src/services/client.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,eAAe,EACf,YAAY,EAEZ,YAAY,EAEb,MAAM,mBAAmB,CAAC;AAG3B,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,SAAS,CAAgC;IACjD,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAS;gBAEb,QAAQ,EAAE,MAAM;IAStB,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;IAa3B,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;YAOnB,QAAQ;IAkCtB,OAAO,CAAC,gBAAgB;YASV,SAAS;IAgBvB,eAAe,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO;IAyBnC,UAAU,CAAC,MAAM,EAAE;QACvB,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE,MAAM,CAAC;QACpB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;QACrC,iBAAiB,CAAC,EAAE,MAAM,CAAC;KAC5B,GAAG,OAAO,CAAC,IAAI,CAAC;IAWX,WAAW,CAAC,MAAM,EAAE;QACxB,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAsBrB,WAAW,CAAC,MAAM,EAAE;QACxB,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAsBrB,WAAW,CAAC,MAAM,EAAE;QACxB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAaxB,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC;CAQpC"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/src/services/client.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,YAAY,EAEZ,YAAY,EAEb,MAAM,mBAAmB,CAAC;AAG3B;;;GAGG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,SAAS,CAAgC;IACjD,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAS;IAEzB;;OAEG;gBACS,QAAQ,EAAE,MAAM;IAM5B,oDAAoD;IACpD,OAAO,CAAC,wBAAwB;IAOhC;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;IAgBjC;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;YAOnB,QAAQ;IAkCtB,OAAO,CAAC,gBAAgB;YASV,SAAS;IAavB;;;OAGG;IACH,eAAe,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO;IAyBzC;;OAEG;IACG,UAAU,CAAC,MAAM,EAAE;QACvB,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE,MAAM,CAAC;QACpB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;QACrC,iBAAiB,CAAC,EAAE,MAAM,CAAC;KAC5B,GAAG,OAAO,CAAC,IAAI,CAAC;IAWjB;;OAEG;IACG,WAAW,CAAC,MAAM,EAAE;QACxB,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAsB3B;;OAEG;IACG,WAAW,CAAC,MAAM,EAAE;QACxB,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;QACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAsB3B;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC;CAQpC"}

package/esm/src/services/client.js

@@ -1,8 +1,14 @@
-import * as dntShim from "../../_dnt.shims.js";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { logger } from "./logger.js";
+/**
+ * Graphiti MCP client wrapper for connecting, querying,
+ * and persisting episodes with basic reconnection handling.
+ */
 export class GraphitiClient {
+    /**
+     * Create a Graphiti client bound to the given MCP endpoint URL.
+     */
     constructor(endpoint) {
         Object.defineProperty(this, "client", {
             enumerable: true,
@@ -30,12 +36,23 @@ export class GraphitiClient {
         });
         this.endpoint = endpoint;
         this.client = new Client({ name: "opencode-graphiti", version: "0.1.0" });
-        const url = new dntShim.dntGlobalThis.URL(endpoint);
-        this.transport = new StreamableHTTPClientTransport(url);
+        this.transport = new StreamableHTTPClientTransport(new URL(endpoint));
     }
+    /** Create a fresh MCP Client and Transport pair. */
+    createClientAndTransport() {
+        this.client = new Client({ name: "opencode-graphiti", version: "0.1.0" });
+        this.transport = new StreamableHTTPClientTransport(new URL(this.endpoint));
+    }
+    /**
+     * Establish a connection to the Graphiti MCP server.
+     * Creates a fresh Client/Transport if a previous attempt failed.
+     */
     async connect() {
         if (this.connected)
             return true;
+        // If a previous connect() tainted the Client's internal state,
+        // create fresh instances so the retry starts cleanly.
+        this.createClientAndTransport();
         try {
             await this.client.connect(this.transport);
             this.connected = true;
@@ -47,6 +64,9 @@ export class GraphitiClient {
             return false;
         }
     }
+    /**
+     * Close the underlying MCP client connection.
+     */
     async disconnect() {
         if (this.connected) {
             await this.client.close();
@@ -90,17 +110,20 @@ export class GraphitiClient {
     async reconnect() {
         this.connected = false;
         try {
-            await this.transport.close();
+            await this.client.close();
         }
         catch {
-            // ignore transport close errors
+            // ignore close errors on stale client
         }
-        this.transport = new StreamableHTTPClientTransport(new URL(this.endpoint));
+        this.createClientAndTransport();
         await this.client.connect(this.transport);
         this.connected = true;
         logger.info("Reconnected to Graphiti MCP server");
     }
-    // Public for testing
+    /**
+     * Parse MCP tool results into JSON when possible.
+     * Public for testing.
+     */
     parseToolResult(result) {
         const typedResult = result;
         const content = typedResult.content;
@@ -124,6 +147,9 @@ export class GraphitiClient {
             return text;
         }
     }
+    /**
+     * Add an episode to Graphiti memory.
+     */
     async addEpisode(params) {
         await this.callTool("add_memory", {
             name: params.name,
@@ -134,6 +160,9 @@ export class GraphitiClient {
         });
         logger.debug("Added episode:", params.name);
     }
+    /**
+     * Search Graphiti facts matching the provided query.
+     */
     async searchFacts(params) {
         try {
             const result = await this.callTool("search_memory_facts", {
@@ -155,6 +184,9 @@ export class GraphitiClient {
             return [];
         }
     }
+    /**
+     * Search Graphiti nodes matching the provided query.
+     */
     async searchNodes(params) {
         try {
             const result = await this.callTool("search_nodes", {
@@ -176,19 +208,9 @@ export class GraphitiClient {
             return [];
         }
     }
-    async getEpisodes(params) {
-        try {
-            const result = await this.callTool("get_episodes", {
-                group_ids: params.groupIds,
-                max_episodes: params.maxEpisodes || 10,
-            });
-            return result || [];
-        }
-        catch (err) {
-            logger.error("getEpisodes error:", err);
-            return [];
-        }
-    }
+    /**
+     * Check whether the Graphiti MCP server is reachable.
+     */
     async getStatus() {
         try {
             await this.callTool("get_status", {});