opencode-graphiti 0.0.0-development

package/esm/src/services/redis-snapshot.js

@@ -0,0 +1,184 @@
+import { getSessionEventPrimaryText, } from "../types/index.js";
+import { sessionSnapshotKey } from "./redis-events.js";
+import { escapeXml, normalizeMemoryText, renderXmlListSection, renderXmlSingleSection, sanitizeMemoryInput, uniqueNormalizedValues, } from "./render-utils.js";
+const SNAPSHOT_BUDGET = 3_000;
+const BLOCKER_PATTERN = /\b(blocker|blocked|blocking)\b/i;
+const selectRecent = (events, predicate, map, limit, excludedNormalized = new Set()) => uniqueNormalizedValues(events.flatMap((event) => {
+    if (!predicate(event))
+        return [];
+    const value = map(event);
+    if (!value)
+        return [];
+    return Array.isArray(value) ? value : [value];
+}).reverse(), limit, excludedNormalized);
+export const buildSessionSnapshotXml = (sessionId, events) => {
+    const decisions = selectRecent(events, (event) => ["decision", "preference"].includes(event.category), (event) => sanitizeMemoryInput(getSessionEventPrimaryText(event)), 5);
+    const occupiedNormalized = new Set(decisions.map((value) => normalizeMemoryText(value)).filter(Boolean));
+    const constraints = selectRecent(events, (event) => event.category === "rule.load", (event) => sanitizeMemoryInput(getSessionEventPrimaryText(event)), 5, occupiedNormalized);
+    for (const value of constraints) {
+        occupiedNormalized.add(normalizeMemoryText(value));
+    }
+    const latestUserRequest = getSessionEventPrimaryText(events.findLast((event) => event.role === "user") ?? {
+        id: "",
+        ts: 0,
+        category: "message",
+        priority: 4,
+        role: "user",
+        summary: "",
+    }) || undefined;
+    const sanitizedLatestUserRequest = latestUserRequest
+        ? sanitizeMemoryInput(latestUserRequest)
+        : undefined;
+    const normalizedLatestUserRequest = sanitizedLatestUserRequest
+        ? normalizeMemoryText(sanitizedLatestUserRequest)
+        : "";
+    if (normalizedLatestUserRequest) {
+        occupiedNormalized.add(normalizedLatestUserRequest);
+    }
+    const activeTask = events.findLast((event) => ["task.create", "task.update", "task.complete"].includes(event.category))?.summary;
+    const sanitizedActiveTask = sanitizeMemoryInput(activeTask ?? "");
+    const activeTaskValue = sanitizedActiveTask &&
+        normalizeMemoryText(sanitizedActiveTask) !== normalizedLatestUserRequest
+        ? sanitizedActiveTask
+        : undefined;
+    if (activeTaskValue) {
+        occupiedNormalized.add(normalizeMemoryText(activeTaskValue));
+    }
+    const activeFiles = selectRecent(events, (event) => event.category.startsWith("file."), (event) => event.refs ?? [], 6, occupiedNormalized);
+    for (const value of activeFiles) {
+        occupiedNormalized.add(normalizeMemoryText(value));
+    }
+    const recentEdits = selectRecent(events, (event) => event.category === "file.write" || event.category === "file.edit", (event) => sanitizeMemoryInput(getSessionEventPrimaryText(event)), 5, occupiedNormalized);
+    for (const value of recentEdits) {
+        occupiedNormalized.add(normalizeMemoryText(value));
+    }
+    const subagentsOpen = selectRecent(events, (event) => event.category === "subagent.start", (event) => sanitizeMemoryInput(getSessionEventPrimaryText(event)), 4, occupiedNormalized);
+    for (const value of subagentsOpen) {
+        occupiedNormalized.add(normalizeMemoryText(value));
+    }
+    const unresolvedErrors = events.filter((event) => event.category === "error" && event.metadata?.resolved !== true &&
+        event.role !== "assistant");
+    const errors = uniqueNormalizedValues(unresolvedErrors.map((event) => sanitizeMemoryInput(getSessionEventPrimaryText(event)))
+        .reverse(), 4, occupiedNormalized);
+    for (const value of errors) {
+        occupiedNormalized.add(normalizeMemoryText(value));
+    }
+    const blockers = uniqueNormalizedValues(unresolvedErrors.flatMap((event) => {
+        const blockerText = sanitizeMemoryInput(event.detail?.trim() ||
+            event.continuityText?.trim() ||
+            event.body?.trim() || "");
+        if (!blockerText || blockerText === event.summary)
+            return [];
+        if (event.metadata?.blocking === true ||
+            BLOCKER_PATTERN.test(blockerText) ||
+            BLOCKER_PATTERN.test(event.summary)) {
+            return [blockerText];
+        }
+        return [];
+    }).reverse(), 3, occupiedNormalized);
+    for (const value of blockers) {
+        occupiedNormalized.add(normalizeMemoryText(value));
+    }
+    const environment = selectRecent(events, (event) => event.category === "cwd.change" || event.category === "env.change", (event) => sanitizeMemoryInput(getSessionEventPrimaryText(event)), 4, occupiedNormalized);
+    for (const value of environment) {
+        occupiedNormalized.add(normalizeMemoryText(value));
+    }
+    const gitState = selectRecent(events, (event) => event.category === "git.activity", (event) => sanitizeMemoryInput(getSessionEventPrimaryText(event)), 4, occupiedNormalized);
+    for (const value of gitState) {
+        occupiedNormalized.add(normalizeMemoryText(value));
+    }
+    const subagentsDone = selectRecent(events, (event) => event.category === "subagent.finish", (event) => sanitizeMemoryInput(getSessionEventPrimaryText(event)), 4, occupiedNormalized);
+    for (const value of subagentsDone) {
+        occupiedNormalized.add(normalizeMemoryText(value));
+    }
+    const open = `<snapshot session="${escapeXml(sessionId)}" ts="${Date.now()}" version="2">`;
+    const close = `</snapshot>`;
+    let xml = open;
+    let remaining = SNAPSHOT_BUDGET - open.length - close.length;
+    const sectionBuilders = [
+        () => renderXmlListSection("decisions", "d", decisions, {
+            itemCharLimit: 240,
+            remaining,
+        }),
+        () => renderXmlListSection("constraints", "c", constraints, {
+            itemCharLimit: 240,
+            remaining,
+        }),
+        () => renderXmlSingleSection("active_task", "goal", activeTaskValue, {
+            valueCharLimit: 320,
+            remaining,
+        }),
+        () => renderXmlListSection("active_files", "f", activeFiles, {
+            itemCharLimit: 240,
+            remaining,
+        }),
+        () => renderXmlListSection("recent_edits", "e", recentEdits, {
+            itemCharLimit: 220,
+            remaining,
+        }),
+        () => renderXmlListSection("subagents_open", "s", subagentsOpen, {
+            itemCharLimit: 220,
+            remaining,
+        }),
+        () => renderXmlListSection("errors", "e", errors, {
+            itemCharLimit: 240,
+            remaining,
+        }),
+        () => renderXmlListSection("blockers", "b", blockers, {
+            itemCharLimit: 220,
+            remaining,
+        }),
+        () => renderXmlListSection("environment", "e", environment, {
+            itemCharLimit: 240,
+            remaining,
+        }),
+        () => renderXmlListSection("git_state", "g", gitState, {
+            itemCharLimit: 220,
+            remaining,
+        }),
+        () => renderXmlListSection("subagents_done", "s", subagentsDone, {
+            itemCharLimit: 220,
+            remaining,
+        }),
+    ];
+    for (const buildSection of sectionBuilders) {
+        const section = buildSection();
+        if (!section)
+            continue;
+        if (section.length > remaining)
+            break;
+        xml += section;
+        remaining -= section.length;
+    }
+    return `${xml}${close}`;
+};
+export class RedisSnapshotService {
+    constructor(redis, options) {
+        Object.defineProperty(this, "redis", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: redis
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: options
+        });
+    }
+    async getSnapshot(sessionId) {
+        return await this.redis.getString(sessionSnapshotKey(sessionId));
+    }
+    async saveSnapshot(sessionId, snapshot) {
+        await this.redis.setString(sessionSnapshotKey(sessionId), snapshot, this.options.ttlSeconds);
+    }
+    async touchSnapshot(sessionId) {
+        await this.redis.touch(sessionSnapshotKey(sessionId), this.options.ttlSeconds);
+    }
+    async rebuildAndSave(sessionId, events) {
+        const snapshot = buildSessionSnapshotXml(sessionId, events);
+        await this.saveSnapshot(sessionId, snapshot);
+        return snapshot;
+    }
+}

package/esm/src/services/render-utils.d.ts

@@ -0,0 +1,23 @@
+export declare const escapeXml: (value: string) => string;
+export declare const stripInjectedMemoryBlocks: (value: string) => string;
+export declare const stripToolTranscriptWrappers: (value: string) => string;
+export declare const sanitizeMemoryInput: (value: string) => string;
+export declare const sanitizeMemoryInputPreservingMemoryBlocks: (value: string) => string;
+export declare const normalizeMemoryText: (value: string) => string;
+export declare const uniqueNormalizedValues: (values: string[], limit: number, excludedNormalized?: Set<string>) => string[];
+export declare const looksLikeOperationalChatter: (value: string) => boolean;
+export declare const looksLikeToolTranscript: (value: string) => boolean;
+export declare const looksTranscriptHeavy: (value: string) => boolean;
+export declare const isHighValueMemoryText: (value: string) => boolean;
+export interface RenderXmlListSectionOptions {
+    itemCharLimit?: number;
+    remaining?: number;
+    includeEmpty?: boolean;
+}
+export declare const renderXmlListSection: (tag: string, itemTag: string, values: string[], options?: RenderXmlListSectionOptions) => string;
+export interface RenderXmlSingleSectionOptions {
+    valueCharLimit?: number;
+    remaining?: number;
+}
+export declare const renderXmlSingleSection: (tag: string, itemTag: string, value: string | undefined, options?: RenderXmlSingleSectionOptions) => string;
+//# sourceMappingURL=render-utils.d.ts.map

package/esm/src/services/render-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-utils.d.ts","sourceRoot":"","sources":["../../../src/src/services/render-utils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS,GAAI,OAAO,MAAM,KAAG,MAKZ,CAAC;AA4B/B,eAAO,MAAM,yBAAyB,GAAI,OAAO,MAAM,KAAG,MAGR,CAAC;AAEnD,eAAO,MAAM,2BAA2B,GAAI,OAAO,MAAM,KAAG,MAKjD,CAAC;AASZ,eAAO,MAAM,mBAAmB,GAAI,OAAO,MAAM,KAAG,MAGjD,CAAC;AAEJ,eAAO,MAAM,yCAAyC,GACpD,OAAO,MAAM,KACZ,MAAoE,CAAC;AAExE,eAAO,MAAM,mBAAmB,GAAI,OAAO,MAAM,KAAG,MAMzC,CAAC;AAEZ,eAAO,MAAM,sBAAsB,GACjC,QAAQ,MAAM,EAAE,EAChB,OAAO,MAAM,EACb,gCAAsC,KACrC,MAAM,EAiBR,CAAC;AAEF,eAAO,MAAM,2BAA2B,GAAI,OAAO,MAAM,KAAG,OACE,CAAC;AAE/D,eAAO,MAAM,uBAAuB,GAAI,OAAO,MAAM,KAAG,OAEnB,CAAC;AAEtC,eAAO,MAAM,oBAAoB,GAAI,OAAO,MAAM,KAAG,OAKpD,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,OAAO,MAAM,KAAG,OAcrD,CAAC;AAqBF,MAAM,WAAW,2BAA2B;IAC1C,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,eAAO,MAAM,oBAAoB,GAC/B,KAAK,MAAM,EACX,SAAS,MAAM,EACf,QAAQ,MAAM,EAAE,EAChB,UAAS,2BAAgC,KACxC,MA+BF,CAAC;AAEF,MAAM,WAAW,6BAA6B;IAC5C,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,eAAO,MAAM,sBAAsB,GACjC,KAAK,MAAM,EACX,SAAS,MAAM,EACf,OAAO,MAAM,GAAG,SAAS,EACzB,UAAS,6BAAkC,KAC1C,MAmBF,CAAC"}

package/esm/src/services/render-utils.js

@@ -0,0 +1,149 @@
+export const escapeXml = (value) => value.replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&apos;");
+const SESSION_MEMORY_BLOCK_PATTERN = /<session_memory\b[^>]*>[\s\S]*?<\/session_memory>/gi;
+const LEGACY_MEMORY_BLOCK_PATTERN = /<memory\b[^>]*>[\s\S]*?<\/memory>/gi;
+const PERSISTENT_MEMORY_BLOCK_PATTERN = /<persistent_memory\b[^>]*>[\s\S]*?<\/persistent_memory>/gi;
+const TOOL_WRAPPER_DOCUMENT_PATTERN = /^\s*(?:<(?:path|content|type)\b[^>]*>[\s\S]*?<\/(?:path|content|type)>\s*)+$/i;
+const TOOL_WRAPPER_BLOCK_PATTERN = /<(?:path|content|type)\b[^>]*>[\s\S]*?<\/(?:path|content|type)>/gi;
+const TOOL_WRAPPER_LINE_PATTERN = /^\s*<\/?(?:path|content|type)\b[^>]*>\s*$/gim;
+const TOOL_WRAPPER_PREFIX_PATTERN = /^\s*(?:<path>|<content>|<type>|<path\b[^>]*>|<content\b[^>]*>|<type\b[^>]*>|<\/path>|<\/content>|<\/type>|<path>.*<\/path>|<type>.*<\/type>|\d+:\s*<(?:path|content|type)\b[^>]*>)\s*$/gim;
+const TOOL_TRANSCRIPT_PATTERN = /\b(?:tool(?:_use)?s?|orchestration|delegat(?:e|ed|ion)|subagent|wrapper|transcript|read output|read wrapper|session_memory|persistent_memory)\b/i;
+const OPERATIONAL_CHATTER_PATTERN = /^(?:plan per target:|i(?:'m| am| will| can| should| need to)\b|now\b.*\b(?:checking|reading|inspecting|updating|running)|next\b.*\b(?:checking|reading|updating|running))/i;
+const LOW_VALUE_MEMORY_PATTERN = /\b(?:assistant|meta chatter|planning chatter|phrasing suggestion|tool routing|orchestration|delegate|subagent|wrapper)\b/i;
+const HIGH_VALUE_MEMORY_PATTERN = /\b(?:architecture|decision|constraint|prefer|preference|must|should|rule|policy|hot path|async|graphiti|redis|falkordb|session memory|persistent memory|milestone|file|src\/|plans\/|docs\/|fix|implement|update)\b/i;
+const TRANSCRIPT_HEAVY_PATTERN = /```|(?:^|\n)\d+:\s|(?:^|\n)\$\s|\b(?:stdout|stderr|exit code|tool output|read output|file contents|transcript)\b/i;
+const STRUCTURED_TRANSCRIPT_HEAVY_PATTERN = /```|(?:^|\n)\d+:\s|(?:^|\n)\$\s|\b(?:stdout|stderr|exit code|tool output|read output|file contents)\b/i;
+export const stripInjectedMemoryBlocks = (value) => value.replace(SESSION_MEMORY_BLOCK_PATTERN, " ")
+    .replace(LEGACY_MEMORY_BLOCK_PATTERN, " ")
+    .replace(PERSISTENT_MEMORY_BLOCK_PATTERN, " ");
+export const stripToolTranscriptWrappers = (value) => TOOL_WRAPPER_DOCUMENT_PATTERN.test(value)
+    ? value.replace(TOOL_WRAPPER_BLOCK_PATTERN, " ")
+        .replace(TOOL_WRAPPER_LINE_PATTERN, " ")
+        .replace(TOOL_WRAPPER_PREFIX_PATTERN, " ")
+    : value;
+const normalizeSanitizedText = (value) => value.replace(/\r\n/g, "\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .replace(/[\t ]+/g, " ")
+    .replace(/ ?\n ?/g, "\n")
+    .trim();
+export const sanitizeMemoryInput = (value) => normalizeSanitizedText(stripToolTranscriptWrappers(stripInjectedMemoryBlocks(value)));
+export const sanitizeMemoryInputPreservingMemoryBlocks = (value) => normalizeSanitizedText(stripToolTranscriptWrappers(value));
+export const normalizeMemoryText = (value) => sanitizeMemoryInput(value)
+    .toLowerCase()
+    .replace(/&(?:amp|lt|gt|quot|apos);/g, " ")
+    .replace(/[^a-z0-9./_-]+/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+export const uniqueNormalizedValues = (values, limit, excludedNormalized = new Set()) => {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        const cleaned = sanitizeMemoryInput(value);
+        const normalized = normalizeMemoryText(cleaned);
+        if (!cleaned || !normalized || excludedNormalized.has(normalized) ||
+            seen.has(normalized)) {
+            continue;
+        }
+        seen.add(normalized);
+        result.push(cleaned);
+        if (result.length >= limit)
+            break;
+    }
+    return result;
+};
+export const looksLikeOperationalChatter = (value) => OPERATIONAL_CHATTER_PATTERN.test(sanitizeMemoryInput(value));
+export const looksLikeToolTranscript = (value) => TOOL_WRAPPER_DOCUMENT_PATTERN.test(value) ||
+    TOOL_TRANSCRIPT_PATTERN.test(value);
+export const looksTranscriptHeavy = (value) => {
+    const sanitized = sanitizeMemoryInput(value);
+    if (!sanitized)
+        return false;
+    return sanitized.length > 600 || sanitized.split("\n").length > 12 ||
+        TRANSCRIPT_HEAVY_PATTERN.test(sanitized);
+};
+export const isHighValueMemoryText = (value) => {
+    const sanitized = sanitizeMemoryInput(value);
+    if (!sanitized)
+        return false;
+    const looksHighValue = HIGH_VALUE_MEMORY_PATTERN.test(sanitized);
+    if (!looksHighValue)
+        return false;
+    const hasStructuredTranscriptEvidence = TOOL_WRAPPER_DOCUMENT_PATTERN.test(value) || sanitized.length > 600 ||
+        sanitized.split("\n").length > 12 ||
+        STRUCTURED_TRANSCRIPT_HEAVY_PATTERN.test(sanitized);
+    if (looksLikeToolTranscript(sanitized) && hasStructuredTranscriptEvidence) {
+        return false;
+    }
+    if (LOW_VALUE_MEMORY_PATTERN.test(sanitized))
+        return false;
+    return true;
+};
+const fitEscapedText = (value, maxEscapedLength) => {
+    const source = value.trim();
+    if (!source || maxEscapedLength <= 0)
+        return "";
+    if (escapeXml(source).length <= maxEscapedLength)
+        return source;
+    let low = 0;
+    let high = source.length;
+    while (low < high) {
+        const mid = Math.ceil((low + high) / 2);
+        if (escapeXml(source.slice(0, mid)).length <= maxEscapedLength) {
+            low = mid;
+        }
+        else {
+            high = mid - 1;
+        }
+    }
+    return source.slice(0, low).trimEnd();
+};
+export const renderXmlListSection = (tag, itemTag, values, options = {}) => {
+    const { itemCharLimit, remaining, includeEmpty = false } = options;
+    const open = `<${tag}>`;
+    const close = `</${tag}>`;
+    if (remaining !== undefined && open.length + close.length > remaining) {
+        return "";
+    }
+    let body = "";
+    for (const value of values) {
+        const normalized = value.trim();
+        if (!normalized)
+            continue;
+        const limited = itemCharLimit
+            ? normalized.slice(0, itemCharLimit)
+            : normalized;
+        const itemOpen = `<${itemTag}>`;
+        const itemClose = `</${itemTag}>`;
+        const content = remaining === undefined ? limited : fitEscapedText(limited, remaining - open.length - close.length - body.length - itemOpen.length -
+            itemClose.length);
+        if (!content)
+            break;
+        body += `${itemOpen}${escapeXml(content)}</${itemTag}>`;
+    }
+    if (!body)
+        return includeEmpty ? `${open}${close}` : "";
+    return `${open}${body}${close}`;
+};
+export const renderXmlSingleSection = (tag, itemTag, value, options = {}) => {
+    if (!value)
+        return "";
+    const { valueCharLimit, remaining } = options;
+    const normalized = value.trim();
+    if (!normalized)
+        return "";
+    const limited = valueCharLimit
+        ? normalized.slice(0, valueCharLimit)
+        : normalized;
+    const open = `<${tag}><${itemTag}>`;
+    const close = `</${itemTag}></${tag}>`;
+    const content = remaining === undefined
+        ? limited
+        : fitEscapedText(limited, remaining - open.length - close.length);
+    if (!content)
+        return "";
+    const section = `${open}${escapeXml(content)}${close}`;
+    return remaining === undefined || section.length <= remaining ? section : "";
+};

package/esm/src/services/runtime-teardown.d.ts

@@ -0,0 +1,23 @@
+export type RuntimeTeardownTask = {
+    name: string;
+    run: () => void | Promise<void>;
+};
+export interface RuntimeTeardownRegistration {
+    run(): Promise<void>;
+    dispose(): void;
+}
+type ShutdownRegistrationAdapter = {
+    addEventListener?: (type: string, listener: (event?: Event) => void, options?: boolean | {
+        once?: boolean;
+        capture?: boolean;
+    }) => void;
+    removeEventListener?: (type: string, listener: (event?: Event) => void, options?: boolean | EventListenerOptions) => void;
+    Deno?: {
+        addSignalListener?: (signal: "SIGINT" | "SIGTERM", handler: () => void) => void;
+        removeSignalListener?: (signal: "SIGINT" | "SIGTERM", handler: () => void) => void;
+        exit?: (code?: number) => never;
+    };
+};
+export declare function registerRuntimeTeardown(tasks: RuntimeTeardownTask[], runtime?: ShutdownRegistrationAdapter): RuntimeTeardownRegistration;
+export {};
+//# sourceMappingURL=runtime-teardown.d.ts.map

package/esm/src/services/runtime-teardown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-teardown.d.ts","sourceRoot":"","sources":["../../../src/src/services/runtime-teardown.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC,CAAC;AAEF,MAAM,WAAW,2BAA2B;IAC1C,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACrB,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,KAAK,2BAA2B,GAAG;IACjC,gBAAgB,CAAC,EAAE,CACjB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,KAAK,IAAI,EACjC,OAAO,CAAC,EAAE,OAAO,GAAG;QAAE,IAAI,CAAC,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAE,KACtD,IAAI,CAAC;IACV,mBAAmB,CAAC,EAAE,CACpB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,KAAK,IAAI,EACjC,OAAO,CAAC,EAAE,OAAO,GAAG,oBAAoB,KACrC,IAAI,CAAC;IACV,IAAI,CAAC,EAAE;QACL,iBAAiB,CAAC,EAAE,CAClB,MAAM,EAAE,QAAQ,GAAG,SAAS,EAC5B,OAAO,EAAE,MAAM,IAAI,KAChB,IAAI,CAAC;QACV,oBAAoB,CAAC,EAAE,CACrB,MAAM,EAAE,QAAQ,GAAG,SAAS,EAC5B,OAAO,EAAE,MAAM,IAAI,KAChB,IAAI,CAAC;QACV,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,KAAK,KAAK,CAAC;KACjC,CAAC;CACH,CAAC;AAwBF,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,mBAAmB,EAAE,EAC5B,OAAO,GAAE,2BAAmD,GAC3D,2BAA2B,CAuH7B"}

package/esm/src/services/runtime-teardown.js

@@ -0,0 +1,119 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { logger } from "./logger.js";
+const SHUTDOWN_EVENTS = ["unload", "beforeunload"];
+const SHUTDOWN_SIGNALS = ["SIGINT", "SIGTERM"];
+const SHUTDOWN_EXIT_CODE = {
+    SIGINT: 130,
+    SIGTERM: 143,
+};
+const activeRegistrations = new WeakMap();
+const getShutdownNotice = (signal) => signal === "SIGINT"
+    ? "Graceful shutdown in progress; waiting for pending memory flush. Press Ctrl+C again to exit immediately and drop pending memories."
+    : "Graceful shutdown in progress; waiting for pending memory flush. Send the signal again to exit immediately and drop pending memories.";
+const getForcedShutdownNotice = (signal) => signal === "SIGINT"
+    ? "Forced shutdown requested; exiting immediately and dropping pending memories."
+    : "Forced shutdown requested; exiting immediately after repeated shutdown signal and dropping pending memories.";
+export function registerRuntimeTeardown(tasks, runtime = dntShim.dntGlobalThis) {
+    const runtimeKey = runtime;
+    let teardownPromise = null;
+    let eventListenersDisposed = false;
+    let signalListenersDisposed = false;
+    let registrationReleased = false;
+    let shutdownSignal = null;
+    let exitRequested = false;
+    const eventListeners = [];
+    const signalListeners = [];
+    const disposeEventListeners = () => {
+        if (eventListenersDisposed)
+            return;
+        eventListenersDisposed = true;
+        for (const { type, listener } of eventListeners) {
+            runtime.removeEventListener?.(type, listener, false);
+        }
+    };
+    const disposeSignalListeners = () => {
+        if (signalListenersDisposed)
+            return;
+        signalListenersDisposed = true;
+        for (const { signal, handler } of signalListeners) {
+            runtime.Deno?.removeSignalListener?.(signal, handler);
+        }
+    };
+    const releaseRegistration = () => {
+        if (registrationReleased)
+            return;
+        registrationReleased = true;
+        if (activeRegistrations.get(runtimeKey) === dispose) {
+            activeRegistrations.delete(runtimeKey);
+        }
+    };
+    const dispose = () => {
+        disposeEventListeners();
+        disposeSignalListeners();
+        releaseRegistration();
+    };
+    const requestExit = (signal) => {
+        if (exitRequested)
+            return;
+        exitRequested = true;
+        dispose();
+        runtime.Deno?.exit?.(SHUTDOWN_EXIT_CODE[signal]);
+    };
+    const run = (options) => {
+        if (teardownPromise)
+            return teardownPromise;
+        teardownPromise = (async () => {
+            disposeEventListeners();
+            if (!options?.keepSignalListeners) {
+                disposeSignalListeners();
+            }
+            releaseRegistration();
+            try {
+                for (const task of tasks) {
+                    try {
+                        await task.run();
+                    }
+                    catch (err) {
+                        logger.warn("Runtime teardown failed", {
+                            resource: task.name,
+                            err,
+                        });
+                    }
+                }
+            }
+            finally {
+                disposeSignalListeners();
+            }
+        })();
+        return teardownPromise;
+    };
+    activeRegistrations.get(runtimeKey)?.();
+    for (const eventType of SHUTDOWN_EVENTS) {
+        const listener = () => {
+            void run();
+        };
+        runtime.addEventListener?.(eventType, listener, { once: true });
+        eventListeners.push({ type: eventType, listener });
+    }
+    for (const signal of SHUTDOWN_SIGNALS) {
+        const handler = () => {
+            if (shutdownSignal) {
+                logger.warn(getForcedShutdownNotice(signal), {
+                    signal,
+                    initialSignal: shutdownSignal,
+                });
+                requestExit(signal);
+                return;
+            }
+            shutdownSignal = signal;
+            logger.warn(getShutdownNotice(signal), { signal });
+            void run({ keepSignalListeners: true }).finally(() => {
+                requestExit(signal);
+            });
+        };
+        runtime.Deno?.addSignalListener?.(signal, handler);
+        signalListeners.push({ signal, handler });
+    }
+    activeRegistrations.set(runtimeKey, dispose);
+    return { run, dispose };
+}

package/esm/src/services/sdk-normalize.d.ts

@@ -0,0 +1,55 @@
+import type { Part } from "@opencode-ai/sdk";
+import type { GraphitiEpisode } from "../types/index.js";
+/**
+ * Narrow type for a single SDK message entry as returned by
+ * `session.messages()`.
+ */
+export type SdkMessage = {
+    info: {
+        role?: string;
+        id?: string;
+    };
+    parts: Part[];
+};
+/**
+ * Normalize an SDK response that may be wrapped in `{ data: … }` or returned
+ * directly.  Returns the inner value cast to `T`, or `undefined` when the
+ * response is absent.
+ *
+ * This replaces the repeated `"data" in response ? (response as
+ * { data?: … }).data : response` pattern found in session.ts and
+ * context-limit.ts.
+ */
+export declare function unwrapSdkResponse<T>(response: unknown): T | undefined;
+/**
+ * Extract the messages array from a raw `session.messages()` response.
+ * Returns an empty array when the response is missing or malformed.
+ */
+export declare function extractSdkMessages(response: unknown): SdkMessage[];
+/**
+ * Extract the provider list from a raw `provider.list()` response.
+ * Returns an empty array when the response is missing or malformed.
+ */
+export type SdkProvider = {
+    id?: string;
+    models?: SdkModel[];
+};
+export type SdkModel = {
+    id?: string;
+    limit?: {
+        context?: number;
+    };
+};
+export declare function extractSdkProviders(response: unknown): SdkProvider[];
+/**
+ * Normalize a raw Graphiti episode object so that `sourceDescription` is
+ * always the canonical field regardless of whether the payload used
+ * camelCase (`sourceDescription`) or snake_case (`source_description`).
+ *
+ * Call this at the API boundary (e.g. inside `GraphitiClient.getEpisodes`)
+ * so all downstream consumers only need to read `episode.sourceDescription`.
+ */
+export declare function normalizeEpisode(raw: GraphitiEpisode & {
+    source_description?: string;
+}): GraphitiEpisode;
+//# sourceMappingURL=sdk-normalize.d.ts.map

package/esm/src/services/sdk-normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk-normalize.d.ts","sourceRoot":"","sources":["../../../src/src/services/sdk-normalize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAA4B,MAAM,kBAAkB,CAAC;AACvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,IAAI,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,EAAE,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACrC,KAAK,EAAE,IAAI,EAAE,CAAC;CACf,CAAC;AAEF;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,GAAG,CAAC,GAAG,SAAS,CAMrE;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,OAAO,GAChB,UAAU,EAAE,CAGd;AAED;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IACrB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC9B,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,GAAG,WAAW,EAAE,CAmBpE;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,eAAe,GAAG;IACrB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B,GACA,eAAe,CAMjB"}

package/esm/src/services/sdk-normalize.js

@@ -0,0 +1,61 @@
+/**
+ * Normalize an SDK response that may be wrapped in `{ data: … }` or returned
+ * directly.  Returns the inner value cast to `T`, or `undefined` when the
+ * response is absent.
+ *
+ * This replaces the repeated `"data" in response ? (response as
+ * { data?: … }).data : response` pattern found in session.ts and
+ * context-limit.ts.
+ */
+export function unwrapSdkResponse(response) {
+    if (response == null)
+        return undefined;
+    if (typeof response === "object" && "data" in response) {
+        return response.data;
+    }
+    return response;
+}
+/**
+ * Extract the messages array from a raw `session.messages()` response.
+ * Returns an empty array when the response is missing or malformed.
+ */
+export function extractSdkMessages(response) {
+    const payload = unwrapSdkResponse(response);
+    return Array.isArray(payload) ? payload : [];
+}
+export function extractSdkProviders(response) {
+    // provider.list() may return `{ providers: [...] }` directly (no data wrap).
+    if (response != null && typeof response === "object") {
+        const obj = response;
+        if (Array.isArray(obj["providers"])) {
+            return obj["providers"];
+        }
+        if ("data" in obj) {
+            const data = obj["data"];
+            if (data != null && typeof data === "object") {
+                const dataObj = data;
+                if (Array.isArray(dataObj["providers"])) {
+                    return dataObj["providers"];
+                }
+            }
+            if (Array.isArray(data))
+                return data;
+        }
+    }
+    return [];
+}
+/**
+ * Normalize a raw Graphiti episode object so that `sourceDescription` is
+ * always the canonical field regardless of whether the payload used
+ * camelCase (`sourceDescription`) or snake_case (`source_description`).
+ *
+ * Call this at the API boundary (e.g. inside `GraphitiClient.getEpisodes`)
+ * so all downstream consumers only need to read `episode.sourceDescription`.
+ */
+export function normalizeEpisode(raw) {
+    const { source_description, ...rest } = raw;
+    return {
+        ...rest,
+        sourceDescription: rest.sourceDescription ?? source_description,
+    };
+}