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

package/lib/src/plugin.js

@@ -0,0 +1,196 @@
+/**
+ * AppKit memory plugin with Databricks-first tools and lazy Graphiti fallback.
+ *
+ * @module
+ */
+import { getExecutionContext, toPlugin } from "@databricks/appkit";
+import { defineTool, executeFromRegistry, } from "@databricks/appkit/beta";
+import { appkit as dbxAppkit, toolkitEntries, ToolRegistryPlugin, } from "@dbx-tools/appkit";
+import { errorUtils, log } from "@dbx-tools/shared-core";
+import { RecallMemoryInputSchema, RememberMemoryInputSchema, } from "./_contracts.js";
+import { MEMORY_CONFIG_SCHEMA, resolveMemoryPluginConfig, } from "./config.js";
+import { DatabricksMemoryRuntime } from "./databricks/_runtime.js";
+/** AppKit memory plugin with Databricks managed memory and Graphiti fallback. */
+export class MemoryPlugin extends ToolRegistryPlugin {
+    static phase = "deferred";
+    static manifest = {
+        name: "memory",
+        displayName: "Memory",
+        description: "Publishes Databricks-first durable memory tools with a lazy Graphiti fallback.",
+        stability: "beta",
+        resources: { required: [], optional: [] },
+        config: { schema: MEMORY_CONFIG_SCHEMA },
+    };
+    logger = log.logger(this);
+    resolved;
+    databricks;
+    graphiti;
+    graphitiStarting;
+    graphitiStartupAbort = new AbortController();
+    closed = false;
+    get toolRegistry() {
+        return this.registry();
+    }
+    async setup() {
+        const resolved = resolveMemoryPluginConfig(this.config);
+        if (resolved.saveTurns === true && resolved.graphiti === false) {
+            throw new Error("AppKit memory saveTurns requires the Graphiti fallback");
+        }
+        this.resolved = resolved;
+        if (resolved.databricks) {
+            this.databricks = new DatabricksMemoryRuntime(getExecutionContext().client, resolved.databricks);
+        }
+        let mastra = false;
+        const context = this.context;
+        const shouldAttachTurnSaver = resolved.saveTurns !== false &&
+            resolved.graphiti !== false &&
+            context?.hasPlugin("mastra") === true;
+        if (shouldAttachTurnSaver && context) {
+            const { attachMastraTurnSaver } = await import("./_mastra.js");
+            mastra = await attachMastraTurnSaver(context, (turn, signal) => this.saveTurn(turn, signal));
+        }
+        if (resolved.saveTurns === true && !mastra) {
+            throw new Error("AppKit memory saveTurns requires a registered Mastra plugin");
+        }
+        this.logger.info("ready", {
+            databricks: resolved.databricks !== false,
+            graphiti: resolved.graphiti !== false ? "lazy" : false,
+            mastraTurnSaver: mastra,
+        });
+    }
+    async toolkit(options) {
+        return toolkitEntries.entries("memory", this.getAgentTools(), {
+            ...options,
+            prefix: options?.prefix ?? "",
+        });
+    }
+    executeAgentTool(name, args, signal, context) {
+        return executeFromRegistry(this.registry(context?.resourceId), name, args, signal);
+    }
+    abortActiveOperations() {
+        super.abortActiveOperations();
+        this.graphitiStartupAbort.abort(new Error("AppKit memory is shutting down"));
+    }
+    async shutdown() {
+        this.closed = true;
+        this.graphitiStartupAbort.abort(new Error("AppKit memory is shutting down"));
+        const starting = this.graphitiStarting;
+        const backend = this.graphiti;
+        this.graphitiStarting = undefined;
+        this.graphiti = undefined;
+        await starting?.catch(() => undefined);
+        await backend?.shutdown();
+    }
+    registry(resourceId) {
+        return {
+            remember: defineTool({
+                description: "Save a durable user preference, fact, decision, or instruction for future conversations.",
+                schema: RememberMemoryInputSchema,
+                annotations: { effect: "write", requiresUserContext: true },
+                autoInheritable: false,
+                execute: (input, signal) => this.remember(this.actorId(resourceId), input, signal),
+            }),
+            recall_memory: defineTool({
+                description: "Search durable actor-scoped memory for facts and preferences relevant to the current task.",
+                schema: RecallMemoryInputSchema,
+                annotations: { effect: "read", requiresUserContext: true },
+                autoInheritable: false,
+                execute: (input, signal) => this.recall(this.actorId(resourceId), input, signal),
+            }),
+        };
+    }
+    async remember(actorId, input, signal) {
+        const databricks = await this.databricksBackend(actorId, signal);
+        if (databricks) {
+            try {
+                return await databricks.remember(actorId, input, signal);
+            }
+            catch (error) {
+                if (!this.shouldFallbackFromDatabricks(error))
+                    throw error;
+            }
+        }
+        return (await this.graphitiBackend()).remember(actorId, input, signal);
+    }
+    async recall(actorId, input, signal) {
+        const parsed = RecallMemoryInputSchema.parse(input);
+        const databricks = await this.databricksBackend(actorId, signal);
+        if (databricks) {
+            try {
+                return await databricks.recall(actorId, parsed, signal);
+            }
+            catch (error) {
+                if (!this.shouldFallbackFromDatabricks(error))
+                    throw error;
+            }
+        }
+        return (await this.graphitiBackend()).recall(actorId, parsed, signal);
+    }
+    async saveTurn(turn, signal) {
+        if (await this.databricksBackend(turn.actorId, signal))
+            return;
+        await (await this.graphitiBackend()).saveTurn(turn, signal);
+    }
+    async databricksBackend(actorId, signal) {
+        const backend = this.databricks;
+        if (!backend)
+            return undefined;
+        if (await backend.available(actorId, signal))
+            return backend;
+        const configured = this.requireConfig().databricks;
+        if (configured && configured.mode === "required") {
+            throw new Error("Required Databricks managed memory is unavailable for the current actor");
+        }
+        return undefined;
+    }
+    shouldFallbackFromDatabricks(error) {
+        const configured = this.requireConfig().databricks;
+        return (configured !== false &&
+            configured.mode === "auto" &&
+            errorUtils.errorContext(error).hasStatusCode(403, 404));
+    }
+    async graphitiBackend() {
+        if (this.closed)
+            throw new Error("AppKit memory is closed");
+        if (this.graphiti?.running)
+            return this.graphiti;
+        if (this.graphiti) {
+            await this.graphiti.shutdown();
+            this.graphiti = undefined;
+        }
+        const options = this.requireConfig().graphiti;
+        if (!options)
+            throw new Error("Graphiti fallback is disabled");
+        this.graphitiStarting ??= import("./graphiti/_backend.js")
+            .then(({ startGraphitiBackend }) => startGraphitiBackend(options, this.graphitiStartupAbort.signal))
+            .then((backend) => {
+            if (this.closed) {
+                return backend.shutdown().then(() => {
+                    throw new Error("AppKit memory closed during Graphiti startup");
+                });
+            }
+            this.graphiti = backend;
+            return backend;
+        })
+            .finally(() => {
+            this.graphitiStarting = undefined;
+        });
+        return this.graphitiStarting;
+    }
+    actorId(resourceId) {
+        if (resourceId)
+            return resourceId;
+        const context = dbxAppkit.tryGetExecutionContext();
+        if (!context)
+            throw new Error("Memory tools require an AppKit execution context");
+        return "userId" in context ? context.userId : context.serviceUserId;
+    }
+    requireConfig() {
+        if (!this.resolved)
+            throw new Error("AppKit memory is not initialized");
+        return this.resolved;
+    }
+}
+/** AppKit registration factory for {@link MemoryPlugin}. */
+export const memory = toPlugin(MemoryPlugin);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../../src/plugin.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * AppKit memory plugin with Databricks-first tools and lazy Graphiti fallback.\n *\n * @module\n */\n\nimport { getExecutionContext, toPlugin, type PluginManifest } from \"@databricks/appkit\";\nimport {\n  defineTool,\n  executeFromRegistry,\n  type ToolkitEntry,\n  type ToolkitOptions,\n  type ToolRegistry,\n} from \"@databricks/appkit/beta\";\nimport {\n  appkit as dbxAppkit,\n  toolkitEntries,\n  ToolRegistryPlugin,\n  type AgentToolExecutionContext,\n} from \"@dbx-tools/appkit\";\nimport { errorUtils, log } from \"@dbx-tools/shared-core\";\n\nimport {\n  RecallMemoryInputSchema,\n  RememberMemoryInputSchema,\n  type GraphitiMemoryBackend,\n  type MemoryTurn,\n  type RecallMemoryInput,\n  type RecallMemoryResult,\n  type RememberMemoryInput,\n  type RememberMemoryResult,\n} from \"./_contracts.ts\";\nimport {\n  MEMORY_CONFIG_SCHEMA,\n  resolveMemoryPluginConfig,\n  type MemoryPluginConfig,\n  type ResolvedMemoryPluginConfig,\n} from \"./config.ts\";\nimport { DatabricksMemoryRuntime } from \"./databricks/_runtime.ts\";\n\n/** AppKit memory plugin with Databricks managed memory and Graphiti fallback. */\nexport class MemoryPlugin extends ToolRegistryPlugin<MemoryPluginConfig> {\n  static phase = \"deferred\" as const;\n  static manifest: PluginManifest<\"memory\"> = {\n    name: \"memory\",\n    displayName: \"Memory\",\n    description: \"Publishes Databricks-first durable memory tools with a lazy Graphiti fallback.\",\n    stability: \"beta\",\n    resources: { required: [], optional: [] },\n    config: { schema: MEMORY_CONFIG_SCHEMA },\n  };\n\n  private readonly logger = log.logger(this);\n  private resolved?: ResolvedMemoryPluginConfig;\n  private databricks?: DatabricksMemoryRuntime;\n  private graphiti?: GraphitiMemoryBackend;\n  private graphitiStarting?: Promise<GraphitiMemoryBackend>;\n  private readonly graphitiStartupAbort = new AbortController();\n  private closed = false;\n\n  protected get toolRegistry(): ToolRegistry {\n    return this.registry();\n  }\n\n  override async setup(): Promise<void> {\n    const resolved = resolveMemoryPluginConfig(this.config);\n    if (resolved.saveTurns === true && resolved.graphiti === false) {\n      throw new Error(\"AppKit memory saveTurns requires the Graphiti fallback\");\n    }\n    this.resolved = resolved;\n    if (resolved.databricks) {\n      this.databricks = new DatabricksMemoryRuntime(\n        getExecutionContext().client,\n        resolved.databricks,\n      );\n    }\n\n    let mastra = false;\n    const context = this.context;\n    const shouldAttachTurnSaver =\n      resolved.saveTurns !== false &&\n      resolved.graphiti !== false &&\n      context?.hasPlugin(\"mastra\") === true;\n    if (shouldAttachTurnSaver && context) {\n      const { attachMastraTurnSaver } = await import(\"./_mastra.ts\");\n      mastra = await attachMastraTurnSaver(context, (turn, signal) => this.saveTurn(turn, signal));\n    }\n    if (resolved.saveTurns === true && !mastra) {\n      throw new Error(\"AppKit memory saveTurns requires a registered Mastra plugin\");\n    }\n    this.logger.info(\"ready\", {\n      databricks: resolved.databricks !== false,\n      graphiti: resolved.graphiti !== false ? \"lazy\" : false,\n      mastraTurnSaver: mastra,\n    });\n  }\n\n  async toolkit(options?: ToolkitOptions): Promise<Record<string, ToolkitEntry>> {\n    return toolkitEntries.entries(\"memory\", this.getAgentTools(), {\n      ...options,\n      prefix: options?.prefix ?? \"\",\n    });\n  }\n\n  override executeAgentTool(\n    name: string,\n    args: unknown,\n    signal?: AbortSignal,\n    context?: AgentToolExecutionContext,\n  ): Promise<unknown> {\n    return executeFromRegistry(this.registry(context?.resourceId), name, args, signal);\n  }\n\n  override abortActiveOperations(): void {\n    super.abortActiveOperations();\n    this.graphitiStartupAbort.abort(new Error(\"AppKit memory is shutting down\"));\n  }\n\n  async shutdown(): Promise<void> {\n    this.closed = true;\n    this.graphitiStartupAbort.abort(new Error(\"AppKit memory is shutting down\"));\n    const starting = this.graphitiStarting;\n    const backend = this.graphiti;\n    this.graphitiStarting = undefined;\n    this.graphiti = undefined;\n    await starting?.catch(() => undefined);\n    await backend?.shutdown();\n  }\n\n  private registry(resourceId?: string): ToolRegistry {\n    return {\n      remember: defineTool({\n        description:\n          \"Save a durable user preference, fact, decision, or instruction for future conversations.\",\n        schema: RememberMemoryInputSchema,\n        annotations: { effect: \"write\", requiresUserContext: true },\n        autoInheritable: false,\n        execute: (input, signal) => this.remember(this.actorId(resourceId), input, signal),\n      }),\n      recall_memory: defineTool({\n        description:\n          \"Search durable actor-scoped memory for facts and preferences relevant to the current task.\",\n        schema: RecallMemoryInputSchema,\n        annotations: { effect: \"read\", requiresUserContext: true },\n        autoInheritable: false,\n        execute: (input, signal) => this.recall(this.actorId(resourceId), input, signal),\n      }),\n    };\n  }\n\n  private async remember(\n    actorId: string,\n    input: RememberMemoryInput,\n    signal?: AbortSignal,\n  ): Promise<RememberMemoryResult> {\n    const databricks = await this.databricksBackend(actorId, signal);\n    if (databricks) {\n      try {\n        return await databricks.remember(actorId, input, signal);\n      } catch (error) {\n        if (!this.shouldFallbackFromDatabricks(error)) throw error;\n      }\n    }\n    return (await this.graphitiBackend()).remember(actorId, input, signal);\n  }\n\n  private async recall(\n    actorId: string,\n    input: RecallMemoryInput,\n    signal?: AbortSignal,\n  ): Promise<RecallMemoryResult> {\n    const parsed = RecallMemoryInputSchema.parse(input);\n    const databricks = await this.databricksBackend(actorId, signal);\n    if (databricks) {\n      try {\n        return await databricks.recall(actorId, parsed, signal);\n      } catch (error) {\n        if (!this.shouldFallbackFromDatabricks(error)) throw error;\n      }\n    }\n    return (await this.graphitiBackend()).recall(actorId, parsed, signal);\n  }\n\n  private async saveTurn(turn: MemoryTurn, signal?: AbortSignal): Promise<void> {\n    if (await this.databricksBackend(turn.actorId, signal)) return;\n    await (await this.graphitiBackend()).saveTurn(turn, signal);\n  }\n\n  private async databricksBackend(\n    actorId: string,\n    signal?: AbortSignal,\n  ): Promise<DatabricksMemoryRuntime | undefined> {\n    const backend = this.databricks;\n    if (!backend) return undefined;\n    if (await backend.available(actorId, signal)) return backend;\n    const configured = this.requireConfig().databricks;\n    if (configured && configured.mode === \"required\") {\n      throw new Error(\"Required Databricks managed memory is unavailable for the current actor\");\n    }\n    return undefined;\n  }\n\n  private shouldFallbackFromDatabricks(error: unknown): boolean {\n    const configured = this.requireConfig().databricks;\n    return (\n      configured !== false &&\n      configured.mode === \"auto\" &&\n      errorUtils.errorContext(error).hasStatusCode(403, 404)\n    );\n  }\n\n  private async graphitiBackend(): Promise<GraphitiMemoryBackend> {\n    if (this.closed) throw new Error(\"AppKit memory is closed\");\n    if (this.graphiti?.running) return this.graphiti;\n    if (this.graphiti) {\n      await this.graphiti.shutdown();\n      this.graphiti = undefined;\n    }\n    const options = this.requireConfig().graphiti;\n    if (!options) throw new Error(\"Graphiti fallback is disabled\");\n    this.graphitiStarting ??= import(\"./graphiti/_backend.ts\")\n      .then(({ startGraphitiBackend }) =>\n        startGraphitiBackend(options, this.graphitiStartupAbort.signal),\n      )\n      .then((backend) => {\n        if (this.closed) {\n          return backend.shutdown().then(() => {\n            throw new Error(\"AppKit memory closed during Graphiti startup\");\n          });\n        }\n        this.graphiti = backend;\n        return backend;\n      })\n      .finally(() => {\n        this.graphitiStarting = undefined;\n      });\n    return this.graphitiStarting;\n  }\n\n  private actorId(resourceId?: string): string {\n    if (resourceId) return resourceId;\n    const context = dbxAppkit.tryGetExecutionContext();\n    if (!context) throw new Error(\"Memory tools require an AppKit execution context\");\n    return \"userId\" in context ? context.userId : context.serviceUserId;\n  }\n\n  private requireConfig(): ResolvedMemoryPluginConfig {\n    if (!this.resolved) throw new Error(\"AppKit memory is not initialized\");\n    return this.resolved;\n  }\n}\n\n/** AppKit registration factory for {@link MemoryPlugin}. */\nexport const memory = toPlugin(MemoryPlugin);\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/_contracts.ts","../src/_mastra.ts","../src/config.ts","../src/plugin.ts","../src/databricks/_runtime.ts","../src/databricks/client.ts","../src/databricks/index.ts","../src/graphiti/_backend.ts","../src/graphiti/index.ts","../src/graphiti/options.ts","../src/graphiti/runtime.ts","../smoke/mastra-tool.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -1,6 +1,106 @@
 {
   "name": "@dbx-tools/appkit-memory",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "description": "AppKit durable memory tools with Databricks managed memory and lazy Graphiti fallback",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/reggie-db/dbx-tools.git",
+    "directory": "packages/js/node/appkit-memory"
+  },
+  "scripts": {
+    "build": "projen build",
+    "compile": "projen compile",
+    "default": "projen default",
+    "package": "projen package",
+    "post-compile": "projen post-compile",
+    "pre-compile": "projen pre-compile",
+    "prepack": "projen prepack",
+    "test": "projen test",
+    "watch": "projen watch",
+    "projen": "projen"
+  },
+  "devDependencies": {
+    "@dbx-tools/appkit-mastra": "^0.9.131",
+    "@types/json-schema": "^7",
+    "@types/node": "^24.6.0",
+    "typescript": "^5.9.3",
+    "vitest": "3.2.4"
+  },
+  "peerDependencies": {
+    "@dbx-tools/appkit-mastra": "^0.9.131"
+  },
+  "dependencies": {
+    "@databricks/appkit": "0.81.0",
+    "@dbx-tools/appkit": "^0.9.131",
+    "@dbx-tools/auth": "^0.9.131",
+    "@dbx-tools/cache": "^0.9.131",
+    "@dbx-tools/core": "^0.9.131",
+    "@dbx-tools/shared-core": "^0.9.131",
+    "@dbx-tools/shared-graphiti": "^0.9.131",
+    "semver": "^7.7.3",
+    "zod": "4.3.6"
+  },
+  "main": "./lib/index.js",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public",
+    "main": "./lib/index.js",
+    "types": "./lib/index.d.ts",
+    "exports": {
+      ".": {
+        "types": "./lib/index.d.ts",
+        "default": "./lib/index.js"
+      },
+      "./config": {
+        "types": "./lib/src/config.d.ts",
+        "default": "./lib/src/config.js"
+      },
+      "./plugin": {
+        "types": "./lib/src/plugin.d.ts",
+        "default": "./lib/src/plugin.js"
+      },
+      "./*": {
+        "types": "./lib/src/*/index.d.ts",
+        "default": "./lib/src/*/index.js"
+      },
+      "./package.json": "./package.json"
+    }
+  },
+  "version": "0.9.131",
+  "types": "./lib/index.d.ts",
+  "dbxToolsConfig": {
+    "tags": [
+      "node"
+    ]
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./config": {
+      "types": "./lib/src/config.d.ts",
+      "default": "./lib/src/config.js"
+    },
+    "./plugin": {
+      "types": "./lib/src/plugin.d.ts",
+      "default": "./lib/src/plugin.js"
+    },
+    "./*": {
+      "types": "./lib/src/*/index.d.ts",
+      "default": "./lib/src/*/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.ts",
+    "src",
+    "lib"
+  ],
+  "peerDependenciesMeta": {
+    "@dbx-tools/appkit-mastra": {
+      "optional": true
+    }
+  },
+  "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"bunx projen\"."
+}

package/src/_contracts.ts

@@ -0,0 +1,107 @@
+/**
+ * Backend-neutral memory tool and turn contracts.
+ *
+ * @module
+ */
+
+import { z } from "zod";
+
+export const RememberMemoryInputSchema = z
+  .object({
+    path: z
+      .string()
+      .trim()
+      .startsWith("/")
+      .describe("Stable absolute memory path, such as /preferences/response.md."),
+    content: z.string().trim().min(1).describe("Durable memory content."),
+    description: z
+      .string()
+      .trim()
+      .min(1)
+      .optional()
+      .describe("Short retrieval-oriented description."),
+  })
+  .strict()
+  .describe("Durable memory to save for the current actor.");
+
+export type RememberMemoryInput = z.infer<typeof RememberMemoryInputSchema>;
+
+export const RecallMemoryInputSchema = z
+  .object({
+    query: z.string().trim().min(1).describe("Question or phrase used to retrieve memory."),
+    limit: z.coerce
+      .number<number>()
+      .int()
+      .min(1)
+      .max(100)
+      .default(10)
+      .describe("Maximum number of matching memories to return."),
+  })
+  .strict()
+  .describe("Actor-scoped memory search.");
+
+export type RecallMemoryInput = z.input<typeof RecallMemoryInputSchema>;
+
+export const MemoryBackendSchema = z
+  .enum(["databricks", "graphiti"])
+  .describe("Memory backend that completed the operation.");
+
+export type MemoryBackend = z.infer<typeof MemoryBackendSchema>;
+
+export const MemoryRecordSchema = z
+  .object({
+    path: z.string().optional().describe("Stable memory path when the backend supports paths."),
+    content: z.string().describe("Retrieved or saved memory content."),
+    description: z.string().optional().describe("Retrieval-oriented memory description."),
+    score: z.number().optional().describe("Backend relevance score when available."),
+  })
+  .strict()
+  .describe("Backend-neutral durable memory record.");
+
+export type MemoryRecord = z.infer<typeof MemoryRecordSchema>;
+
+export const RememberMemoryResultSchema = z
+  .object({
+    backend: MemoryBackendSchema,
+    memory: MemoryRecordSchema,
+  })
+  .strict()
+  .describe("Result of saving one durable memory.");
+
+export type RememberMemoryResult = z.infer<typeof RememberMemoryResultSchema>;
+
+export const RecallMemoryResultSchema = z
+  .object({
+    backend: MemoryBackendSchema,
+    memories: z.array(MemoryRecordSchema).describe("Matching actor-scoped memories."),
+  })
+  .strict()
+  .describe("Result of one durable memory search.");
+
+export type RecallMemoryResult = z.infer<typeof RecallMemoryResultSchema>;
+
+/** Completed Mastra turn offered to the optional external saver. */
+export interface MemoryTurn {
+  readonly agentId: string;
+  readonly actorId: string;
+  readonly threadId: string;
+  readonly user: string;
+  readonly assistant: string;
+}
+
+/** Lazy Graphiti backend used only after managed memory is unavailable. */
+export interface GraphitiMemoryBackend {
+  readonly running: boolean;
+  remember(
+    actorId: string,
+    input: RememberMemoryInput,
+    signal?: AbortSignal,
+  ): Promise<RememberMemoryResult>;
+  recall(
+    actorId: string,
+    input: z.output<typeof RecallMemoryInputSchema>,
+    signal?: AbortSignal,
+  ): Promise<RecallMemoryResult>;
+  saveTurn(turn: MemoryTurn, signal?: AbortSignal): Promise<void>;
+  shutdown(): Promise<void>;
+}

package/src/_mastra.ts

@@ -0,0 +1,80 @@
+/**
+ * Optional Mastra output-processor attachment.
+ *
+ * Loaded only when the memory plugin finds a registered Mastra sibling.
+ *
+ * @module
+ */
+
+import { pluginRegistry } from "@dbx-tools/appkit";
+import { errorUtils, log, object } from "@dbx-tools/shared-core";
+
+import type { MemoryTurn } from "./_contracts.ts";
+
+const logger = log.logger("memory/mastra");
+
+interface MemoryMessage {
+  readonly role: string;
+  readonly content: { readonly parts: readonly unknown[] };
+}
+
+/** Attach a memory-owned turn saver through Mastra's generic processor extension. */
+export async function attachMastraTurnSaver(
+  context: pluginRegistry.PluginContextLike,
+  saveTurn: (turn: MemoryTurn, signal?: AbortSignal) => Promise<void>,
+): Promise<boolean> {
+  const mastraModule = await import("@dbx-tools/appkit-mastra");
+  const plugin = pluginRegistry.instance(context, mastraModule.mastra);
+  if (!plugin) return false;
+  plugin.exports().registerOutputProcessor((agentId) => ({
+    id: `appkit_memory_${agentId}`,
+    name: "AppKit memory turn saver",
+    description: "Saves completed turns to the configured fallback memory backend.",
+    processOutputResult: async ({ messageList, requestContext, abortSignal }) => {
+      const scope = mastraModule.memory.requestMemoryScope(requestContext);
+      if (!scope) return messageList;
+      const actorId = typeof scope.resource === "string" ? scope.resource : undefined;
+      const threadId = typeof scope.thread === "string" ? scope.thread : undefined;
+      if (!actorId || !threadId) return messageList;
+      const user = latestText(messageList.get.input.db(), "user");
+      const assistant = latestText(messageList.get.response.db(), "assistant");
+      if (!user || !assistant) return messageList;
+      try {
+        await saveTurn(
+          {
+            agentId,
+            actorId,
+            threadId,
+            user,
+            assistant,
+          },
+          abortSignal,
+        );
+      } catch (error) {
+        logger.warn("turn save failed", { error: errorUtils.toError(error), agentId });
+      }
+      return messageList;
+    },
+  }));
+  return true;
+}
+
+function latestText(
+  messages: readonly MemoryMessage[],
+  role: "user" | "assistant",
+): string | undefined {
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message?.role !== role) continue;
+    const text = message.content.parts
+      .flatMap((part) =>
+        object.isRecord(part) && part.type === "text" && typeof part.text === "string"
+          ? [part.text]
+          : [],
+      )
+      .join("\n")
+      .trim();
+    if (text) return text;
+  }
+  return undefined;
+}

package/src/config.ts

@@ -0,0 +1,134 @@
+/**
+ * Top-level AppKit memory plugin configuration.
+ *
+ * @module
+ */
+
+import type { BasePluginConfig } from "@databricks/appkit";
+import { projectUtils } from "@dbx-tools/core";
+import { stringUtils } from "@dbx-tools/shared-core";
+import {
+  GraphitiOptionsSchema,
+  graphitiOptionOverrides,
+  type GraphitiOptions,
+} from "@dbx-tools/shared-graphiti";
+import type { JSONSchema7 } from "json-schema";
+import { z } from "zod";
+
+export const DatabricksMemoryOptionsSchema = z
+  .object({
+    memoryStore: z
+      .string()
+      .trim()
+      .min(1)
+      .optional()
+      .describe("Existing Databricks Agent Memory Store id or resource name."),
+    mode: z
+      .enum(["auto", "required"])
+      .default("auto")
+      .describe("Whether an inaccessible managed-memory store falls back or fails."),
+  })
+  .strict()
+  .describe("Databricks managed-memory backend configuration.");
+
+export type DatabricksMemoryOptions = z.input<typeof DatabricksMemoryOptionsSchema>;
+
+const GraphitiMemoryOptionsSchema = GraphitiOptionsSchema.partial().describe(
+  "Graphiti option overrides for the lazy fallback.",
+);
+
+export const MemoryPluginOptionsSchema = z
+  .object({
+    databricks: z
+      .union([z.literal("auto"), z.boolean(), DatabricksMemoryOptionsSchema])
+      .default("auto")
+      .describe(
+        "Databricks managed memory mode: auto falls back, true requires access, and false disables it.",
+      ),
+    graphiti: z
+      .union([z.boolean(), GraphitiMemoryOptionsSchema])
+      .default(true)
+      .describe("Lazy Graphiti fallback configuration, enabled by default."),
+    saveTurns: z
+      .union([z.literal("auto"), z.boolean()])
+      .default("auto")
+      .describe(
+        "Completed-turn saving mode: auto attaches when possible, true requires attachment, and false disables it.",
+      ),
+  })
+  .strict()
+  .describe("AppKit memory plugin options.");
+
+export type MemoryPluginOptions = z.input<typeof MemoryPluginOptionsSchema>;
+
+/** AppKit base configuration plus the memory plugin's serialized options. */
+export type MemoryPluginConfig = BasePluginConfig & MemoryPluginOptions;
+
+/** Resolved Databricks store identity and availability policy. */
+export interface ResolvedDatabricksMemoryOptions {
+  readonly memoryStore: string;
+  readonly mode: "auto" | "required";
+}
+
+/** Fully resolved top-level memory configuration. */
+export interface ResolvedMemoryPluginConfig {
+  readonly databricks: false | ResolvedDatabricksMemoryOptions;
+  readonly graphiti: false | GraphitiOptions;
+  readonly saveTurns: "auto" | boolean;
+}
+
+/** JSON Schema published through the AppKit memory plugin manifest. */
+export const MEMORY_CONFIG_SCHEMA = z.toJSONSchema(MemoryPluginOptionsSchema) as JSONSchema7;
+
+/** Resolve plugin defaults without parsing unrelated AppKit base fields. */
+export function resolveMemoryPluginConfig(
+  config: MemoryPluginConfig = {},
+): ResolvedMemoryPluginConfig {
+  const parsed = MemoryPluginOptionsSchema.parse({
+    databricks: config.databricks,
+    graphiti: config.graphiti,
+    saveTurns: config.saveTurns,
+  });
+  if (parsed.databricks === false && parsed.graphiti === false) {
+    throw new Error("AppKit memory requires at least one enabled backend");
+  }
+  return {
+    databricks:
+      parsed.databricks === false
+        ? false
+        : {
+            memoryStore:
+              typeof parsed.databricks === "object" && parsed.databricks.memoryStore
+                ? resourceId(parsed.databricks.memoryStore, "memory-stores")
+                : defaultMemoryStore(),
+            mode:
+              parsed.databricks === true
+                ? "required"
+                : typeof parsed.databricks === "object"
+                  ? parsed.databricks.mode
+                  : "auto",
+          },
+    graphiti:
+      config.graphiti === false
+        ? false
+        : config.graphiti === undefined || config.graphiti === true
+          ? {}
+          : graphitiOptionOverrides(config.graphiti),
+    saveTurns: parsed.saveTurns,
+  };
+}
+
+function defaultMemoryStore(): string {
+  const slug = stringUtils.toSlugWithOptions(
+    { maxLength: 56, truncateStrategy: "hash" },
+    projectUtils.name(),
+  );
+  const id = /^[a-z]/.test(slug) ? slug : `app-${slug}`;
+  return (id.length < 3 ? `${id}-store` : id).slice(0, 56);
+}
+
+function resourceId(value: string, prefix: string): string {
+  const trimmed = value.trim().replace(new RegExp(`^${prefix}/`), "");
+  if (!trimmed) throw new Error(`${prefix} id is required`);
+  return trimmed;
+}