opencode-graphiti 0.0.0-development

package/script/src/handlers/event.js

@@ -0,0 +1,290 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEventHandler = createEventHandler;
+const context_limit_js_1 = require("../services/context-limit.js");
+const event_extractor_js_1 = require("../services/event-extractor.js");
+const logger_js_1 = require("../services/logger.js");
+const utils_js_1 = require("../utils.js");
+const asRecord = (value) => value && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : undefined;
+const asString = (value) => typeof value === "string" && value.trim() ? value.trim() : undefined;
+const passthroughEventTypes = new Set([
+    "task.updated",
+    "rules.loaded",
+    "environment.updated",
+    "subagent.started",
+    "subagent.finished",
+    "tool.called",
+    "tool.completed",
+]);
+const getEventSessionId = (value, depth = 0) => {
+    if (depth > 4)
+        return undefined;
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const sessionId = getEventSessionId(item, depth + 1);
+            if (sessionId)
+                return sessionId;
+        }
+        return undefined;
+    }
+    const record = asRecord(value);
+    if (!record)
+        return undefined;
+    const directSessionId = asString(record.sessionID) ??
+        asString(record.sessionId);
+    if (directSessionId)
+        return directSessionId;
+    for (const nested of Object.values(record)) {
+        const sessionId = getEventSessionId(nested, depth + 1);
+        if (sessionId)
+            return sessionId;
+    }
+    return undefined;
+};
+const getCompactionSummary = (value) => {
+    const summary = asRecord(value)?.summary;
+    return typeof summary === "string" ? summary : "";
+};
+function createEventHandler(deps) {
+    const { sessionManager, redisEvents, redisCache, redisSnapshot, graphitiAsync, sdkClient, directory, } = deps;
+    const contextLimitCache = new Map();
+    const contextLimitLookupGeneration = new Map();
+    let nextContextLimitLookupGeneration = 0;
+    const clearContextLimitLookupGeneration = (sessionId, generation) => {
+        if (generation === undefined) {
+            contextLimitLookupGeneration.delete(sessionId);
+            return;
+        }
+        if (contextLimitLookupGeneration.get(sessionId) === generation) {
+            contextLimitLookupGeneration.delete(sessionId);
+        }
+    };
+    return async ({ event }) => {
+        try {
+            if (event.type === "session.created") {
+                const info = event.properties.info;
+                const sessionId = info.id;
+                const parentId = info.parentID ?? null;
+                sessionManager.setParentId(sessionId, parentId);
+                sessionManager.markSessionActive(sessionId);
+                const { state, resolved, canonicalSessionId } = await sessionManager
+                    .resolveSessionState(sessionId);
+                if (!resolved || !state?.isMain || !canonicalSessionId)
+                    return;
+                sessionManager.markResolvedSessionActive(sessionId, canonicalSessionId);
+                for (const structured of (0, event_extractor_js_1.extractStructuredEvents)({
+                    eventType: event.type,
+                    sessionId,
+                    properties: event.properties,
+                    role: "system",
+                })) {
+                    await redisEvents.recordEvent(canonicalSessionId, state.groupId, structured);
+                }
+                await Promise.all([
+                    redisEvents.touchSessionEvents(canonicalSessionId),
+                    redisSnapshot.touchSnapshot(canonicalSessionId),
+                    redisCache.touch(state.groupId),
+                ]);
+                if (canonicalSessionId === sessionId) {
+                    graphitiAsync.schedulePrimer(state.groupId);
+                }
+                return;
+            }
+            if (event.type === "session.idle") {
+                const sessionId = event.properties.sessionID;
+                const { state, resolved, canonicalSessionId } = await sessionManager
+                    .resolveSessionState(sessionId);
+                if (!resolved || !state?.isMain)
+                    return;
+                if (!canonicalSessionId)
+                    return;
+                const idleGeneration = sessionManager.captureIdleCleanupGeneration(canonicalSessionId);
+                if (idleGeneration === null)
+                    return;
+                const events = await redisEvents.getRecentSessionEvents(canonicalSessionId, 40, true);
+                await redisSnapshot.rebuildAndSave(canonicalSessionId, events);
+                state.hotTierReady = true;
+                graphitiAsync.scheduleDrain(state.groupId);
+                const refreshQuery = state.latestUserRequest ??
+                    state.latestRefreshQuery ??
+                    (await redisCache.getMeta(state.groupId))?.lastQuery;
+                if (refreshQuery) {
+                    state.latestRefreshQuery = refreshQuery;
+                    graphitiAsync.scheduleCacheRefresh(state.groupId, refreshQuery);
+                }
+                sessionManager.scheduleIdleSessionCleanup(canonicalSessionId, idleGeneration);
+                return;
+            }
+            if (event.type === "session.deleted") {
+                const sessionId = event.properties
+                    .sessionID;
+                const canonicalSessionId = await sessionManager
+                    .resolveCanonicalSessionId(sessionId);
+                clearContextLimitLookupGeneration(sessionId);
+                if (canonicalSessionId) {
+                    clearContextLimitLookupGeneration(canonicalSessionId);
+                }
+                if (canonicalSessionId && canonicalSessionId !== sessionId) {
+                    sessionManager.purgeAssistantBufferSource(sessionId);
+                }
+                sessionManager.deleteSession(sessionId);
+                return;
+            }
+            if (event.type === "session.compacted") {
+                const sessionId = event.properties.sessionID;
+                const { state, resolved, canonicalSessionId } = await sessionManager
+                    .resolveSessionState(sessionId);
+                if (!resolved || !state?.isMain)
+                    return;
+                if (!canonicalSessionId)
+                    return;
+                const structured = (0, event_extractor_js_1.extractStructuredEvents)({
+                    eventType: event.type,
+                    sessionId,
+                    properties: event.properties,
+                    messageText: getCompactionSummary(event.properties),
+                    role: "system",
+                });
+                for (const item of structured) {
+                    await redisEvents.recordEvent(canonicalSessionId, state.groupId, item);
+                }
+                const events = await redisEvents.getRecentSessionEvents(canonicalSessionId, 40, true);
+                await redisSnapshot.rebuildAndSave(canonicalSessionId, events);
+                graphitiAsync.scheduleDrain(state.groupId);
+                const refreshQuery = state.latestUserRequest ??
+                    state.latestRefreshQuery ??
+                    (await redisCache.getMeta(state.groupId))?.lastQuery;
+                if (refreshQuery) {
+                    state.latestRefreshQuery = refreshQuery;
+                    graphitiAsync.scheduleCacheRefresh(state.groupId, refreshQuery);
+                }
+                return;
+            }
+            if (event.type === "message.updated") {
+                const info = event.properties.info;
+                const sessionId = info.sessionID;
+                const { state, resolved, canonicalSessionId } = await sessionManager
+                    .resolveSessionState(sessionId);
+                if (!resolved || !state?.isMain)
+                    return;
+                if (!canonicalSessionId)
+                    return;
+                sessionManager.markResolvedSessionActive(sessionId, canonicalSessionId);
+                if (info.role !== "assistant") {
+                    sessionManager.deletePendingAssistant(canonicalSessionId, info.id);
+                    return;
+                }
+                const time = info.time;
+                if (!time?.completed)
+                    return;
+                if (sessionManager.isAssistantBuffered(canonicalSessionId, info.id)) {
+                    return;
+                }
+                const assistantText = sessionManager.finalizeAssistantMessage(state, canonicalSessionId, info.id, "message.updated");
+                if (assistantText) {
+                    for (const structured of (0, event_extractor_js_1.extractStructuredEvents)({
+                        eventType: event.type,
+                        sessionId,
+                        properties: event.properties,
+                        messageText: assistantText,
+                        role: "assistant",
+                    })) {
+                        await redisEvents.recordEvent(canonicalSessionId, state.groupId, structured);
+                    }
+                }
+                if (info.tokens && info.providerID && info.modelID) {
+                    const lookupSessionId = canonicalSessionId;
+                    const lookupGeneration = ++nextContextLimitLookupGeneration;
+                    contextLimitLookupGeneration.set(lookupSessionId, lookupGeneration);
+                    const cleanupSessionIds = new Set([lookupSessionId]);
+                    void (async () => {
+                        const limit = await (0, context_limit_js_1.resolveContextLimit)(info.providerID, info.modelID, sdkClient, directory, contextLimitCache);
+                        if (contextLimitLookupGeneration.get(lookupSessionId) !==
+                            lookupGeneration) {
+                            return;
+                        }
+                        const currentCanonicalSessionId = await sessionManager
+                            .resolveCanonicalSessionId(sessionId);
+                        if (!currentCanonicalSessionId)
+                            return;
+                        cleanupSessionIds.add(currentCanonicalSessionId);
+                        if (currentCanonicalSessionId !== lookupSessionId &&
+                            (contextLimitLookupGeneration.get(currentCanonicalSessionId) ??
+                                -1) >
+                                lookupGeneration) {
+                            return;
+                        }
+                        if (currentCanonicalSessionId !== lookupSessionId) {
+                            contextLimitLookupGeneration.set(currentCanonicalSessionId, lookupGeneration);
+                        }
+                        if (contextLimitLookupGeneration.get(currentCanonicalSessionId) !==
+                            lookupGeneration) {
+                            return;
+                        }
+                        const currentState = sessionManager.getState(currentCanonicalSessionId);
+                        if (!currentState?.isMain)
+                            return;
+                        currentState.contextLimit = limit;
+                    })().catch((err) => logger_js_1.logger.debug("Failed to resolve context limit", err)).finally(() => {
+                        for (const lookupSessionId of cleanupSessionIds) {
+                            clearContextLimitLookupGeneration(lookupSessionId, lookupGeneration);
+                        }
+                    });
+                }
+                return;
+            }
+            if (event.type === "message.part.updated") {
+                const part = event.properties.part;
+                if (!(0, utils_js_1.isTextPart)(part))
+                    return;
+                const canonicalSessionId = await sessionManager.resolveCanonicalSessionId(part.sessionID) ?? part.sessionID;
+                sessionManager.markResolvedSessionActive(part.sessionID, canonicalSessionId);
+                sessionManager.bufferAssistantPart(canonicalSessionId, part.messageID, part.text, part.sessionID);
+                if (!sessionManager.hasPendingAssistantCompletion(canonicalSessionId, part.messageID)) {
+                    return;
+                }
+                const { state, resolved } = await sessionManager.resolveSessionState(part.sessionID);
+                if (!resolved || !state?.isMain)
+                    return;
+                const assistantText = sessionManager.finalizeAssistantMessage(state, canonicalSessionId, part.messageID, "message.part.updated");
+                if (!assistantText)
+                    return;
+                for (const structured of (0, event_extractor_js_1.extractStructuredEvents)({
+                    eventType: "message.updated",
+                    sessionId: part.sessionID,
+                    properties: event.properties,
+                    messageText: assistantText,
+                    role: "assistant",
+                })) {
+                    await redisEvents.recordEvent(canonicalSessionId, state.groupId, structured);
+                }
+                return;
+            }
+            if (!passthroughEventTypes.has(event.type)) {
+                return;
+            }
+            const sessionId = getEventSessionId(event.properties);
+            if (!sessionId)
+                return;
+            sessionManager.markSessionActive(sessionId);
+            const { state, resolved, canonicalSessionId } = await sessionManager
+                .resolveSessionState(sessionId);
+            if (!resolved || !state?.isMain)
+                return;
+            if (!canonicalSessionId)
+                return;
+            for (const structured of (0, event_extractor_js_1.extractStructuredEvents)({
+                eventType: event.type,
+                sessionId,
+                properties: event.properties,
+            })) {
+                await redisEvents.recordEvent(canonicalSessionId, state.groupId, structured);
+            }
+        }
+        catch (err) {
+            logger_js_1.logger.error("Event handler error", { type: event.type, err });
+        }
+    };
+}

package/script/src/handlers/messages.d.ts

@@ -0,0 +1,9 @@
+import type { Hooks } from "@opencode-ai/plugin";
+import type { SessionManager } from "../session.js";
+type MessagesTransformHook = NonNullable<Hooks["experimental.chat.messages.transform"]>;
+export interface MessagesHandlerDeps {
+    sessionManager: SessionManager;
+}
+export declare function createMessagesHandler(deps: MessagesHandlerDeps): MessagesTransformHook;
+export {};
+//# sourceMappingURL=messages.d.ts.map

package/script/src/handlers/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../src/src/handlers/messages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAOjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD,KAAK,qBAAqB,GAAG,WAAW,CACtC,KAAK,CAAC,sCAAsC,CAAC,CAC9C,CAAC;AAIF,MAAM,WAAW,mBAAmB;IAClC,cAAc,EAAE,cAAc,CAAC;CAChC;AAkCD,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,mBAAmB,GACxB,qBAAqB,CAyFvB"}

package/script/src/handlers/messages.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMessagesHandler = createMessagesHandler;
+const logger_js_1 = require("../services/logger.js");
+const render_utils_js_1 = require("../services/render-utils.js");
+const utils_js_1 = require("../utils.js");
+const asRecord = (value) => value && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : undefined;
+const getTransformMessage = (input) => {
+    const message = asRecord(input)?.message;
+    return typeof message === "string" ? message : undefined;
+};
+const getLatestUserText = (output) => {
+    const lastUserEntry = output.messages
+        .findLast((message) => message.info.role === "user");
+    const textPart = lastUserEntry?.parts.find(utils_js_1.isTextPart);
+    return textPart
+        ? (0, render_utils_js_1.sanitizeMemoryInputPreservingMemoryBlocks)(textPart.text)
+        : undefined;
+};
+const scrubPromptMemoryText = (text) => {
+    const stripped = (0, render_utils_js_1.stripInjectedMemoryBlocks)(text);
+    if (stripped === text)
+        return text;
+    return stripped.replace(/\r\n/g, "\n")
+        .replace(/[\t ]+\n/g, "\n")
+        .replace(/\n[\t ]+/g, "\n")
+        .replace(/[\t ]{2,}/g, " ")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+};
+function createMessagesHandler(deps) {
+    const { sessionManager } = deps;
+    return async (input, output) => {
+        const lastUserEntry = output.messages
+            .findLast((message) => message.info.role === "user");
+        if (!lastUserEntry)
+            return;
+        const sourceSessionID = lastUserEntry.info.sessionID;
+        try {
+            const { state, resolved, canonicalSessionId, } = await sessionManager.resolveSessionState(sourceSessionID);
+            if (!resolved || !canonicalSessionId)
+                return;
+            if (!state?.isMain)
+                return;
+            sessionManager.markResolvedSessionActive(sourceSessionID, canonicalSessionId);
+            let rewroteExistingMemory = false;
+            for (const entry of output.messages) {
+                for (const part of entry.parts) {
+                    if ((0, utils_js_1.isTextPart)(part) &&
+                        !rewroteExistingMemory &&
+                        (part.text.includes("<session_memory") ||
+                            part.text.includes("<memory") ||
+                            part.text.includes("<persistent_memory"))) {
+                        rewroteExistingMemory = true;
+                    }
+                }
+            }
+            const recallQuery = (0, render_utils_js_1.sanitizeMemoryInput)((0, render_utils_js_1.stripInjectedMemoryBlocks)(getTransformMessage(input) ?? getLatestUserText(output) ?? "")) || undefined;
+            const prepared = state.pendingInjection ??
+                await sessionManager.prepareInjection(canonicalSessionId, recallQuery);
+            if (!prepared)
+                return;
+            const latestUserText = lastUserEntry.parts.find(utils_js_1.isTextPart)?.text;
+            for (const entry of output.messages) {
+                for (const part of entry.parts) {
+                    if ((0, utils_js_1.isTextPart)(part)) {
+                        part.text = scrubPromptMemoryText(part.text);
+                    }
+                }
+            }
+            const textPart = lastUserEntry.parts.find(utils_js_1.isTextPart);
+            if (!textPart || latestUserText === undefined)
+                return;
+            const effectiveUserText = (0, render_utils_js_1.sanitizeMemoryInputPreservingMemoryBlocks)(latestUserText);
+            if (!effectiveUserText) {
+                sessionManager.clearPendingInjection(state, prepared);
+                return;
+            }
+            textPart.text = `${prepared.envelope}\n\n${effectiveUserText}`;
+            logger_js_1.logger.info("Injected canonical session_memory block", {
+                sessionID: canonicalSessionId,
+                sourceSessionID,
+                rewroteExistingMemory,
+            });
+            sessionManager.clearPendingInjection(state, prepared);
+        }
+        catch (error) {
+            logger_js_1.logger.warn("Unable to prepare local session memory for messages transform", {
+                sessionID: sourceSessionID,
+                error,
+            });
+        }
+    };
+}

package/script/src/index.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const warnOnGraphitiStartupUnavailable: (connected: boolean, endpoint: string) => void;
+export declare const warnOnRedisStartupUnavailable: (connected: boolean, endpoint: string) => void;
+export declare const graphiti: Plugin;
+//# sourceMappingURL=index.d.ts.map

package/script/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAC;AAmD/D,eAAO,MAAM,gCAAgC,GAC3C,WAAW,OAAO,EAClB,UAAU,MAAM,KACf,IAMF,CAAC;AAEF,eAAO,MAAM,6BAA6B,GACxC,WAAW,OAAO,EAClB,UAAU,MAAM,KACf,IAMF,CAAC;AAyBF,eAAO,MAAM,QAAQ,EAAE,MA0ItB,CAAC"}

package/script/src/index.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphiti = exports.warnOnRedisStartupUnavailable = exports.warnOnGraphitiStartupUnavailable = void 0;
+const config_js_1 = require("./config.js");
+const chat_js_1 = require("./handlers/chat.js");
+const compacting_js_1 = require("./handlers/compacting.js");
+const event_js_1 = require("./handlers/event.js");
+const messages_js_1 = require("./handlers/messages.js");
+const session_js_1 = require("./session.js");
+const batch_drain_js_1 = require("./services/batch-drain.js");
+const connection_manager_js_1 = require("./services/connection-manager.js");
+const graphiti_async_js_1 = require("./services/graphiti-async.js");
+const graphiti_mcp_js_1 = require("./services/graphiti-mcp.js");
+const opencode_warning_js_1 = require("./services/opencode-warning.js");
+const redis_cache_js_1 = require("./services/redis-cache.js");
+const redis_client_js_1 = require("./services/redis-client.js");
+const redis_events_js_1 = require("./services/redis-events.js");
+const redis_snapshot_js_1 = require("./services/redis-snapshot.js");
+const runtime_teardown_js_1 = require("./services/runtime-teardown.js");
+const utils_js_1 = require("./utils.js");
+const warnOnGraphitiStartupUnavailable = (connected, endpoint) => {
+    if (connected)
+        return;
+    (0, opencode_warning_js_1.notifyGraphitiAvailabilityIssue)(`Graphiti MCP unavailable at ${endpoint}; continuing without persistent memory.`, { endpoint });
+};
+exports.warnOnGraphitiStartupUnavailable = warnOnGraphitiStartupUnavailable;
+const warnOnRedisStartupUnavailable = (connected, endpoint) => {
+    if (connected)
+        return;
+    (0, opencode_warning_js_1.notifyGraphitiAvailabilityIssue)(`Redis unavailable at ${endpoint}; continuing without persistent memory.`, { endpoint });
+};
+exports.warnOnRedisStartupUnavailable = warnOnRedisStartupUnavailable;
+const defaultGraphitiDependencies = {
+    loadConfig: config_js_1.loadConfig,
+    setOpenCodeClient: opencode_warning_js_1.setOpenCodeClient,
+    warnOnGraphitiStartupUnavailable: exports.warnOnGraphitiStartupUnavailable,
+    warnOnRedisStartupUnavailable: exports.warnOnRedisStartupUnavailable,
+    GraphitiConnectionManager: connection_manager_js_1.GraphitiConnectionManager,
+    RedisClient: redis_client_js_1.RedisClient,
+    registerRuntimeTeardown: runtime_teardown_js_1.registerRuntimeTeardown,
+    GraphitiMcpClient: graphiti_mcp_js_1.GraphitiMcpClient,
+    RedisEventsService: redis_events_js_1.RedisEventsService,
+    RedisSnapshotService: redis_snapshot_js_1.RedisSnapshotService,
+    RedisCacheService: redis_cache_js_1.RedisCacheService,
+    BatchDrainService: batch_drain_js_1.BatchDrainService,
+    GraphitiAsyncService: graphiti_async_js_1.GraphitiAsyncService,
+    SessionManager: session_js_1.SessionManager,
+    createEventHandler: event_js_1.createEventHandler,
+    createChatHandler: chat_js_1.createChatHandler,
+    createCompactingHandler: compacting_js_1.createCompactingHandler,
+    createMessagesHandler: messages_js_1.createMessagesHandler,
+    makeGroupId: utils_js_1.makeGroupId,
+    makeUserGroupId: utils_js_1.makeUserGroupId,
+};
+const graphiti = (input, dependencies = defaultGraphitiDependencies) => {
+    const config = dependencies.loadConfig(input.directory);
+    dependencies.setOpenCodeClient(input.client);
+    let startupUnavailableReported = false;
+    let startupChecksRemaining = 2;
+    const reportStartupUnavailable = (service) => {
+        if (startupUnavailableReported)
+            return;
+        startupUnavailableReported = true;
+        if (service === "graphiti") {
+            dependencies.warnOnGraphitiStartupUnavailable(false, config.graphiti.endpoint);
+            return;
+        }
+        dependencies.warnOnRedisStartupUnavailable(false, config.redis.endpoint);
+    };
+    const reportStartupCheckSucceeded = () => {
+        startupChecksRemaining -= 1;
+        if (startupUnavailableReported || startupChecksRemaining !== 0)
+            return;
+        dependencies.warnOnGraphitiStartupUnavailable(true, config.graphiti.endpoint);
+    };
+    const connectionManager = new dependencies.GraphitiConnectionManager({
+        endpoint: config.graphiti.endpoint,
+    });
+    connectionManager.start();
+    void connectionManager.ready()
+        .then((connected) => {
+        if (!connected) {
+            reportStartupUnavailable("graphiti");
+            return;
+        }
+        reportStartupCheckSucceeded();
+    })
+        .catch(() => {
+        reportStartupUnavailable("graphiti");
+    });
+    const redisClient = new dependencies.RedisClient({
+        endpoint: config.redis.endpoint,
+    });
+    void redisClient.connect()
+        .then(() => {
+        reportStartupCheckSucceeded();
+    })
+        .catch(() => {
+        reportStartupUnavailable("redis");
+    });
+    dependencies.registerRuntimeTeardown([
+        {
+            name: "redis",
+            run: () => redisClient.close(),
+        },
+        {
+            name: "graphiti",
+            run: () => connectionManager.stop(),
+        },
+    ]);
+    const graphitiClient = new dependencies.GraphitiMcpClient(connectionManager);
+    const redisEvents = new dependencies.RedisEventsService(redisClient, {
+        sessionTtlSeconds: config.redis.sessionTtlSeconds,
+    });
+    const redisSnapshot = new dependencies.RedisSnapshotService(redisClient, {
+        ttlSeconds: config.redis.sessionTtlSeconds * 2,
+    });
+    const redisCache = new dependencies.RedisCacheService(redisClient, {
+        ttlSeconds: config.redis.cacheTtlSeconds,
+        driftThreshold: config.graphiti.driftThreshold,
+    });
+    const batchDrain = new dependencies.BatchDrainService(redisClient, redisEvents, {
+        batchSize: config.redis.batchSize,
+        batchMaxBytes: config.redis.batchMaxBytes,
+        drainRetryMax: config.redis.drainRetryMax,
+    });
+    const graphitiAsync = new dependencies.GraphitiAsyncService(graphitiClient, redisCache, batchDrain);
+    const defaultGroupId = dependencies.makeGroupId(config.graphiti.groupIdPrefix, input.directory);
+    const defaultUserGroupId = dependencies.makeUserGroupId(config.graphiti.groupIdPrefix, input.directory);
+    const sessionManager = new dependencies.SessionManager(defaultGroupId, defaultUserGroupId, input.client, redisEvents, redisSnapshot, redisCache, {
+        idleRetentionMs: config.redis.sessionTtlSeconds * 1000,
+    });
+    return Promise.resolve({
+        event: dependencies.createEventHandler({
+            sessionManager,
+            redisEvents,
+            redisCache,
+            redisSnapshot,
+            graphitiAsync,
+            defaultGroupId,
+            defaultUserGroupId,
+            sdkClient: input.client,
+            directory: input.directory,
+        }),
+        "chat.message": dependencies.createChatHandler({
+            sessionManager,
+            redisEvents,
+            graphitiAsync,
+            drainTriggerSize: config.redis.batchSize,
+        }),
+        "experimental.session.compacting": dependencies.createCompactingHandler({
+            sessionManager,
+        }),
+        "experimental.chat.messages.transform": dependencies.createMessagesHandler({
+            sessionManager,
+        }),
+    });
+};
+exports.graphiti = graphiti;

package/script/src/services/batch-drain.d.ts

@@ -0,0 +1,23 @@
+import type { GraphitiMcpClient } from "./graphiti-mcp.js";
+import type { RedisClient } from "./redis-client.js";
+import type { RedisEventsService } from "./redis-events.js";
+export interface BatchDrainServiceOptions {
+    batchSize: number;
+    batchMaxBytes: number;
+    drainRetryMax: number;
+    claimHeartbeatIntervalMs?: number;
+}
+export declare class BatchDrainService {
+    private readonly redis;
+    private readonly events;
+    private readonly options;
+    constructor(redis: RedisClient, events: RedisEventsService, options: BatchDrainServiceOptions);
+    private getClaimHeartbeatIntervalMs;
+    private getRetryState;
+    private setRetryState;
+    drainGroup(groupId: string, graphiti: GraphitiMcpClient): Promise<{
+        status: "empty" | "backoff" | "success" | "dead-letter" | "retry";
+        drained: number;
+    }>;
+}
+//# sourceMappingURL=batch-drain.d.ts.map

package/script/src/services/batch-drain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-drain.d.ts","sourceRoot":"","sources":["../../../src/src/services/batch-drain.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAE3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAS5D,MAAM,WAAW,wBAAwB;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,wBAAwB,CAAC,EAAE,MAAM,CAAC;CACnC;AA+BD,qBAAa,iBAAiB;IAE1B,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAFP,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,kBAAkB,EAC1B,OAAO,EAAE,wBAAwB;IAGpD,OAAO,CAAC,2BAA2B;YAiCrB,aAAa;YAab,aAAa;IAYrB,UAAU,CACd,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,iBAAiB,GAC1B,OAAO,CACR;QACE,MAAM,EAAE,OAAO,GAAG,SAAS,GAAG,SAAS,GAAG,aAAa,GAAG,OAAO,CAAC;QAClE,OAAO,EAAE,MAAM,CAAC;KACjB,CACF;CAiJF"}