opencode-graphiti 0.0.0-development

package/esm/src/services/connection-manager.js

@@ -0,0 +1,621 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import manifest from "../../deno.js";
+import { logger } from "./logger.js";
+export class GraphitiOfflineError extends Error {
+    constructor(state, message) {
+        super(message ??
+            (state === "closing"
+                ? "Graphiti connection manager is closing"
+                : state === "stopped"
+                    ? "Graphiti connection manager is stopped"
+                    : "Graphiti connection manager is offline"));
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: state
+        });
+        Object.defineProperty(this, "kind", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "offline"
+        });
+        this.name = "GraphitiOfflineError";
+    }
+}
+export class GraphitiQueueTimeoutError extends Error {
+    constructor(message = "Graphiti request timed out while waiting for connection") {
+        super(message);
+        Object.defineProperty(this, "kind", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "queue-timeout"
+        });
+        this.name = "GraphitiQueueTimeoutError";
+    }
+}
+export class GraphitiRequestTimeoutError extends Error {
+    constructor(message = "Graphiti request timed out") {
+        super(message);
+        Object.defineProperty(this, "kind", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "request-timeout"
+        });
+        this.name = "GraphitiRequestTimeoutError";
+    }
+}
+export class GraphitiTransportError extends Error {
+    constructor(message = "Graphiti transport failure") {
+        super(message);
+        Object.defineProperty(this, "kind", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "transport-failure"
+        });
+        this.name = "GraphitiTransportError";
+    }
+}
+export class GraphitiSessionExpiredError extends Error {
+    constructor(message = "Graphiti session expired") {
+        super(message);
+        Object.defineProperty(this, "kind", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "session-expired"
+        });
+        this.name = "GraphitiSessionExpiredError";
+    }
+}
+export function isGraphitiOfflineError(err) {
+    return err instanceof GraphitiOfflineError;
+}
+export function isGraphitiTimeoutError(err) {
+    return err instanceof GraphitiQueueTimeoutError ||
+        err instanceof GraphitiRequestTimeoutError;
+}
+const validateEndpoint = (endpoint) => {
+    const normalized = endpoint.trim();
+    if (!normalized) {
+        throw new Error("Graphiti endpoint must not be empty");
+    }
+    new URL(normalized);
+    return normalized;
+};
+function createMcpConnection(endpoint) {
+    const client = new Client({
+        name: manifest.name,
+        version: manifest.version,
+    });
+    const transport = new StreamableHTTPClientTransport(new URL(endpoint));
+    return {
+        connect: () => client.connect(transport),
+        close: () => client.close(),
+        callTool: (request) => client.callTool(request),
+    };
+}
+function getErrorMessage(err) {
+    if (typeof err === "string")
+        return err;
+    if (!err || typeof err !== "object")
+        return "";
+    const { message, cause } = err;
+    if (typeof message === "string")
+        return message;
+    if (cause)
+        return getErrorMessage(cause);
+    return "";
+}
+function isRequestTimeout(err) {
+    if (!err || typeof err !== "object") {
+        return typeof err === "string" && /request timed out/i.test(err);
+    }
+    const { code } = err;
+    return code === -32001 || /request timed out/i.test(getErrorMessage(err));
+}
+function isSessionExpired(err) {
+    return !!(err &&
+        typeof err === "object" &&
+        "code" in err &&
+        err.code === 404);
+}
+function isTransportFailure(err) {
+    if (!err)
+        return false;
+    if (isRequestTimeout(err) || isSessionExpired(err))
+        return false;
+    const message = getErrorMessage(err);
+    if (/(socket hang up|fetch failed|network|connection reset|connection refused|econnrefused|terminated|broken pipe|stream closed|unexpected end|transport)/i
+        .test(message)) {
+        return true;
+    }
+    if (typeof err === "object") {
+        const { name } = err;
+        return name === "TypeError" && message.length > 0;
+    }
+    return false;
+}
+export class GraphitiConnectionManager {
+    constructor(options) {
+        Object.defineProperty(this, "endpoint", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "requestDeadlineMs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "queueCapacity", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "startupTimeoutMs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "reconnectInitialDelayMs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "reconnectMaxDelayMs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "reconnectMultiplier", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "reconnectJitter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "connectionFactory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "random", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "now", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "setTimerImpl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "clearTimerImpl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "offline"
+        });
+        Object.defineProperty(this, "connection", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "connectPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "reconnectTimer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "pendingRequests", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "readyWaiters", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "reconnectDelayMs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "started", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "flushingQueue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "stopPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        this.endpoint = validateEndpoint(options.endpoint);
+        this.requestDeadlineMs = options.requestDeadlineMs ?? 15_000;
+        this.queueCapacity = options.queueCapacity ?? 32;
+        this.startupTimeoutMs = options.startupTimeoutMs ?? this.requestDeadlineMs;
+        this.reconnectInitialDelayMs = options.reconnectInitialDelayMs ?? 1_000;
+        this.reconnectMaxDelayMs = options.reconnectMaxDelayMs ?? 60_000;
+        this.reconnectMultiplier = options.reconnectMultiplier ?? 2;
+        this.reconnectJitter = options.reconnectJitter ?? 0.25;
+        this.connectionFactory = options.connectionFactory ?? createMcpConnection;
+        this.random = options.random ?? Math.random;
+        this.now = options.now ?? Date.now;
+        this.setTimerImpl = options.setTimer ??
+            ((callback, delayMs) => setTimeout(callback, delayMs));
+        this.clearTimerImpl = options.clearTimer ??
+            ((timer) => clearTimeout(timer));
+        this.reconnectDelayMs = this.reconnectInitialDelayMs;
+    }
+    getState() {
+        return this.state;
+    }
+    start() {
+        if (this.state === "closing" || this.state === "stopped") {
+            throw new GraphitiOfflineError(this.state, this.state === "closing"
+                ? "Graphiti connection manager is closing"
+                : "Graphiti connection manager has been stopped and cannot be restarted");
+        }
+        if (this.started)
+            return;
+        this.started = true;
+        void this.reconnect();
+    }
+    async stop() {
+        if (this.state === "stopped")
+            return;
+        if (this.stopPromise) {
+            await this.stopPromise;
+            return;
+        }
+        this.stopPromise = (async () => {
+            this.started = false;
+            this.state = "closing";
+            this.cancelReconnectTimer();
+            this.rejectAllPending(new GraphitiOfflineError("stopped", "Graphiti connection manager stopped"));
+            this.resolveReadyWaiters(false);
+            const connection = this.connection;
+            this.connection = null;
+            if (connection) {
+                try {
+                    await connection.close();
+                }
+                catch {
+                    // Ignore close errors while shutting down.
+                }
+            }
+            this.state = "stopped";
+        })();
+        await this.stopPromise;
+    }
+    async ready(timeoutMs = this.startupTimeoutMs) {
+        if (this.state === "connected")
+            return true;
+        if (this.state === "closing" || this.state === "stopped")
+            return false;
+        return await new Promise((resolve) => {
+            let settled = false;
+            let timer = null;
+            const finish = (value) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timer !== null)
+                    this.clearTimerImpl(timer);
+                this.readyWaiters.delete(finish);
+                resolve(value);
+            };
+            this.readyWaiters.add(finish);
+            if (timeoutMs >= 0) {
+                timer = this.setTimerImpl(() => finish(false), timeoutMs);
+            }
+        });
+    }
+    async callTool(name, args, deadlineMs = this.requestDeadlineMs) {
+        const sanitizedArgs = Object.fromEntries(Object.entries(args).filter(([_, value]) => value !== null && value !== undefined));
+        if (this.state === "closing" || this.state === "stopped") {
+            throw new GraphitiOfflineError(this.state);
+        }
+        if (this.state === "offline") {
+            throw new GraphitiOfflineError("offline");
+        }
+        if (this.state === "connecting") {
+            return await this.enqueueRequest(name, sanitizedArgs, deadlineMs);
+        }
+        return await this.executeConnectedCallWithinDeadline(name, sanitizedArgs, this.now() + deadlineMs);
+    }
+    async reconnect() {
+        if (this.state === "closing" || this.state === "stopped")
+            return false;
+        if (this.connectPromise)
+            return await this.connectPromise;
+        this.cancelReconnectTimer();
+        this.state = "connecting";
+        const attempt = this.performReconnect();
+        this.connectPromise = attempt.finally(() => {
+            this.connectPromise = null;
+        });
+        return await this.connectPromise;
+    }
+    async performReconnect() {
+        const previousConnection = this.connection;
+        this.connection = null;
+        let nextConnection = null;
+        if (previousConnection) {
+            try {
+                await previousConnection.close();
+            }
+            catch {
+                // Ignore stale close failures during reconnect.
+            }
+        }
+        try {
+            nextConnection = this.connectionFactory(this.endpoint);
+            await nextConnection.connect();
+            if (this.state === "closing") {
+                try {
+                    await nextConnection.close();
+                }
+                catch {
+                    // Ignore close failures while shutting down.
+                }
+                return false;
+            }
+            this.connection = nextConnection;
+            this.state = "connected";
+            this.reconnectDelayMs = this.reconnectInitialDelayMs;
+            this.resolveReadyWaiters(true);
+            logger.info("Connected to Graphiti MCP server at", this.endpoint);
+            void this.flushPendingQueue();
+            return true;
+        }
+        catch (err) {
+            if (nextConnection) {
+                try {
+                    await nextConnection.close();
+                }
+                catch {
+                    // Ignore close failures for failed connects.
+                }
+            }
+            if (this.state !== "closing" && this.state !== "stopped") {
+                this.state = "offline";
+                this.scheduleReconnect();
+                logger.warn("Failed to connect to Graphiti MCP server", err);
+            }
+            return false;
+        }
+    }
+    async executeConnectedCall(name, args, deadlineMs) {
+        return await this.executeConnectedCallWithinDeadline(name, args, this.now() + deadlineMs);
+    }
+    async executeConnectedCallWithinDeadline(name, args, deadlineAt, attempt = 0) {
+        if (this.state !== "connected" || !this.connection) {
+            throw new GraphitiOfflineError("offline");
+        }
+        const deadlineMs = this.getRemainingDeadlineMs(deadlineAt);
+        if (deadlineMs <= 0) {
+            throw new GraphitiRequestTimeoutError();
+        }
+        try {
+            return await this.runWithRequestDeadline(this.connection.callTool({ name, arguments: args }), deadlineMs);
+        }
+        catch (err) {
+            if (isRequestTimeout(err)) {
+                throw new GraphitiRequestTimeoutError(getErrorMessage(err) || undefined);
+            }
+            if (isSessionExpired(err)) {
+                const typedError = new GraphitiSessionExpiredError(getErrorMessage(err) || undefined);
+                if (attempt >= 1) {
+                    void this.reconnect();
+                    throw typedError;
+                }
+                const connected = await this.reconnectWithinDeadline(deadlineAt);
+                if (!connected)
+                    throw typedError;
+                return await this.executeConnectedCallWithinDeadline(name, args, deadlineAt, attempt + 1);
+            }
+            if (isTransportFailure(err)) {
+                const typedError = new GraphitiTransportError(getErrorMessage(err) || undefined);
+                if (attempt >= 1) {
+                    void this.reconnect();
+                    throw typedError;
+                }
+                const connected = await this.reconnectWithinDeadline(deadlineAt);
+                if (!connected)
+                    throw typedError;
+                return await this.executeConnectedCallWithinDeadline(name, args, deadlineAt, attempt + 1);
+            }
+            throw err;
+        }
+    }
+    getRemainingDeadlineMs(deadlineAt) {
+        return deadlineAt - this.now();
+    }
+    async reconnectWithinDeadline(deadlineAt) {
+        const deadlineMs = this.getRemainingDeadlineMs(deadlineAt);
+        if (deadlineMs <= 0) {
+            throw new GraphitiRequestTimeoutError();
+        }
+        return await this.runWithRequestDeadline(this.reconnect(), deadlineMs);
+    }
+    runWithRequestDeadline(task, deadlineMs) {
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const timer = this.setTimerImpl(() => {
+                if (settled)
+                    return;
+                settled = true;
+                reject(new GraphitiRequestTimeoutError());
+            }, deadlineMs);
+            task.then((value) => {
+                if (settled)
+                    return;
+                settled = true;
+                this.clearTimerImpl(timer);
+                resolve(value);
+            }, (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                this.clearTimerImpl(timer);
+                reject(error);
+            });
+        });
+    }
+    enqueueRequest(name, args, deadlineMs) {
+        if (deadlineMs <= 0) {
+            return Promise.reject(new GraphitiQueueTimeoutError());
+        }
+        return new Promise((resolve, reject) => {
+            const deadlineAt = this.now() + deadlineMs;
+            const pending = {
+                name,
+                args,
+                deadlineAt,
+                resolve,
+                reject,
+                timer: null,
+            };
+            pending.timer = this.setTimerImpl(() => {
+                this.removePendingRequest(pending);
+                reject(new GraphitiQueueTimeoutError());
+            }, deadlineMs);
+            if (this.pendingRequests.length >= this.queueCapacity) {
+                const dropped = this.pendingRequests.shift();
+                if (dropped) {
+                    this.clearPendingTimer(dropped);
+                    dropped.reject(new GraphitiQueueTimeoutError("Graphiti request dropped because the connecting queue is full"));
+                }
+            }
+            this.pendingRequests.push(pending);
+        });
+    }
+    async flushPendingQueue() {
+        if (this.flushingQueue || this.state !== "connected")
+            return;
+        this.flushingQueue = true;
+        try {
+            while (this.state === "connected" && this.pendingRequests.length > 0) {
+                const next = this.pendingRequests.shift();
+                if (!next)
+                    continue;
+                this.clearPendingTimer(next);
+                if (this.getRemainingDeadlineMs(next.deadlineAt) <= 0) {
+                    next.reject(new GraphitiQueueTimeoutError());
+                    continue;
+                }
+                try {
+                    const result = await this.executeConnectedCallWithinDeadline(next.name, next.args, next.deadlineAt);
+                    next.resolve(result);
+                }
+                catch (err) {
+                    next.reject(err);
+                }
+            }
+        }
+        finally {
+            this.flushingQueue = false;
+        }
+    }
+    removePendingRequest(target) {
+        const index = this.pendingRequests.indexOf(target);
+        if (index >= 0) {
+            this.pendingRequests.splice(index, 1);
+        }
+        this.clearPendingTimer(target);
+    }
+    clearPendingTimer(request) {
+        if (request.timer !== null) {
+            this.clearTimerImpl(request.timer);
+            request.timer = null;
+        }
+    }
+    rejectAllPending(error) {
+        const pending = [...this.pendingRequests];
+        this.pendingRequests = [];
+        for (const request of pending) {
+            this.clearPendingTimer(request);
+            request.reject(error);
+        }
+    }
+    scheduleReconnect() {
+        if (!this.started || this.state === "closing" || this.state === "stopped" ||
+            this.reconnectTimer !== null) {
+            return;
+        }
+        const jitterFactor = 1 + ((this.random() * 2) - 1) * this.reconnectJitter;
+        const delayMs = Math.max(0, Math.round(this.reconnectDelayMs * jitterFactor));
+        this.reconnectTimer = this.setTimerImpl(() => {
+            this.reconnectTimer = null;
+            if (this.state === "closing" || this.state === "stopped")
+                return;
+            void this.reconnect();
+        }, delayMs);
+        this.reconnectDelayMs = Math.min(this.reconnectMaxDelayMs, Math.max(this.reconnectInitialDelayMs, Math.round(this.reconnectDelayMs * this.reconnectMultiplier)));
+    }
+    cancelReconnectTimer() {
+        if (this.reconnectTimer !== null) {
+            this.clearTimerImpl(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+    resolveReadyWaiters(value) {
+        const waiters = [...this.readyWaiters];
+        this.readyWaiters.clear();
+        for (const waiter of waiters) {
+            waiter(value);
+        }
+    }
+}

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

@@ -0,0 +1,7 @@
+/** Milliseconds in one day. */
+export declare const DAY_MS: number;
+/** Default token context limit when the provider does not report one. */
+export declare const DEFAULT_CONTEXT_LIMIT = 200000;
+/** Maximum project-scope facts fetched per search query. */
+export declare const PROJECT_MAX_FACTS = 50;
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/src/services/constants.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,eAAO,MAAM,MAAM,QAAsB,CAAC;AAE1C,yEAAyE;AACzE,eAAO,MAAM,qBAAqB,SAAU,CAAC;AAE7C,4DAA4D;AAC5D,eAAO,MAAM,iBAAiB,KAAK,CAAC"}

package/esm/src/services/constants.js

@@ -0,0 +1,6 @@
+/** Milliseconds in one day. */
+export const DAY_MS = 24 * 60 * 60 * 1000;
+/** Default token context limit when the provider does not report one. */
+export const DEFAULT_CONTEXT_LIMIT = 200_000;
+/** Maximum project-scope facts fetched per search query. */
+export const PROJECT_MAX_FACTS = 50;

package/esm/src/services/context-limit.d.ts

@@ -0,0 +1,3 @@
+import type { OpencodeClient } from "@opencode-ai/sdk";
+export declare function resolveContextLimit(providerID: string, modelID: string, client: OpencodeClient, directory: string | undefined, cache: Map<string, number>): Promise<number>;
+//# sourceMappingURL=context-limit.d.ts.map

package/esm/src/services/context-limit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-limit.d.ts","sourceRoot":"","sources":["../../../src/src/services/context-limit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAkBvD,wBAAsB,mBAAmB,CACvC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,cAAc,EACtB,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GACzB,OAAO,CAAC,MAAM,CAAC,CAoCjB"}

package/esm/src/services/context-limit.js

@@ -0,0 +1,44 @@
+import { DEFAULT_CONTEXT_LIMIT } from "./constants.js";
+import { logger } from "./logger.js";
+import { extractSdkProviders } from "./sdk-normalize.js";
+const UNKNOWN_CONTEXT_LIMIT = -1;
+const getContextLimitCacheKey = (providerID, modelID, directory) => {
+    const normalizedDirectory = directory?.trim();
+    return normalizedDirectory
+        ? `${normalizedDirectory}\u0000${providerID}/${modelID}`
+        : `${providerID}/${modelID}`;
+};
+export async function resolveContextLimit(providerID, modelID, client, directory, cache) {
+    const normalizedDirectory = directory?.trim();
+    const modelKey = getContextLimitCacheKey(providerID, modelID, normalizedDirectory);
+    const cached = cache.get(modelKey);
+    if (cached !== undefined) {
+        return cached > 0 ? cached : DEFAULT_CONTEXT_LIMIT;
+    }
+    try {
+        const response = await client.provider.list({
+            query: normalizedDirectory ? { directory: normalizedDirectory } : {},
+        });
+        const list = extractSdkProviders(response);
+        for (const provider of list) {
+            if (provider.id !== providerID)
+                continue;
+            const models = provider.models ?? [];
+            for (const model of models) {
+                if (model.id !== modelID)
+                    continue;
+                const contextLimit = model.limit?.context;
+                if (typeof contextLimit === "number" && contextLimit > 0) {
+                    cache.set(modelKey, contextLimit);
+                    return contextLimit;
+                }
+            }
+        }
+    }
+    catch (err) {
+        logger.warn("Failed to fetch provider context limit", err);
+        return DEFAULT_CONTEXT_LIMIT;
+    }
+    cache.set(modelKey, UNKNOWN_CONTEXT_LIMIT);
+    return DEFAULT_CONTEXT_LIMIT;
+}