opencode-graphiti 0.0.0-development

package/esm/src/handlers/chat.js

@@ -0,0 +1,60 @@
+import { extractStructuredEvents } from "../services/event-extractor.js";
+import { logger } from "../services/logger.js";
+import { sanitizeMemoryInput } from "../services/render-utils.js";
+import { extractTextFromParts } from "../utils.js";
+export function createChatHandler(deps) {
+    const { sessionManager, redisEvents, graphitiAsync, drainTriggerSize } = deps;
+    return async ({ sessionID }, output) => {
+        try {
+            sessionManager.markSessionActive(sessionID);
+            const { state, resolved, canonicalSessionId } = await sessionManager
+                .resolveSessionState(sessionID);
+            if (!resolved || !state?.isMain)
+                return;
+            if (!canonicalSessionId)
+                return;
+            sessionManager.markResolvedSessionActive(sessionID, canonicalSessionId);
+            const messageText = extractTextFromParts(output.parts);
+            if (!messageText)
+                return;
+            const sanitizedMessageText = sanitizeMemoryInput(messageText);
+            if (!sanitizedMessageText)
+                return;
+            state.messageCount += 1;
+            state.latestUserRequest = sanitizedMessageText;
+            state.latestRefreshQuery = sanitizedMessageText;
+            let queueLength = 0;
+            for (const event of extractStructuredEvents({
+                eventType: "chat.message",
+                sessionId: sessionID,
+                messageText: sanitizedMessageText,
+                messageCount: state.messageCount,
+                role: "user",
+            })) {
+                queueLength = await redisEvents.recordEvent(canonicalSessionId, state.groupId, event);
+            }
+            const prepared = await sessionManager.prepareInjection(canonicalSessionId, sanitizedMessageText);
+            if (prepared) {
+                state.injectedMemories = true;
+            }
+            logger.info("Prepared local session memory for chat transform", {
+                sessionID: canonicalSessionId,
+                sourceSessionID: sessionID,
+                hotTierReady: state.hotTierReady,
+                refreshClassification: prepared?.refreshDecision.classification,
+            });
+            if (prepared && prepared.refreshDecision.shouldRefresh) {
+                graphitiAsync.scheduleCacheRefresh(state.groupId, sanitizedMessageText);
+            }
+            if (queueLength >= drainTriggerSize) {
+                graphitiAsync.scheduleDrain(state.groupId);
+            }
+        }
+        catch (error) {
+            logger.warn("Unable to prepare local session memory for chat transform", {
+                sessionID,
+                error,
+            });
+        }
+    };
+}

package/esm/src/handlers/compacting.d.ts

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

package/esm/src/handlers/compacting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compacting.d.ts","sourceRoot":"","sources":["../../../src/src/handlers/compacting.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAEjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD,KAAK,cAAc,GAAG,WAAW,CAAC,KAAK,CAAC,iCAAiC,CAAC,CAAC,CAAC;AAI5E,MAAM,WAAW,qBAAqB;IACpC,cAAc,EAAE,cAAc,CAAC;CAChC;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,qBAAqB,GAC1B,cAAc,CAmChB"}

package/esm/src/handlers/compacting.js

@@ -0,0 +1,30 @@
+import { logger } from "../services/logger.js";
+export function createCompactingHandler(deps) {
+    const { sessionManager } = deps;
+    return async ({ sessionID }, output) => {
+        try {
+            const { state, resolved, canonicalSessionId, } = await sessionManager.resolveSessionState(sessionID);
+            if (!resolved || !canonicalSessionId)
+                return;
+            if (!state?.isMain)
+                return;
+            sessionManager.markResolvedSessionActive(sessionID, canonicalSessionId);
+            const prepared = await sessionManager.prepareInjection(canonicalSessionId);
+            if (!prepared?.envelope)
+                return;
+            output.context.push(prepared.envelope);
+            sessionManager.clearPendingInjection(state, prepared);
+            logger.info("Injected local session_memory into compaction context", {
+                sessionID: canonicalSessionId,
+                sourceSessionID: sessionID,
+                hotTierReady: state.hotTierReady,
+            });
+        }
+        catch (error) {
+            logger.warn("Unable to prepare local session memory for compaction", {
+                sessionID,
+                error,
+            });
+        }
+    };
+}

package/esm/src/handlers/event.d.ts

@@ -0,0 +1,22 @@
+import type { Hooks } from "@opencode-ai/plugin";
+import type { OpencodeClient } from "@opencode-ai/sdk";
+import type { GraphitiAsyncService } from "../services/graphiti-async.js";
+import type { RedisCacheService } from "../services/redis-cache.js";
+import type { RedisEventsService } from "../services/redis-events.js";
+import type { RedisSnapshotService } from "../services/redis-snapshot.js";
+import type { SessionManager } from "../session.js";
+type EventHook = NonNullable<Hooks["event"]>;
+export interface EventHandlerDeps {
+    sessionManager: SessionManager;
+    redisEvents: RedisEventsService;
+    redisCache: RedisCacheService;
+    redisSnapshot: RedisSnapshotService;
+    graphitiAsync: GraphitiAsyncService;
+    defaultGroupId: string;
+    defaultUserGroupId: string;
+    sdkClient: OpencodeClient;
+    directory: string;
+}
+export declare function createEventHandler(deps: EventHandlerDeps): EventHook;
+export {};
+//# sourceMappingURL=event.d.ts.map

package/esm/src/handlers/event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.d.ts","sourceRoot":"","sources":["../../../src/src/handlers/event.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGvD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAC1E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAE1E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD,KAAK,SAAS,GAAG,WAAW,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;AAG7C,MAAM,WAAW,gBAAgB;IAC/B,cAAc,EAAE,cAAc,CAAC;IAC/B,WAAW,EAAE,kBAAkB,CAAC;IAChC,UAAU,EAAE,iBAAiB,CAAC;IAC9B,aAAa,EAAE,oBAAoB,CAAC;IACpC,aAAa,EAAE,oBAAoB,CAAC;IACpC,cAAc,EAAE,MAAM,CAAC;IACvB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,SAAS,EAAE,cAAc,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;CACnB;AAmDD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,gBAAgB,GAAG,SAAS,CAoXpE"}

package/esm/src/handlers/event.js

@@ -0,0 +1,287 @@
+import { resolveContextLimit } from "../services/context-limit.js";
+import { extractStructuredEvents } from "../services/event-extractor.js";
+import { logger } from "../services/logger.js";
+import { isTextPart } from "../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 : "";
+};
+export 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 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 = 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 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 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.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 (!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 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 extractStructuredEvents({
+                eventType: event.type,
+                sessionId,
+                properties: event.properties,
+            })) {
+                await redisEvents.recordEvent(canonicalSessionId, state.groupId, structured);
+            }
+        }
+        catch (err) {
+            logger.error("Event handler error", { type: event.type, err });
+        }
+    };
+}

package/esm/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/esm/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/esm/src/handlers/messages.js

@@ -0,0 +1,93 @@
+import { logger } from "../services/logger.js";
+import { sanitizeMemoryInput, sanitizeMemoryInputPreservingMemoryBlocks, stripInjectedMemoryBlocks, } from "../services/render-utils.js";
+import { isTextPart } from "../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(isTextPart);
+    return textPart
+        ? sanitizeMemoryInputPreservingMemoryBlocks(textPart.text)
+        : undefined;
+};
+const scrubPromptMemoryText = (text) => {
+    const stripped = 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();
+};
+export 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 (isTextPart(part) &&
+                        !rewroteExistingMemory &&
+                        (part.text.includes("<session_memory") ||
+                            part.text.includes("<memory") ||
+                            part.text.includes("<persistent_memory"))) {
+                        rewroteExistingMemory = true;
+                    }
+                }
+            }
+            const recallQuery = sanitizeMemoryInput(stripInjectedMemoryBlocks(getTransformMessage(input) ?? getLatestUserText(output) ?? "")) || undefined;
+            const prepared = state.pendingInjection ??
+                await sessionManager.prepareInjection(canonicalSessionId, recallQuery);
+            if (!prepared)
+                return;
+            const latestUserText = lastUserEntry.parts.find(isTextPart)?.text;
+            for (const entry of output.messages) {
+                for (const part of entry.parts) {
+                    if (isTextPart(part)) {
+                        part.text = scrubPromptMemoryText(part.text);
+                    }
+                }
+            }
+            const textPart = lastUserEntry.parts.find(isTextPart);
+            if (!textPart || latestUserText === undefined)
+                return;
+            const effectiveUserText = sanitizeMemoryInputPreservingMemoryBlocks(latestUserText);
+            if (!effectiveUserText) {
+                sessionManager.clearPendingInjection(state, prepared);
+                return;
+            }
+            textPart.text = `${prepared.envelope}\n\n${effectiveUserText}`;
+            logger.info("Injected canonical session_memory block", {
+                sessionID: canonicalSessionId,
+                sourceSessionID,
+                rewroteExistingMemory,
+            });
+            sessionManager.clearPendingInjection(state, prepared);
+        }
+        catch (error) {
+            logger.warn("Unable to prepare local session memory for messages transform", {
+                sessionID: sourceSessionID,
+                error,
+            });
+        }
+    };
+}

package/esm/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/esm/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"}