@dbx-tools/appkit-memory 0.0.0-stage → 0.9.131

package/lib/src/graphiti/_backend.js

@@ -0,0 +1,214 @@
+/**
+ * Lazy Graphiti implementation of the backend-neutral memory contract.
+ *
+ * @module
+ */
+import { createHash, randomBytes } from "node:crypto";
+import { createServer } from "node:net";
+import { ConfigurationError } from "@databricks/appkit";
+import { openApiTools } from "@dbx-tools/appkit/openapi-tool";
+import { profile as authProfile } from "@dbx-tools/auth";
+import { configUtils } from "@dbx-tools/core";
+import { z } from "zod";
+import { graphitiOptionOverrides, graphitiOptionsFromEnvironment, resolveGraphitiOptions, } from "./options.js";
+import { createGraphitiChildProcess, graphitiHealthCheck, graphitiHttpUrl, graphitiRequestHeaders, } from "./runtime.js";
+const GraphitiFactSchema = z
+    .object({
+    name: z.string().optional().describe("Graphiti fact name."),
+    fact: z.string().describe("Retrieved graph fact."),
+})
+    .loose()
+    .describe("Graphiti fact search result.");
+const GraphitiFactSearchSchema = z
+    .object({
+    facts: z.array(GraphitiFactSchema).optional().describe("Matching graph facts."),
+    error: z.string().optional().describe("Graphiti operation error."),
+})
+    .loose()
+    .describe("Graphiti fact search response.");
+const GraphitiWriteSchema = z
+    .object({
+    message: z.string().optional().describe("Graphiti write confirmation."),
+    error: z.string().optional().describe("Graphiti operation error."),
+})
+    .loose()
+    .describe("Graphiti write response.");
+class GraphitiBackend {
+    options;
+    child;
+    writeTool;
+    recallTool;
+    constructor(options, child, writeTool, recallTool) {
+        this.options = options;
+        this.child = child;
+        this.writeTool = writeTool;
+        this.recallTool = recallTool;
+    }
+    get running() {
+        return ((this.child.exitCode === null || this.child.exitCode === undefined) &&
+            (this.child.signalCode === null || this.child.signalCode === undefined));
+    }
+    async remember(actorId, input, signal) {
+        await this.write(actorId, {
+            name: input.path,
+            episode_body: input.content,
+            source: "text",
+            source_description: input.description ? `${input.path}: ${input.description}` : input.path,
+        }, signal);
+        return {
+            backend: "graphiti",
+            memory: {
+                path: input.path,
+                content: input.content,
+                ...(input.description ? { description: input.description } : {}),
+            },
+        };
+    }
+    async recall(actorId, input, signal) {
+        const response = GraphitiFactSearchSchema.parse(await this.request(this.recallTool, {
+            query: input.query,
+            max_facts: input.limit,
+            group_ids: [userScope(actorId)],
+        }, signal));
+        if (response.error)
+            throw new Error(response.error);
+        return {
+            backend: "graphiti",
+            memories: (response.facts ?? []).map((fact) => ({
+                content: fact.fact,
+                ...(fact.name ? { description: fact.name } : {}),
+            })),
+        };
+    }
+    async saveTurn(turn, signal) {
+        await this.write(turn.actorId, {
+            name: `Mastra turn ${turn.agentId}/${turn.threadId}`,
+            episode_body: `User: ${turn.user}\n\nAssistant: ${turn.assistant}`,
+            source: "message",
+            source_description: `Completed ${turn.agentId} conversation turn`,
+        }, signal);
+    }
+    shutdown() {
+        return this.child.shutdown();
+    }
+    async write(actorId, args, signal) {
+        const response = GraphitiWriteSchema.parse(await this.request(this.writeTool, { ...args, group_id: userScope(actorId) }, signal));
+        if (response.error)
+            throw new Error(response.error);
+    }
+    async request(tool, args, signal) {
+        if (!this.running)
+            throw new Error("Graphiti sidecar is not running");
+        const response = await fetch(tool.url, {
+            method: tool.method,
+            headers: {
+                ...graphitiRequestHeaders(this.options),
+                "content-type": "application/json",
+            },
+            body: JSON.stringify(args),
+            signal,
+        });
+        if (!response.ok) {
+            throw new Error(`Graphiti operation ${tool.id} failed with HTTP ${response.status}: ${await response.text()}`);
+        }
+        return response.json();
+    }
+}
+/** Start a fully ready Graphiti backend for the first fallback operation. */
+export async function startGraphitiBackend(options, signal) {
+    const configured = resolveGraphitiConfig(options);
+    if (configured.listen.scheme !== "tcp") {
+        throw new Error("AppKit memory requires a TCP Graphiti listener");
+    }
+    const [graphitiPort] = await distinctPorts(configUtils.port(undefined, "DATABRICKS_APP_PORT", 8000, configUtils.ENV_ONLY), configured.listen.port);
+    const resolved = resolveGraphitiOptions({
+        ...configured,
+        bearer: randomBytes(32).toString("base64url"),
+        listen: { ...configured.listen, port: graphitiPort },
+    });
+    let tools;
+    const { child } = await createGraphitiChildProcess({
+        ...resolved,
+        ...(signal ? { signal } : {}),
+        healthCheck: async ({ signal }) => {
+            try {
+                if (!(await graphitiHealthCheck(resolved, signal)))
+                    return false;
+                const loaded = await openApiTools(graphitiHttpUrl(resolved, "/openapi.json"), {
+                    signal,
+                    headers: graphitiRequestHeaders(resolved),
+                });
+                tools = [
+                    requiredOperation(loaded, "add_memory_sync"),
+                    requiredOperation(loaded, "search_memory_facts"),
+                ];
+                return true;
+            }
+            catch (error) {
+                if (signal.aborted)
+                    throw error;
+                return false;
+            }
+        },
+    });
+    if (!tools) {
+        await child.shutdown();
+        throw new Error("Graphiti OpenAPI tools were not captured during readiness");
+    }
+    return new GraphitiBackend(resolved, child, tools[0], tools[1]);
+}
+function resolveGraphitiConfig(options) {
+    const environment = graphitiOptionsFromEnvironment(process.env);
+    if (environment.profile && !authProfile.resolveProfile({ profile: environment.profile })) {
+        environment.profile = undefined;
+    }
+    const overrides = graphitiOptionOverrides(options);
+    return resolveGraphitiOptions({
+        ...environment,
+        ...overrides,
+        listen: overrides.listen ??
+            environment.listen ?? {
+            scheme: "tcp",
+            host: "127.0.0.1",
+            port: 0,
+        },
+    });
+}
+function requiredOperation(tools, name) {
+    const tool = tools.find(({ id }) => id === name);
+    if (!tool)
+        throw new Error(`Graphiti OpenAPI is missing operation: ${name}`);
+    return tool;
+}
+function userScope(userId) {
+    return `user_${createHash("sha256").update(userId).digest("base64url")}`;
+}
+async function availablePort() {
+    return new Promise((resolve, reject) => {
+        const server = createServer();
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => {
+            const address = server.address();
+            if (!address || typeof address === "string") {
+                server.close();
+                reject(new Error("Could not allocate a Graphiti loopback port"));
+                return;
+            }
+            server.close((error) => (error ? reject(error) : resolve(address.port)));
+        });
+    });
+}
+async function distinctPorts(appPort, graphitiPort) {
+    const ports = [appPort];
+    for (const configuredPort of [graphitiPort]) {
+        if (configuredPort && ports.includes(configuredPort)) {
+            throw new ConfigurationError("Graphiti sidecar ports must differ from DATABRICKS_APP_PORT");
+        }
+        let port = configuredPort || (await availablePort());
+        while (ports.includes(port))
+            port = await availablePort();
+        ports.push(port);
+    }
+    return ports.slice(1);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_backend.js","sourceRoot":"","sources":["../../../src/graphiti/_backend.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Lazy Graphiti implementation of the backend-neutral memory contract.\n *\n * @module\n */\n\nimport { createHash, randomBytes } from \"node:crypto\";\nimport { createServer } from \"node:net\";\nimport { ConfigurationError } from \"@databricks/appkit\";\nimport { openApiTools, type OpenApiTool } from \"@dbx-tools/appkit/openapi-tool\";\nimport { profile as authProfile } from \"@dbx-tools/auth\";\nimport { configUtils } from \"@dbx-tools/core\";\nimport type { ChildProcessResult } from \"@dbx-tools/core/exec\";\nimport { z } from \"zod\";\n\nimport {\n  type GraphitiMemoryBackend,\n  type MemoryTurn,\n  type RecallMemoryInput,\n  type RecallMemoryResult,\n  type RememberMemoryInput,\n  type RememberMemoryResult,\n} from \"../_contracts.ts\";\nimport {\n  graphitiOptionOverrides,\n  graphitiOptionsFromEnvironment,\n  resolveGraphitiOptions,\n  type GraphitiOptions,\n  type ResolvedGraphitiOptions,\n} from \"./options.ts\";\nimport {\n  createGraphitiChildProcess,\n  graphitiHealthCheck,\n  graphitiHttpUrl,\n  graphitiRequestHeaders,\n} from \"./runtime.ts\";\n\nconst GraphitiFactSchema = z\n  .object({\n    name: z.string().optional().describe(\"Graphiti fact name.\"),\n    fact: z.string().describe(\"Retrieved graph fact.\"),\n  })\n  .loose()\n  .describe(\"Graphiti fact search result.\");\n\nconst GraphitiFactSearchSchema = z\n  .object({\n    facts: z.array(GraphitiFactSchema).optional().describe(\"Matching graph facts.\"),\n    error: z.string().optional().describe(\"Graphiti operation error.\"),\n  })\n  .loose()\n  .describe(\"Graphiti fact search response.\");\n\nconst GraphitiWriteSchema = z\n  .object({\n    message: z.string().optional().describe(\"Graphiti write confirmation.\"),\n    error: z.string().optional().describe(\"Graphiti operation error.\"),\n  })\n  .loose()\n  .describe(\"Graphiti write response.\");\n\nclass GraphitiBackend implements GraphitiMemoryBackend {\n  constructor(\n    private readonly options: ResolvedGraphitiOptions,\n    private readonly child: ChildProcessResult,\n    private readonly writeTool: OpenApiTool,\n    private readonly recallTool: OpenApiTool,\n  ) {}\n\n  get running(): boolean {\n    return (\n      (this.child.exitCode === null || this.child.exitCode === undefined) &&\n      (this.child.signalCode === null || this.child.signalCode === undefined)\n    );\n  }\n\n  async remember(\n    actorId: string,\n    input: RememberMemoryInput,\n    signal?: AbortSignal,\n  ): Promise<RememberMemoryResult> {\n    await this.write(\n      actorId,\n      {\n        name: input.path,\n        episode_body: input.content,\n        source: \"text\",\n        source_description: input.description ? `${input.path}: ${input.description}` : input.path,\n      },\n      signal,\n    );\n    return {\n      backend: \"graphiti\",\n      memory: {\n        path: input.path,\n        content: input.content,\n        ...(input.description ? { description: input.description } : {}),\n      },\n    };\n  }\n\n  async recall(\n    actorId: string,\n    input: RecallMemoryInput,\n    signal?: AbortSignal,\n  ): Promise<RecallMemoryResult> {\n    const response = GraphitiFactSearchSchema.parse(\n      await this.request(\n        this.recallTool,\n        {\n          query: input.query,\n          max_facts: input.limit,\n          group_ids: [userScope(actorId)],\n        },\n        signal,\n      ),\n    );\n    if (response.error) throw new Error(response.error);\n    return {\n      backend: \"graphiti\",\n      memories: (response.facts ?? []).map((fact) => ({\n        content: fact.fact,\n        ...(fact.name ? { description: fact.name } : {}),\n      })),\n    };\n  }\n\n  async saveTurn(turn: MemoryTurn, signal?: AbortSignal): Promise<void> {\n    await this.write(\n      turn.actorId,\n      {\n        name: `Mastra turn ${turn.agentId}/${turn.threadId}`,\n        episode_body: `User: ${turn.user}\\n\\nAssistant: ${turn.assistant}`,\n        source: \"message\",\n        source_description: `Completed ${turn.agentId} conversation turn`,\n      },\n      signal,\n    );\n  }\n\n  shutdown(): Promise<void> {\n    return this.child.shutdown();\n  }\n\n  private async write(\n    actorId: string,\n    args: Record<string, unknown>,\n    signal?: AbortSignal,\n  ): Promise<void> {\n    const response = GraphitiWriteSchema.parse(\n      await this.request(this.writeTool, { ...args, group_id: userScope(actorId) }, signal),\n    );\n    if (response.error) throw new Error(response.error);\n  }\n\n  private async request(\n    tool: OpenApiTool,\n    args: Record<string, unknown>,\n    signal?: AbortSignal,\n  ): Promise<unknown> {\n    if (!this.running) throw new Error(\"Graphiti sidecar is not running\");\n    const response = await fetch(tool.url, {\n      method: tool.method,\n      headers: {\n        ...graphitiRequestHeaders(this.options),\n        \"content-type\": \"application/json\",\n      },\n      body: JSON.stringify(args),\n      signal,\n    });\n    if (!response.ok) {\n      throw new Error(\n        `Graphiti operation ${tool.id} failed with HTTP ${response.status}: ${await response.text()}`,\n      );\n    }\n    return response.json();\n  }\n}\n\n/** Start a fully ready Graphiti backend for the first fallback operation. */\nexport async function startGraphitiBackend(\n  options: GraphitiOptions,\n  signal?: AbortSignal,\n): Promise<GraphitiMemoryBackend> {\n  const configured = resolveGraphitiConfig(options);\n  if (configured.listen.scheme !== \"tcp\") {\n    throw new Error(\"AppKit memory requires a TCP Graphiti listener\");\n  }\n  const [graphitiPort] = await distinctPorts(\n    configUtils.port(undefined, \"DATABRICKS_APP_PORT\", 8000, configUtils.ENV_ONLY),\n    configured.listen.port,\n  );\n  const resolved = resolveGraphitiOptions({\n    ...configured,\n    bearer: randomBytes(32).toString(\"base64url\"),\n    listen: { ...configured.listen, port: graphitiPort },\n  });\n  let tools: OpenApiTool[] | undefined;\n  const { child } = await createGraphitiChildProcess({\n    ...resolved,\n    ...(signal ? { signal } : {}),\n    healthCheck: async ({ signal }) => {\n      try {\n        if (!(await graphitiHealthCheck(resolved, signal))) return false;\n        const loaded = await openApiTools(graphitiHttpUrl(resolved, \"/openapi.json\"), {\n          signal,\n          headers: graphitiRequestHeaders(resolved),\n        });\n        tools = [\n          requiredOperation(loaded, \"add_memory_sync\"),\n          requiredOperation(loaded, \"search_memory_facts\"),\n        ];\n        return true;\n      } catch (error) {\n        if (signal.aborted) throw error;\n        return false;\n      }\n    },\n  });\n  if (!tools) {\n    await child.shutdown();\n    throw new Error(\"Graphiti OpenAPI tools were not captured during readiness\");\n  }\n  return new GraphitiBackend(resolved, child, tools[0]!, tools[1]!);\n}\n\nfunction resolveGraphitiConfig(options: GraphitiOptions): ResolvedGraphitiOptions {\n  const environment = graphitiOptionsFromEnvironment(process.env);\n  if (environment.profile && !authProfile.resolveProfile({ profile: environment.profile })) {\n    environment.profile = undefined;\n  }\n  const overrides = graphitiOptionOverrides(options);\n  return resolveGraphitiOptions({\n    ...environment,\n    ...overrides,\n    listen: overrides.listen ??\n      environment.listen ?? {\n        scheme: \"tcp\",\n        host: \"127.0.0.1\",\n        port: 0,\n      },\n  });\n}\n\nfunction requiredOperation(tools: readonly OpenApiTool[], name: string): OpenApiTool {\n  const tool = tools.find(({ id }) => id === name);\n  if (!tool) throw new Error(`Graphiti OpenAPI is missing operation: ${name}`);\n  return tool;\n}\n\nfunction userScope(userId: string): string {\n  return `user_${createHash(\"sha256\").update(userId).digest(\"base64url\")}`;\n}\n\nasync function availablePort(): Promise<number> {\n  return new Promise((resolve, reject) => {\n    const server = createServer();\n    server.once(\"error\", reject);\n    server.listen(0, \"127.0.0.1\", () => {\n      const address = server.address();\n      if (!address || typeof address === \"string\") {\n        server.close();\n        reject(new Error(\"Could not allocate a Graphiti loopback port\"));\n        return;\n      }\n      server.close((error) => (error ? reject(error) : resolve(address.port)));\n    });\n  });\n}\n\nasync function distinctPorts(appPort: number, graphitiPort: number): Promise<[number]> {\n  const ports = [appPort];\n  for (const configuredPort of [graphitiPort]) {\n    if (configuredPort && ports.includes(configuredPort)) {\n      throw new ConfigurationError(\"Graphiti sidecar ports must differ from DATABRICKS_APP_PORT\");\n    }\n    let port = configuredPort || (await availablePort());\n    while (ports.includes(port)) port = await availablePort();\n    ports.push(port);\n  }\n  return ports.slice(1) as [number];\n}\n"]}

package/lib/src/graphiti/index.d.ts

@@ -0,0 +1,3 @@
+export * as options from "./options.ts";
+export * as runtime from "./runtime.ts";
+export type { GraphitiHealthCheckContext, GraphitiHealthCheck, GraphitiChildProcess, GraphitiRuntimeOptions, GraphitiPythonCommand } from "./runtime.ts";

package/lib/src/graphiti/index.js

@@ -0,0 +1,6 @@
+// GENERATED by projen watch - DO NOT EDIT.
+// Regenerated from the exporting modules in ./src.
+// Hand edits are overwritten on the next watch; this file is read-only.
+export * as options from "./options.js";
+export * as runtime from "./runtime.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZ3JhcGhpdGkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsMkNBQTJDO0FBQzNDLG1EQUFtRDtBQUNuRCx3RUFBd0U7QUFFeEUsT0FBTyxLQUFLLE9BQU8sTUFBTSxjQUFjLENBQUM7QUFDeEMsT0FBTyxLQUFLLE9BQU8sTUFBTSxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBHRU5FUkFURUQgYnkgcHJvamVuIHdhdGNoIC0gRE8gTk9UIEVESVQuXG4vLyBSZWdlbmVyYXRlZCBmcm9tIHRoZSBleHBvcnRpbmcgbW9kdWxlcyBpbiAuL3NyYy5cbi8vIEhhbmQgZWRpdHMgYXJlIG92ZXJ3cml0dGVuIG9uIHRoZSBuZXh0IHdhdGNoOyB0aGlzIGZpbGUgaXMgcmVhZC1vbmx5LlxuXG5leHBvcnQgKiBhcyBvcHRpb25zIGZyb20gXCIuL29wdGlvbnMudHNcIjtcbmV4cG9ydCAqIGFzIHJ1bnRpbWUgZnJvbSBcIi4vcnVudGltZS50c1wiO1xuZXhwb3J0IHR5cGUgeyBHcmFwaGl0aUhlYWx0aENoZWNrQ29udGV4dCwgR3JhcGhpdGlIZWFsdGhDaGVjaywgR3JhcGhpdGlDaGlsZFByb2Nlc3MsIEdyYXBoaXRpUnVudGltZU9wdGlvbnMsIEdyYXBoaXRpUHl0aG9uQ29tbWFuZCB9IGZyb20gXCIuL3J1bnRpbWUudHNcIjtcbiJdfQ==

package/lib/src/graphiti/options.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Node export of the shared Graphiti option contract.
+ *
+ * @module
+ */
+export { GRAPHITI_DEFAULTS, GraphitiCliOptionsSchema, GraphitiOptionsSchema, ResolvedGraphitiOptionsSchema, graphitiOptionOverrides, graphitiOptionsEnvironment, graphitiOptionsFromEnvironment, resolveGraphitiOptions, } from "@dbx-tools/shared-graphiti";
+export type { GraphitiOptions, ResolvedGraphitiOptions } from "@dbx-tools/shared-graphiti";

package/lib/src/graphiti/options.js

@@ -0,0 +1,7 @@
+/**
+ * Node export of the shared Graphiti option contract.
+ *
+ * @module
+ */
+export { GRAPHITI_DEFAULTS, GraphitiCliOptionsSchema, GraphitiOptionsSchema, ResolvedGraphitiOptionsSchema, graphitiOptionOverrides, graphitiOptionsEnvironment, graphitiOptionsFromEnvironment, resolveGraphitiOptions, } from "@dbx-tools/shared-graphiti";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9ncmFwaGl0aS9vcHRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFFSCxPQUFPLEVBQ0wsaUJBQWlCLEVBQ2pCLHdCQUF3QixFQUN4QixxQkFBcUIsRUFDckIsNkJBQTZCLEVBQzdCLHVCQUF1QixFQUN2QiwwQkFBMEIsRUFDMUIsOEJBQThCLEVBQzlCLHNCQUFzQixHQUN2QixNQUFNLDRCQUE0QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBOb2RlIGV4cG9ydCBvZiB0aGUgc2hhcmVkIEdyYXBoaXRpIG9wdGlvbiBjb250cmFjdC5cbiAqXG4gKiBAbW9kdWxlXG4gKi9cblxuZXhwb3J0IHtcbiAgR1JBUEhJVElfREVGQVVMVFMsXG4gIEdyYXBoaXRpQ2xpT3B0aW9uc1NjaGVtYSxcbiAgR3JhcGhpdGlPcHRpb25zU2NoZW1hLFxuICBSZXNvbHZlZEdyYXBoaXRpT3B0aW9uc1NjaGVtYSxcbiAgZ3JhcGhpdGlPcHRpb25PdmVycmlkZXMsXG4gIGdyYXBoaXRpT3B0aW9uc0Vudmlyb25tZW50LFxuICBncmFwaGl0aU9wdGlvbnNGcm9tRW52aXJvbm1lbnQsXG4gIHJlc29sdmVHcmFwaGl0aU9wdGlvbnMsXG59IGZyb20gXCJAZGJ4LXRvb2xzL3NoYXJlZC1ncmFwaGl0aVwiO1xuZXhwb3J0IHR5cGUgeyBHcmFwaGl0aU9wdGlvbnMsIFJlc29sdmVkR3JhcGhpdGlPcHRpb25zIH0gZnJvbSBcIkBkYngtdG9vbHMvc2hhcmVkLWdyYXBoaXRpXCI7XG4iXX0=

package/lib/src/graphiti/runtime.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Node Graphiti runtime and process supervision.
+ *
+ * @module
+ */
+import type { ChildProcessResult } from "@dbx-tools/core/exec";
+import { type GraphitiOptions, type ResolvedGraphitiOptions } from "./options.ts";
+/** Context passed to one Graphiti sidecar readiness probe. */
+export interface GraphitiHealthCheckContext {
+    readonly process: ChildProcessResult;
+    readonly signal: AbortSignal;
+    readonly attempt: number;
+}
+/** HTTP probe used to decide that the Graphiti sidecar has started listening. */
+export type GraphitiHealthCheck = (context: GraphitiHealthCheckContext) => boolean | PromiseLike<boolean>;
+/** Async creation result that preserves the awaitable child handle. */
+export interface GraphitiChildProcess {
+    child: ChildProcessResult;
+}
+/** Shared Graphiti options plus the Node-only sidecar readiness probe. */
+export type GraphitiRuntimeOptions = GraphitiOptions & {
+    /** Readiness probe for {@link createGraphitiChildProcess}. Defaults to `/healthcheck`. */
+    healthCheck?: GraphitiHealthCheck;
+    /** Cancels sidecar startup without changing the serialized Graphiti configuration. */
+    signal?: AbortSignal;
+};
+/** Milliseconds left in a startup budget after `startedAt`. */
+export declare function remainingTimeoutMs(startedAt: number, timeoutMs: number, now?: number): number;
+/** Return whether the Graphiti `/healthcheck` endpoint responds successfully. */
+export declare function graphitiHealthCheck(options: Pick<ResolvedGraphitiOptions, "listen" | "bearer">, signal: AbortSignal): Promise<boolean>;
+/** Poll `/healthcheck` until it succeeds or `timeoutMs` elapses. */
+export declare function waitForGraphitiHealth(options: Pick<ResolvedGraphitiOptions, "listen" | "bearer">, timeoutMs: number, signal?: AbortSignal): Promise<void>;
+/** Build authorization headers for one optionally secured Graphiti runtime. */
+export declare function graphitiRequestHeaders(options: Pick<ResolvedGraphitiOptions, "bearer">): Readonly<Record<string, string>>;
+/** Executable and arguments used to launch Graphiti. */
+export interface GraphitiPythonCommand {
+    command: string;
+    args: string[];
+}
+/** Resolve configured or app-installed Python, otherwise a uv-provisioned runtime. */
+export declare function resolveGraphitiPythonCommand(options?: {
+    dev?: boolean;
+}, ...args: string[]): Promise<GraphitiPythonCommand>;
+/** Build one HTTP URL for a resolved Graphiti listener. */
+export declare function graphitiHttpUrl(options: Pick<ResolvedGraphitiOptions, "listen">, path: string): string;
+/** Build one readiness-gated Graphiti sidecar from the shared typed options. */
+export declare function createGraphitiChildProcess(options?: GraphitiRuntimeOptions): Promise<GraphitiChildProcess>;
+/** Run the supervised stack until the child exits. */
+export declare function runGraphiti(options?: GraphitiRuntimeOptions): Promise<void>;

package/lib/src/graphiti/runtime.js

@@ -0,0 +1,170 @@
+/**
+ * Node Graphiti runtime and process supervision.
+ *
+ * @module
+ */
+import { delimiter, dirname } from "node:path";
+import { exec } from "@dbx-tools/core";
+import { asyncUtils, environmentUtils, functionUtils, options as sharedOptions, } from "@dbx-tools/shared-core";
+import { coerce, rcompare } from "semver";
+import { graphitiOptionsEnvironment, resolveGraphitiOptions, } from "./options.js";
+const HEALTH_CHECK_INTERVAL_MS = 200;
+const PYTHON_CANDIDATES = ["python", "python3"];
+const GRAPHITI_IMPORT_PROBE = "import dbx_tools.graphiti";
+const graphitiPython = functionUtils.memoize(async () => {
+    const available = (await Promise.all(PYTHON_CANDIDATES.map((command) => _probePython(command)))).filter((candidate) => candidate !== undefined);
+    available.sort((left, right) => rcompare(left.version, right.version));
+    return available[0]?.command;
+});
+function graphitiOptions(options) {
+    const { healthCheck: _healthCheck, signal: _signal, ...graphiti } = options;
+    return graphiti;
+}
+/** Milliseconds left in a startup budget after `startedAt`. */
+export function remainingTimeoutMs(startedAt, timeoutMs, now = Date.now()) {
+    return Math.max(0, timeoutMs - (now - startedAt));
+}
+function _runtimeEnvironment(options) {
+    if (options.listen.scheme !== "tcp")
+        throw new Error("Graphiti requires a TCP listener");
+    const nodeBin = process.env.DBX_TOOLS_NODE_BIN?.trim();
+    const path = nodeBin
+        ? [dirname(nodeBin), process.env.PATH].filter(Boolean).join(delimiter)
+        : process.env.PATH;
+    return {
+        ...process.env,
+        ...(path ? { PATH: path } : {}),
+        ...graphitiOptionsEnvironment(options),
+    };
+}
+/** Return whether the Graphiti `/healthcheck` endpoint responds successfully. */
+export async function graphitiHealthCheck(options, signal) {
+    try {
+        return (await fetch(graphitiHttpUrl(options, "/healthcheck"), {
+            signal,
+            headers: graphitiRequestHeaders(options),
+        })).ok;
+    }
+    catch (error) {
+        if (signal.aborted)
+            throw error;
+        return false;
+    }
+}
+/** Poll `/healthcheck` until it succeeds or `timeoutMs` elapses. */
+export async function waitForGraphitiHealth(options, timeoutMs, signal) {
+    const budget = Math.max(1, timeoutMs);
+    for await (const healthy of asyncUtils.poll(({ signal: pollSignal }) => graphitiHealthCheck(options, pollSignal), {
+        intervalMs: HEALTH_CHECK_INTERVAL_MS,
+        timeoutMs: budget,
+        signal,
+        predicate: (ready) => !ready,
+    })) {
+        if (healthy)
+            return;
+    }
+    throw new Error("Graphiti sidecar healthcheck did not succeed");
+}
+/** Build authorization headers for one optionally secured Graphiti runtime. */
+export function graphitiRequestHeaders(options) {
+    return options.bearer ? { authorization: `Bearer ${options.bearer}` } : {};
+}
+/** Resolve configured or app-installed Python, otherwise a uv-provisioned runtime. */
+export async function resolveGraphitiPythonCommand(options = {}, ...args) {
+    const python = process.env.PYTHON?.trim();
+    if (python)
+        return { command: python, args };
+    if (environmentUtils.isDatabricksAppEnv()) {
+        const installed = await graphitiPython();
+        if (installed)
+            return { command: installed, args };
+    }
+    const extra = options.dev ? "[dev]" : "";
+    const packageArgs = [
+        "--with",
+        `dbx-tools-graphiti${extra}==${(await import("../../index.js")).PACKAGE_VERSION}`,
+    ];
+    return {
+        command: "uv",
+        args: ["run", "--no-project", ...packageArgs, "--python", "python3", "python", ...args],
+    };
+}
+async function _probePython(command) {
+    const versionResult = await exec.spawn(command, ["-V"], {
+        check: false,
+        stdin: "ignore",
+        stdout: "capture",
+        stderr: "capture",
+        trim: true,
+    });
+    if (versionResult.exitCode !== 0)
+        return undefined;
+    const version = coerce(`${versionResult.stdout}\n${versionResult.stderr}`);
+    if (!version)
+        return undefined;
+    const importResult = await exec.spawn(command, ["-c", GRAPHITI_IMPORT_PROBE], {
+        check: false,
+        stdin: "ignore",
+        stdout: "ignore",
+        stderr: "ignore",
+    });
+    return importResult.exitCode === 0 ? { command, version } : undefined;
+}
+/** Build one HTTP URL for a resolved Graphiti listener. */
+export function graphitiHttpUrl(options, path) {
+    return `${sharedOptions
+        .formatListenAddress(options.listen)
+        .replace(/^tcp:/, "http:")}${path.startsWith("/") ? path : `/${path}`}`;
+}
+/** Build one readiness-gated Graphiti sidecar from the shared typed options. */
+export async function createGraphitiChildProcess(options = {}) {
+    const healthCheck = options.healthCheck;
+    const resolved = resolveGraphitiOptions(graphitiOptions(options));
+    const python = await resolveGraphitiPythonCommand({ dev: !resolved.databaseUrl }, "-m", "dbx_tools.graphiti");
+    const child = exec.spawn(python.command, python.args, {
+        env: _runtimeEnvironment(resolved),
+        forwardTerminationSignals: false,
+    });
+    const controller = new AbortController();
+    const startupSignal = options.signal
+        ? AbortSignal.any([controller.signal, options.signal])
+        : controller.signal;
+    const probe = healthCheck ?? (({ signal }) => graphitiHealthCheck(resolved, signal));
+    try {
+        await Promise.race([
+            waitForGraphitiChild(child, probe, resolved.startupTimeoutMs, startupSignal),
+            child.then((result) => {
+                throw new Error(`Graphiti child ${child.pid ?? "<unknown>"} exited before becoming ready ` +
+                    `(exit ${result.exitCode})`);
+            }),
+        ]);
+        return { child };
+    }
+    catch (error) {
+        await child.shutdown();
+        throw error;
+    }
+    finally {
+        controller.abort();
+    }
+}
+async function waitForGraphitiChild(child, healthCheck, timeoutMs, signal) {
+    for await (const healthy of asyncUtils.poll(({ attempt, signal: pollSignal }) => healthCheck({ process: child, signal: pollSignal, attempt }), {
+        intervalMs: HEALTH_CHECK_INTERVAL_MS,
+        timeoutMs,
+        signal,
+        predicate: (ready) => !ready,
+    })) {
+        if (healthy)
+            return;
+    }
+}
+/** Run the supervised stack until the child exits. */
+export async function runGraphiti(options = {}) {
+    const { child } = await createGraphitiChildProcess(options);
+    const outcome = await child;
+    if (outcome.exitCode !== 0) {
+        throw new Error(`Graphiti child exited with status ${outcome.exitCode}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../../src/graphiti/runtime.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Node Graphiti runtime and process supervision.\n *\n * @module\n */\n\nimport { delimiter, dirname } from \"node:path\";\nimport { exec } from \"@dbx-tools/core\";\nimport type { ChildProcessResult } from \"@dbx-tools/core/exec\";\nimport {\n  asyncUtils,\n  environmentUtils,\n  functionUtils,\n  options as sharedOptions,\n} from \"@dbx-tools/shared-core\";\nimport { coerce, rcompare, type SemVer } from \"semver\";\n\nimport {\n  graphitiOptionsEnvironment,\n  resolveGraphitiOptions,\n  type GraphitiOptions,\n  type ResolvedGraphitiOptions,\n} from \"./options.ts\";\n\n/** Context passed to one Graphiti sidecar readiness probe. */\nexport interface GraphitiHealthCheckContext {\n  readonly process: ChildProcessResult;\n  readonly signal: AbortSignal;\n  readonly attempt: number;\n}\n\n/** HTTP probe used to decide that the Graphiti sidecar has started listening. */\nexport type GraphitiHealthCheck = (\n  context: GraphitiHealthCheckContext,\n) => boolean | PromiseLike<boolean>;\n\n/** Async creation result that preserves the awaitable child handle. */\nexport interface GraphitiChildProcess {\n  child: ChildProcessResult;\n}\n\n/** Shared Graphiti options plus the Node-only sidecar readiness probe. */\nexport type GraphitiRuntimeOptions = GraphitiOptions & {\n  /** Readiness probe for {@link createGraphitiChildProcess}. Defaults to `/healthcheck`. */\n  healthCheck?: GraphitiHealthCheck;\n  /** Cancels sidecar startup without changing the serialized Graphiti configuration. */\n  signal?: AbortSignal;\n};\n\nconst HEALTH_CHECK_INTERVAL_MS = 200;\nconst PYTHON_CANDIDATES = [\"python\", \"python3\"] as const;\nconst GRAPHITI_IMPORT_PROBE = \"import dbx_tools.graphiti\";\n\ninterface PythonCandidate {\n  command: string;\n  version: SemVer;\n}\n\nconst graphitiPython = functionUtils.memoize(async (): Promise<string | undefined> => {\n  const available = (\n    await Promise.all(PYTHON_CANDIDATES.map((command) => _probePython(command)))\n  ).filter((candidate): candidate is PythonCandidate => candidate !== undefined);\n  available.sort((left, right) => rcompare(left.version, right.version));\n  return available[0]?.command;\n});\n\nfunction graphitiOptions(options: GraphitiRuntimeOptions): GraphitiOptions {\n  const { healthCheck: _healthCheck, signal: _signal, ...graphiti } = options;\n  return graphiti;\n}\n\n/** Milliseconds left in a startup budget after `startedAt`. */\nexport function remainingTimeoutMs(startedAt: number, timeoutMs: number, now = Date.now()): number {\n  return Math.max(0, timeoutMs - (now - startedAt));\n}\n\nfunction _runtimeEnvironment(options: ResolvedGraphitiOptions): NodeJS.ProcessEnv {\n  if (options.listen.scheme !== \"tcp\") throw new Error(\"Graphiti requires a TCP listener\");\n  const nodeBin = process.env.DBX_TOOLS_NODE_BIN?.trim();\n  const path = nodeBin\n    ? [dirname(nodeBin), process.env.PATH].filter(Boolean).join(delimiter)\n    : process.env.PATH;\n  return {\n    ...process.env,\n    ...(path ? { PATH: path } : {}),\n    ...graphitiOptionsEnvironment(options),\n  };\n}\n\n/** Return whether the Graphiti `/healthcheck` endpoint responds successfully. */\nexport async function graphitiHealthCheck(\n  options: Pick<ResolvedGraphitiOptions, \"listen\" | \"bearer\">,\n  signal: AbortSignal,\n): Promise<boolean> {\n  try {\n    return (\n      await fetch(graphitiHttpUrl(options, \"/healthcheck\"), {\n        signal,\n        headers: graphitiRequestHeaders(options),\n      })\n    ).ok;\n  } catch (error) {\n    if (signal.aborted) throw error;\n    return false;\n  }\n}\n\n/** Poll `/healthcheck` until it succeeds or `timeoutMs` elapses. */\nexport async function waitForGraphitiHealth(\n  options: Pick<ResolvedGraphitiOptions, \"listen\" | \"bearer\">,\n  timeoutMs: number,\n  signal?: AbortSignal,\n): Promise<void> {\n  const budget = Math.max(1, timeoutMs);\n  for await (const healthy of asyncUtils.poll(\n    ({ signal: pollSignal }) => graphitiHealthCheck(options, pollSignal),\n    {\n      intervalMs: HEALTH_CHECK_INTERVAL_MS,\n      timeoutMs: budget,\n      signal,\n      predicate: (ready) => !ready,\n    },\n  )) {\n    if (healthy) return;\n  }\n  throw new Error(\"Graphiti sidecar healthcheck did not succeed\");\n}\n\n/** Build authorization headers for one optionally secured Graphiti runtime. */\nexport function graphitiRequestHeaders(\n  options: Pick<ResolvedGraphitiOptions, \"bearer\">,\n): Readonly<Record<string, string>> {\n  return options.bearer ? { authorization: `Bearer ${options.bearer}` } : {};\n}\n\n/** Executable and arguments used to launch Graphiti. */\nexport interface GraphitiPythonCommand {\n  command: string;\n  args: string[];\n}\n\n/** Resolve configured or app-installed Python, otherwise a uv-provisioned runtime. */\nexport async function resolveGraphitiPythonCommand(\n  options: { dev?: boolean } = {},\n  ...args: string[]\n): Promise<GraphitiPythonCommand> {\n  const python = process.env.PYTHON?.trim();\n  if (python) return { command: python, args };\n  if (environmentUtils.isDatabricksAppEnv()) {\n    const installed = await graphitiPython();\n    if (installed) return { command: installed, args };\n  }\n  const extra = options.dev ? \"[dev]\" : \"\";\n  const packageArgs = [\n    \"--with\",\n    `dbx-tools-graphiti${extra}==${(await import(\"../../index.ts\")).PACKAGE_VERSION}`,\n  ];\n  return {\n    command: \"uv\",\n    args: [\"run\", \"--no-project\", ...packageArgs, \"--python\", \"python3\", \"python\", ...args],\n  };\n}\n\nasync function _probePython(command: string): Promise<PythonCandidate | undefined> {\n  const versionResult = await exec.spawn(command, [\"-V\"], {\n    check: false,\n    stdin: \"ignore\",\n    stdout: \"capture\",\n    stderr: \"capture\",\n    trim: true,\n  });\n  if (versionResult.exitCode !== 0) return undefined;\n  const version = coerce(`${versionResult.stdout}\\n${versionResult.stderr}`);\n  if (!version) return undefined;\n\n  const importResult = await exec.spawn(command, [\"-c\", GRAPHITI_IMPORT_PROBE], {\n    check: false,\n    stdin: \"ignore\",\n    stdout: \"ignore\",\n    stderr: \"ignore\",\n  });\n  return importResult.exitCode === 0 ? { command, version } : undefined;\n}\n\n/** Build one HTTP URL for a resolved Graphiti listener. */\nexport function graphitiHttpUrl(\n  options: Pick<ResolvedGraphitiOptions, \"listen\">,\n  path: string,\n): string {\n  return `${sharedOptions\n    .formatListenAddress(options.listen)\n    .replace(/^tcp:/, \"http:\")}${path.startsWith(\"/\") ? path : `/${path}`}`;\n}\n\n/** Build one readiness-gated Graphiti sidecar from the shared typed options. */\nexport async function createGraphitiChildProcess(\n  options: GraphitiRuntimeOptions = {},\n): Promise<GraphitiChildProcess> {\n  const healthCheck = options.healthCheck;\n  const resolved = resolveGraphitiOptions(graphitiOptions(options));\n  const python = await resolveGraphitiPythonCommand(\n    { dev: !resolved.databaseUrl },\n    \"-m\",\n    \"dbx_tools.graphiti\",\n  );\n  const child = exec.spawn(python.command, python.args, {\n    env: _runtimeEnvironment(resolved),\n    forwardTerminationSignals: false,\n  });\n  const controller = new AbortController();\n  const startupSignal = options.signal\n    ? AbortSignal.any([controller.signal, options.signal])\n    : controller.signal;\n  const probe = healthCheck ?? (({ signal }) => graphitiHealthCheck(resolved, signal));\n  try {\n    await Promise.race([\n      waitForGraphitiChild(child, probe, resolved.startupTimeoutMs, startupSignal),\n      child.then((result) => {\n        throw new Error(\n          `Graphiti child ${child.pid ?? \"<unknown>\"} exited before becoming ready ` +\n            `(exit ${result.exitCode})`,\n        );\n      }),\n    ]);\n    return { child };\n  } catch (error) {\n    await child.shutdown();\n    throw error;\n  } finally {\n    controller.abort();\n  }\n}\n\nasync function waitForGraphitiChild(\n  child: ChildProcessResult,\n  healthCheck: GraphitiHealthCheck,\n  timeoutMs: number,\n  signal: AbortSignal,\n): Promise<void> {\n  for await (const healthy of asyncUtils.poll(\n    ({ attempt, signal: pollSignal }) =>\n      healthCheck({ process: child, signal: pollSignal, attempt }),\n    {\n      intervalMs: HEALTH_CHECK_INTERVAL_MS,\n      timeoutMs,\n      signal,\n      predicate: (ready) => !ready,\n    },\n  )) {\n    if (healthy) return;\n  }\n}\n\n/** Run the supervised stack until the child exits. */\nexport async function runGraphiti(options: GraphitiRuntimeOptions = {}): Promise<void> {\n  const { child } = await createGraphitiChildProcess(options);\n  const outcome = await child;\n  if (outcome.exitCode !== 0) {\n    throw new Error(`Graphiti child exited with status ${outcome.exitCode}`);\n  }\n}\n"]}

package/lib/src/plugin.d.ts

@@ -0,0 +1,38 @@
+/**
+ * AppKit memory plugin with Databricks-first tools and lazy Graphiti fallback.
+ *
+ * @module
+ */
+import { type PluginManifest } from "@databricks/appkit";
+import { type ToolkitEntry, type ToolkitOptions, type ToolRegistry } from "@databricks/appkit/beta";
+import { ToolRegistryPlugin, type AgentToolExecutionContext } from "@dbx-tools/appkit";
+import { type MemoryPluginConfig } from "./config.ts";
+/** AppKit memory plugin with Databricks managed memory and Graphiti fallback. */
+export declare class MemoryPlugin extends ToolRegistryPlugin<MemoryPluginConfig> {
+    static phase: "deferred";
+    static manifest: PluginManifest<"memory">;
+    private readonly logger;
+    private resolved?;
+    private databricks?;
+    private graphiti?;
+    private graphitiStarting?;
+    private readonly graphitiStartupAbort;
+    private closed;
+    protected get toolRegistry(): ToolRegistry;
+    setup(): Promise<void>;
+    toolkit(options?: ToolkitOptions): Promise<Record<string, ToolkitEntry>>;
+    executeAgentTool(name: string, args: unknown, signal?: AbortSignal, context?: AgentToolExecutionContext): Promise<unknown>;
+    abortActiveOperations(): void;
+    shutdown(): Promise<void>;
+    private registry;
+    private remember;
+    private recall;
+    private saveTurn;
+    private databricksBackend;
+    private shouldFallbackFromDatabricks;
+    private graphitiBackend;
+    private actorId;
+    private requireConfig;
+}
+/** AppKit registration factory for {@link MemoryPlugin}. */
+export declare const memory: import("@databricks/appkit").ToPlugin<typeof MemoryPlugin, MemoryPluginConfig, "memory">;