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

package/lib/src/_mastra.js

@@ -0,0 +1,66 @@
+/**
+ * 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";
+const logger = log.logger("memory/mastra");
+/** Attach a memory-owned turn saver through Mastra's generic processor extension. */
+export async function attachMastraTurnSaver(context, saveTurn) {
+    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, role) {
+    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;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/config.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Top-level AppKit memory plugin configuration.
+ *
+ * @module
+ */
+import type { BasePluginConfig } from "@databricks/appkit";
+import { type GraphitiOptions } from "@dbx-tools/shared-graphiti";
+import type { JSONSchema7 } from "json-schema";
+import { z } from "zod";
+export declare const DatabricksMemoryOptionsSchema: z.ZodObject<{
+    memoryStore: z.ZodOptional<z.ZodString>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        required: "required";
+    }>>;
+}, z.core.$strict>;
+export type DatabricksMemoryOptions = z.input<typeof DatabricksMemoryOptionsSchema>;
+export declare const MemoryPluginOptionsSchema: z.ZodObject<{
+    databricks: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodBoolean, z.ZodObject<{
+        memoryStore: z.ZodOptional<z.ZodString>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            auto: "auto";
+            required: "required";
+        }>>;
+    }, z.core.$strict>]>>;
+    graphiti: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        postgresRole: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        profile: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        bearer: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        graphitiHome: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        modelClass: z.ZodOptional<z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+            "chat-thinking": "chat-thinking";
+            "chat-balanced": "chat-balanced";
+            "chat-fast": "chat-fast";
+        }>>>>;
+        temperature: z.ZodOptional<z.ZodDefault<z.ZodCoercedNumber<number>>>;
+        structuredOutputMode: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+        startupTimeoutMs: z.ZodOptional<z.ZodDefault<z.ZodCoercedNumber<number>>>;
+        listen: z.ZodOptional<z.ZodDefault<z.ZodType<{
+            scheme: "tcp";
+            host: string;
+            port: number;
+        }, unknown, z.core.$ZodTypeInternals<{
+            scheme: "tcp";
+            host: string;
+            port: number;
+        }, unknown>>>>;
+        databaseUrl: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        databaseSchema: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+    }, z.core.$strict>]>>;
+    saveTurns: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodBoolean]>>;
+}, z.core.$strict>;
+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 declare const MEMORY_CONFIG_SCHEMA: JSONSchema7;
+/** Resolve plugin defaults without parsing unrelated AppKit base fields. */
+export declare function resolveMemoryPluginConfig(config?: MemoryPluginConfig): ResolvedMemoryPluginConfig;

package/lib/src/config.js

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

package/lib/src/databricks/_runtime.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Request-scoped Databricks managed-memory routing.
+ *
+ * @module
+ */
+import { type WorkspaceClient } from "@databricks/appkit";
+import { type RecallMemoryInput, type RecallMemoryResult, type RememberMemoryInput, type RememberMemoryResult } from "../_contracts.ts";
+import type { ResolvedDatabricksMemoryOptions } from "../config.ts";
+/** Databricks backend that selects the active request credential for each call. */
+export declare class DatabricksMemoryRuntime {
+    private readonly workspaceClient;
+    readonly options: ResolvedDatabricksMemoryOptions;
+    constructor(workspaceClient: WorkspaceClient, options: ResolvedDatabricksMemoryOptions);
+    available(actorId: string, signal?: AbortSignal): Promise<boolean>;
+    remember(actorId: string, input: RememberMemoryInput, signal?: AbortSignal): Promise<RememberMemoryResult>;
+    recall(actorId: string, input: RecallMemoryInput, signal?: AbortSignal): Promise<RecallMemoryResult>;
+    private requestClient;
+}

package/lib/src/databricks/_runtime.js

@@ -0,0 +1,79 @@
+/**
+ * Request-scoped Databricks managed-memory routing.
+ *
+ * @module
+ */
+import { getExecutionContext } from "@databricks/appkit";
+import { createCache, getOrSet } from "@dbx-tools/cache/cache";
+import { RecallMemoryInputSchema, } from "../_contracts.js";
+import { ManagedAgentMemoryClient } from "./client.js";
+const ACCESS_CACHE_TTL_MS = 5 * 60_000;
+const accessCache = createCache({
+    maxEntries: 1_000,
+    ttl: ACCESS_CACHE_TTL_MS,
+    useClone: false,
+});
+/** Databricks backend that selects the active request credential for each call. */
+export class DatabricksMemoryRuntime {
+    workspaceClient;
+    options;
+    constructor(workspaceClient, options) {
+        this.workspaceClient = workspaceClient;
+        this.options = options;
+    }
+    async available(actorId, signal) {
+        const request = this.requestClient(actorId);
+        return ((await getOrSet(accessCache, request.cacheKey, () => request.client.available(signal))) ??
+            false);
+    }
+    async remember(actorId, input, signal) {
+        const entry = await this.requestClient(actorId).client.saveMemory({
+            actorId,
+            ...input,
+            ...(signal ? { signal } : {}),
+        });
+        return {
+            backend: "databricks",
+            memory: {
+                path: entry.path,
+                content: entry.content ?? input.content,
+                ...(entry.description ? { description: entry.description } : {}),
+            },
+        };
+    }
+    async recall(actorId, input, signal) {
+        const parsed = RecallMemoryInputSchema.parse(input);
+        const results = await this.requestClient(actorId).client.searchMemory({
+            actorId,
+            query: parsed.query,
+            limit: parsed.limit,
+            ...(signal ? { signal } : {}),
+        });
+        return {
+            backend: "databricks",
+            memories: results.map(({ entry, score }) => ({
+                path: entry.path,
+                content: entry.content ?? "",
+                ...(entry.description ? { description: entry.description } : {}),
+                ...(score === undefined ? {} : { score }),
+            })),
+        };
+    }
+    requestClient(actorId) {
+        let workspaceClient = this.workspaceClient;
+        let credentialId = actorId;
+        try {
+            const execution = getExecutionContext();
+            workspaceClient = execution.client;
+            credentialId = "userId" in execution ? execution.userId : execution.serviceUserId;
+        }
+        catch {
+            // Startup and tests have no active AppKit request context.
+        }
+        return {
+            client: new ManagedAgentMemoryClient(workspaceClient, this.options),
+            cacheKey: `${this.options.memoryStore}:${credentialId}:${actorId}`,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/databricks/client.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Databricks Agent Memory REST client.
+ *
+ * @module
+ */
+import type { WorkspaceClient } from "@databricks/appkit";
+import { z } from "zod";
+import type { ResolvedDatabricksMemoryOptions } from "../config.ts";
+export declare const ManagedMemoryEntrySchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    actor_id: z.ZodString;
+    session_id: z.ZodOptional<z.ZodString>;
+    path: z.ZodString;
+    content: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    source_type: z.ZodOptional<z.ZodString>;
+    create_time: z.ZodOptional<z.ZodString>;
+    update_time: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type ManagedMemoryEntry = z.infer<typeof ManagedMemoryEntrySchema>;
+/** One managed-memory search result with its optional backend score. */
+export interface ManagedMemorySearchResult {
+    readonly entry: ManagedMemoryEntry;
+    readonly score?: number;
+}
+/** Thin REST client for actor-scoped Databricks Agent Memory operations. */
+export declare class ManagedAgentMemoryClient {
+    private readonly client;
+    readonly memoryStore: string;
+    constructor(client: WorkspaceClient, options: ResolvedDatabricksMemoryOptions);
+    available(signal?: AbortSignal): Promise<boolean>;
+    searchMemory(input: {
+        actorId: string;
+        query: string;
+        limit: number;
+        signal?: AbortSignal;
+    }): Promise<ManagedMemorySearchResult[]>;
+    saveMemory(input: {
+        actorId: string;
+        path: string;
+        content: string;
+        description?: string;
+        signal?: AbortSignal;
+    }): Promise<ManagedMemoryEntry>;
+    private createMemory;
+    private listMemoryEntries;
+    private updateMemory;
+}

package/lib/src/databricks/client.js

@@ -0,0 +1,174 @@
+/**
+ * Databricks Agent Memory REST client.
+ *
+ * @module
+ */
+import { databricks } from "@dbx-tools/appkit";
+import { errorUtils } from "@dbx-tools/shared-core";
+import { z } from "zod";
+export const ManagedMemoryEntrySchema = z
+    .object({
+    name: z.string().optional().describe("Managed memory entry resource name."),
+    actor_id: z.string().describe("Trusted application actor identifier."),
+    session_id: z.string().optional().describe("Associated session identifier."),
+    path: z.string().describe("Absolute memory path."),
+    content: z.string().optional().describe("Memory content."),
+    description: z.string().optional().describe("Memory retrieval description."),
+    source_type: z.string().optional().describe("Entry writer type."),
+    create_time: z.string().optional().describe("Entry creation timestamp."),
+    update_time: z.string().optional().describe("Entry update timestamp."),
+})
+    .loose()
+    .describe("Databricks managed memory entry.");
+const SearchMemoryResponseSchema = z
+    .object({
+    managed_memory_entries: z
+        .array(ManagedMemoryEntrySchema)
+        .optional()
+        .describe("Compatibility list of matching entries."),
+    results: z
+        .array(z
+        .object({
+        managed_memory_entry: ManagedMemoryEntrySchema.describe("Matching memory entry."),
+        score: z.number().optional().describe("BM25 relevance score."),
+    })
+        .loose())
+        .optional()
+        .describe("Ranked memory search results."),
+})
+    .loose()
+    .describe("Databricks managed memory search response.");
+const ListMemoryResponseSchema = z
+    .object({
+    managed_memory_entries: z
+        .array(ManagedMemoryEntrySchema)
+        .optional()
+        .describe("Managed memory entries in this page."),
+    next_page_token: z.string().optional().describe("Next page token."),
+})
+    .loose()
+    .describe("Page of Databricks managed memory entries.");
+/** Thin REST client for actor-scoped Databricks Agent Memory operations. */
+export class ManagedAgentMemoryClient {
+    client;
+    memoryStore;
+    constructor(client, options) {
+        this.client = client;
+        this.memoryStore = options.memoryStore;
+    }
+    async available(signal) {
+        try {
+            await this.client.apiClient.request({
+                path: `/api/2.0/agents/memory-stores/${encodeURIComponent(this.memoryStore)}`,
+                method: "GET",
+                headers: new Headers({ accept: "application/json" }),
+                raw: false,
+            }, signal ? databricks.toContext(signal) : undefined);
+            return true;
+        }
+        catch (error) {
+            if (errorUtils.errorContext(error).hasStatusCode(403, 404))
+                return false;
+            throw error;
+        }
+    }
+    async searchMemory(input) {
+        const response = SearchMemoryResponseSchema.parse(await this.client.apiClient.request({
+            path: `/api/2.0/agents/memory-stores/${encodeURIComponent(this.memoryStore)}/entries:search`,
+            method: "POST",
+            headers: new Headers({
+                accept: "application/json",
+                "content-type": "application/json",
+            }),
+            raw: false,
+            payload: {
+                actor_id: input.actorId,
+                query: input.query,
+                page_size: input.limit,
+            },
+        }, input.signal ? databricks.toContext(input.signal) : undefined));
+        if (response.results) {
+            return response.results.map((result) => ({
+                entry: result.managed_memory_entry,
+                ...(result.score === undefined ? {} : { score: result.score }),
+            }));
+        }
+        return (response.managed_memory_entries ?? []).map((entry) => ({ entry }));
+    }
+    async saveMemory(input) {
+        const existing = (await this.listMemoryEntries(input))[0];
+        if (existing?.name) {
+            return this.updateMemory(existing, input);
+        }
+        try {
+            return await this.createMemory(input);
+        }
+        catch (error) {
+            if (!errorUtils.errorContext(error).hasStatusCode(409))
+                throw error;
+            const raced = (await this.listMemoryEntries(input))[0];
+            if (!raced?.name)
+                throw error;
+            return this.updateMemory(raced, input);
+        }
+    }
+    async createMemory(input) {
+        return ManagedMemoryEntrySchema.parse(await this.client.apiClient.request({
+            path: `/api/2.0/agents/memory-stores/${encodeURIComponent(this.memoryStore)}/entries`,
+            method: "POST",
+            headers: new Headers({
+                accept: "application/json",
+                "content-type": "application/json",
+            }),
+            raw: false,
+            payload: {
+                actor_id: input.actorId,
+                path: input.path,
+                content: input.content,
+                ...(input.description ? { description: input.description } : {}),
+                source_type: "MANAGED_MEMORY_ENTRY_SOURCE_TYPE_AGENT",
+            },
+        }, input.signal ? databricks.toContext(input.signal) : undefined));
+    }
+    async listMemoryEntries(input) {
+        const response = ListMemoryResponseSchema.parse(await this.client.apiClient.request({
+            path: `/api/2.0/agents/memory-stores/${encodeURIComponent(this.memoryStore)}/entries`,
+            method: "GET",
+            headers: new Headers({ accept: "application/json" }),
+            query: {
+                actor_id: input.actorId,
+                path: input.path,
+                page_size: 100,
+            },
+            raw: false,
+        }, input.signal ? databricks.toContext(input.signal) : undefined));
+        return (response.managed_memory_entries ?? []).filter((entry) => entry.path === input.path);
+    }
+    async updateMemory(current, input) {
+        const headers = new Headers({
+            accept: "application/json",
+            "content-type": "application/json",
+        });
+        await this.client.config.authenticate(headers);
+        const response = await fetch(new URL(`/api/2.0/agents/${current.name
+            .split("/")
+            .map((part) => encodeURIComponent(part))
+            .join("/")}?update_mask=content,description`, (await this.client.config.getHost()).toString()), {
+            method: "PATCH",
+            headers,
+            body: JSON.stringify({
+                actor_id: input.actorId,
+                path: input.path,
+                content: input.content,
+                ...(input.description ? { description: input.description } : {}),
+            }),
+            ...(input.signal ? { signal: input.signal } : {}),
+        });
+        const body = await response.json().catch(() => undefined);
+        if (!response.ok) {
+            throw Object.assign(new Error(`Databricks Agent Memory request failed (${response.status})`), { statusCode: response.status, response: body });
+        }
+        return ManagedMemoryEntrySchema.parse(body);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../src/databricks/client.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Databricks Agent Memory REST client.\n *\n * @module\n */\n\nimport type { WorkspaceClient } from \"@databricks/appkit\";\nimport { databricks } from \"@dbx-tools/appkit\";\nimport { errorUtils } from \"@dbx-tools/shared-core\";\nimport { z } from \"zod\";\n\nimport type { ResolvedDatabricksMemoryOptions } from \"../config.ts\";\n\nexport const ManagedMemoryEntrySchema = z\n  .object({\n    name: z.string().optional().describe(\"Managed memory entry resource name.\"),\n    actor_id: z.string().describe(\"Trusted application actor identifier.\"),\n    session_id: z.string().optional().describe(\"Associated session identifier.\"),\n    path: z.string().describe(\"Absolute memory path.\"),\n    content: z.string().optional().describe(\"Memory content.\"),\n    description: z.string().optional().describe(\"Memory retrieval description.\"),\n    source_type: z.string().optional().describe(\"Entry writer type.\"),\n    create_time: z.string().optional().describe(\"Entry creation timestamp.\"),\n    update_time: z.string().optional().describe(\"Entry update timestamp.\"),\n  })\n  .loose()\n  .describe(\"Databricks managed memory entry.\");\n\nexport type ManagedMemoryEntry = z.infer<typeof ManagedMemoryEntrySchema>;\n\nconst SearchMemoryResponseSchema = z\n  .object({\n    managed_memory_entries: z\n      .array(ManagedMemoryEntrySchema)\n      .optional()\n      .describe(\"Compatibility list of matching entries.\"),\n    results: z\n      .array(\n        z\n          .object({\n            managed_memory_entry: ManagedMemoryEntrySchema.describe(\"Matching memory entry.\"),\n            score: z.number().optional().describe(\"BM25 relevance score.\"),\n          })\n          .loose(),\n      )\n      .optional()\n      .describe(\"Ranked memory search results.\"),\n  })\n  .loose()\n  .describe(\"Databricks managed memory search response.\");\n\nconst ListMemoryResponseSchema = z\n  .object({\n    managed_memory_entries: z\n      .array(ManagedMemoryEntrySchema)\n      .optional()\n      .describe(\"Managed memory entries in this page.\"),\n    next_page_token: z.string().optional().describe(\"Next page token.\"),\n  })\n  .loose()\n  .describe(\"Page of Databricks managed memory entries.\");\n\n/** One managed-memory search result with its optional backend score. */\nexport interface ManagedMemorySearchResult {\n  readonly entry: ManagedMemoryEntry;\n  readonly score?: number;\n}\n\n/** Thin REST client for actor-scoped Databricks Agent Memory operations. */\nexport class ManagedAgentMemoryClient {\n  readonly memoryStore: string;\n\n  constructor(\n    private readonly client: WorkspaceClient,\n    options: ResolvedDatabricksMemoryOptions,\n  ) {\n    this.memoryStore = options.memoryStore;\n  }\n\n  async available(signal?: AbortSignal): Promise<boolean> {\n    try {\n      await this.client.apiClient.request(\n        {\n          path: `/api/2.0/agents/memory-stores/${encodeURIComponent(this.memoryStore)}`,\n          method: \"GET\",\n          headers: new Headers({ accept: \"application/json\" }),\n          raw: false,\n        },\n        signal ? databricks.toContext(signal) : undefined,\n      );\n      return true;\n    } catch (error) {\n      if (errorUtils.errorContext(error).hasStatusCode(403, 404)) return false;\n      throw error;\n    }\n  }\n\n  async searchMemory(input: {\n    actorId: string;\n    query: string;\n    limit: number;\n    signal?: AbortSignal;\n  }): Promise<ManagedMemorySearchResult[]> {\n    const response = SearchMemoryResponseSchema.parse(\n      await this.client.apiClient.request(\n        {\n          path: `/api/2.0/agents/memory-stores/${encodeURIComponent(this.memoryStore)}/entries:search`,\n          method: \"POST\",\n          headers: new Headers({\n            accept: \"application/json\",\n            \"content-type\": \"application/json\",\n          }),\n          raw: false,\n          payload: {\n            actor_id: input.actorId,\n            query: input.query,\n            page_size: input.limit,\n          },\n        },\n        input.signal ? databricks.toContext(input.signal) : undefined,\n      ),\n    );\n    if (response.results) {\n      return response.results.map((result) => ({\n        entry: result.managed_memory_entry,\n        ...(result.score === undefined ? {} : { score: result.score }),\n      }));\n    }\n    return (response.managed_memory_entries ?? []).map((entry) => ({ entry }));\n  }\n\n  async saveMemory(input: {\n    actorId: string;\n    path: string;\n    content: string;\n    description?: string;\n    signal?: AbortSignal;\n  }): Promise<ManagedMemoryEntry> {\n    const existing = (await this.listMemoryEntries(input))[0];\n    if (existing?.name) {\n      return this.updateMemory(existing as ManagedMemoryEntry & { name: string }, input);\n    }\n    try {\n      return await this.createMemory(input);\n    } catch (error) {\n      if (!errorUtils.errorContext(error).hasStatusCode(409)) throw error;\n      const raced = (await this.listMemoryEntries(input))[0];\n      if (!raced?.name) throw error;\n      return this.updateMemory(raced as ManagedMemoryEntry & { name: string }, input);\n    }\n  }\n\n  private async createMemory(input: {\n    actorId: string;\n    path: string;\n    content: string;\n    description?: string;\n    signal?: AbortSignal;\n  }): Promise<ManagedMemoryEntry> {\n    return ManagedMemoryEntrySchema.parse(\n      await this.client.apiClient.request(\n        {\n          path: `/api/2.0/agents/memory-stores/${encodeURIComponent(this.memoryStore)}/entries`,\n          method: \"POST\",\n          headers: new Headers({\n            accept: \"application/json\",\n            \"content-type\": \"application/json\",\n          }),\n          raw: false,\n          payload: {\n            actor_id: input.actorId,\n            path: input.path,\n            content: input.content,\n            ...(input.description ? { description: input.description } : {}),\n            source_type: \"MANAGED_MEMORY_ENTRY_SOURCE_TYPE_AGENT\",\n          },\n        },\n        input.signal ? databricks.toContext(input.signal) : undefined,\n      ),\n    );\n  }\n\n  private async listMemoryEntries(input: {\n    actorId: string;\n    path: string;\n    signal?: AbortSignal;\n  }): Promise<ManagedMemoryEntry[]> {\n    const response = ListMemoryResponseSchema.parse(\n      await this.client.apiClient.request(\n        {\n          path: `/api/2.0/agents/memory-stores/${encodeURIComponent(this.memoryStore)}/entries`,\n          method: \"GET\",\n          headers: new Headers({ accept: \"application/json\" }),\n          query: {\n            actor_id: input.actorId,\n            path: input.path,\n            page_size: 100,\n          },\n          raw: false,\n        },\n        input.signal ? databricks.toContext(input.signal) : undefined,\n      ),\n    );\n    return (response.managed_memory_entries ?? []).filter((entry) => entry.path === input.path);\n  }\n\n  private async updateMemory(\n    current: ManagedMemoryEntry & { name: string },\n    input: {\n      actorId: string;\n      path: string;\n      content: string;\n      description?: string;\n      signal?: AbortSignal;\n    },\n  ): Promise<ManagedMemoryEntry> {\n    const headers = new Headers({\n      accept: \"application/json\",\n      \"content-type\": \"application/json\",\n    });\n    await this.client.config.authenticate(headers);\n    const response = await fetch(\n      new URL(\n        `/api/2.0/agents/${current.name\n          .split(\"/\")\n          .map((part) => encodeURIComponent(part))\n          .join(\"/\")}?update_mask=content,description`,\n        (await this.client.config.getHost()).toString(),\n      ),\n      {\n        method: \"PATCH\",\n        headers,\n        body: JSON.stringify({\n          actor_id: input.actorId,\n          path: input.path,\n          content: input.content,\n          ...(input.description ? { description: input.description } : {}),\n        }),\n        ...(input.signal ? { signal: input.signal } : {}),\n      },\n    );\n    const body = await response.json().catch(() => undefined);\n    if (!response.ok) {\n      throw Object.assign(\n        new Error(`Databricks Agent Memory request failed (${response.status})`),\n        { statusCode: response.status, response: body },\n      );\n    }\n    return ManagedMemoryEntrySchema.parse(body);\n  }\n}\n"]}

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

@@ -0,0 +1,3 @@
+export * as client from "./client.ts";
+export { ManagedMemoryEntrySchema, ManagedAgentMemoryClient } from "./client.ts";
+export type { ManagedMemoryEntry, ManagedMemorySearchResult } from "./client.ts";

package/lib/src/databricks/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 client from "./client.js";
+export { ManagedMemoryEntrySchema, ManagedAgentMemoryClient } from "./client.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZGF0YWJyaWNrcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxPQUFPLEtBQUssTUFBTSxNQUFNLGFBQWEsQ0FBQztBQUN0QyxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxhQUFhLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBHRU5FUkFURUQgYnkgcHJvamVuIHdhdGNoIC0gRE8gTk9UIEVESVQuXG4vLyBSZWdlbmVyYXRlZCBmcm9tIHRoZSBleHBvcnRpbmcgbW9kdWxlcyBpbiAuL3NyYy5cbi8vIEhhbmQgZWRpdHMgYXJlIG92ZXJ3cml0dGVuIG9uIHRoZSBuZXh0IHdhdGNoOyB0aGlzIGZpbGUgaXMgcmVhZC1vbmx5LlxuXG5leHBvcnQgKiBhcyBjbGllbnQgZnJvbSBcIi4vY2xpZW50LnRzXCI7XG5leHBvcnQgeyBNYW5hZ2VkTWVtb3J5RW50cnlTY2hlbWEsIE1hbmFnZWRBZ2VudE1lbW9yeUNsaWVudCB9IGZyb20gXCIuL2NsaWVudC50c1wiO1xuZXhwb3J0IHR5cGUgeyBNYW5hZ2VkTWVtb3J5RW50cnksIE1hbmFnZWRNZW1vcnlTZWFyY2hSZXN1bHQgfSBmcm9tIFwiLi9jbGllbnQudHNcIjtcbiJdfQ==