@mongodb-js/agent-engine-sdk-memory 0.11.3

package/dist/http/client_adapter.js

@@ -0,0 +1,452 @@
+/**
+ * `MemoryRuntime` + `MemoryCrudClient` implemented over agent-engine-sdk's
+ * `MemoryClient`.
+ *
+ * The facade needs two seams (the workflow runtime and the CRUD conveniences);
+ * `MemoryClient` already owns the HTTP mechanics both share — URL building, the
+ * transport-extras/dynamic-header hooks, the bounded 5xx/network retry, and the
+ * 404→null lookup semantics. Rather than reimplement that stack, this adapter is
+ * a thin binding: it fills the empty tenancy the backends stamp (`org_id`/
+ * `project_id` come from the trusted OE execution context or the Gateway API
+ * key), selects the route convention per backend, and translates
+ * `MemoryClient`'s `MemoryHttpError` into the memory package's typed error
+ * hierarchy (which is this package's public API).
+ *
+ * Two `MemoryClient` instances back each adapter: a retrying one for the write
+ * turn and all reads (idempotent — turns carry an idempotency key, reads are
+ * pure) and a non-retrying one for type-specific creates (no idempotency key, so
+ * a retry after the server committed could duplicate the record).
+ */
+import { MemoryClient, MemoryHttpError, } from "@mongodb-js/agent-engine-sdk";
+import { MemoryAuthError, MemoryBadRequestError, MemoryConnectionError, MemoryNotProvisionedError, MemoryNotSupportedError, MemoryRouteNotFoundError, MemoryServerError, } from "../errors.js";
+import { ContextResponseSchema, CreateEpisodicResultSchema, CreateProceduralResultSchema, CreateSemanticResultSchema, CreateTaxonomicResultSchema, CustomMemoryRetrieveResultSchema, CustomMemorySaveResultSchema, MemoryChunkSchema, WriteTurnResultSchema, } from "../models.js";
+/** Error codes the backends use to signal the memory runtime is not yet reachable. */
+const NOT_PROVISIONED_CODES = new Set([
+    "AGENT_NOT_DEPLOYED",
+    "NO_WORKSPACE_ENDPOINT",
+    "PROJECT_RUNTIME_FAILED",
+]);
+const RETRIES = 2; // initial + 2 retries, matching the previous transport
+/** Empty tenancy: the backend stamps the trusted org/project (caller cannot override). */
+const EMPTY_ORG = "";
+const EMPTY_PROJECT = "";
+/** A single `MemoryClient`-backed runtime + CRUD client for the `Memory` facade. */
+export class MemoryClientAdapter {
+    retry;
+    noRetry;
+    projectScoped;
+    constructor(opts) {
+        this.projectScoped = opts.projectScoped;
+        const timeout = opts.timeout ?? 30;
+        const make = (maxRetries) => new MemoryClient(opts.baseUrl, timeout, opts.headers ?? {}, opts.apiPrefix, undefined, opts.requestExtras, maxRetries, opts.routeStyle, opts.fetchImpl);
+        this.retry = make(RETRIES);
+        this.noRetry = make(0);
+    }
+    // ---------------------------------------------------------------------------
+    // Error translation
+    // ---------------------------------------------------------------------------
+    /** Map a `MemoryClient` failure to this package's typed error hierarchy. */
+    mapError(err, coreLoop) {
+        if (!(err instanceof MemoryHttpError)) {
+            // A JSON-parse (SyntaxError from resp.json()) or schema-validation
+            // (ZodError from schema.parse) failure means the backend answered but the
+            // success body was unparseable/invalid — a server-side contract violation,
+            // not a transport failure. Mirror the Python SDK and surface it as a
+            // MemoryServerError rather than a MemoryConnectionError.
+            if (err instanceof SyntaxError ||
+                (err instanceof Error && err.name === "ZodError")) {
+                return new MemoryServerError(String(err), { status: null });
+            }
+            // fetch/timeout — MemoryClient rethrows the raw error after exhausting retries.
+            return new MemoryConnectionError(String(err), { status: null });
+        }
+        const { status, responseText } = err;
+        let code = null;
+        let message = responseText;
+        try {
+            const parsed = JSON.parse(responseText);
+            if (parsed !== null &&
+                typeof parsed === "object" &&
+                !Array.isArray(parsed)) {
+                const body = parsed;
+                code = body.code || null;
+                // `detail` is FastAPI's convention and is what the memory server
+                // returns; without it a structured message surfaces as raw JSON. Only
+                // strings qualify — FastAPI validation errors put a list there.
+                const detail = typeof body.detail === "string" ? body.detail : undefined;
+                message =
+                    body.error ||
+                        body.message ||
+                        detail ||
+                        responseText;
+            }
+        }
+        catch {
+            // Non-JSON body: keep the raw text as the message.
+        }
+        const opts = { status, code, responseText };
+        if (status === 401 || status === 403)
+            return new MemoryAuthError(message, opts);
+        if (code !== null && NOT_PROVISIONED_CODES.has(code))
+            return new MemoryNotProvisionedError(message, opts);
+        if (status === 404 && coreLoop)
+            return this.routeNotFoundError(opts);
+        if (status >= 400 && status < 500)
+            return new MemoryBadRequestError(message, opts);
+        return new MemoryServerError(message, opts);
+    }
+    routeNotFoundError(opts) {
+        const hint = this.projectScoped
+            ? "projectId is set, so the SDK used a project-scoped memory route; if you " +
+                "are targeting a local or direct OE backend, unset projectId (or " +
+                "AGENTIC_MEMORY_PROJECT_ID)"
+            : "projectId is empty, so the SDK used a flat memory route; if you are " +
+                "targeting the hosted Gateway, set projectId (or AGENTIC_MEMORY_PROJECT_ID)";
+        return new MemoryRouteNotFoundError("memory route not found (404). This often means the route shape does not " +
+            `match the backend: ${hint}. It can also mean baseUrl points at the ` +
+            "wrong host.", opts);
+    }
+    // ---------------------------------------------------------------------------
+    // MemoryRuntime
+    // ---------------------------------------------------------------------------
+    async recordTurn(args) {
+        try {
+            const r = await this.retry.writeTurn({
+                sessionId: args.sessionId,
+                role: args.role,
+                orgId: EMPTY_ORG,
+                userId: args.userId,
+                projectId: EMPTY_PROJECT,
+                content: args.content,
+                modelName: args.modelName,
+                toolCalls: args.toolCalls,
+                toolCallId: args.toolCallId,
+                toolName: args.toolName,
+                isError: args.isError,
+                idempotencyKey: args.idempotencyKey,
+            });
+            return WriteTurnResultSchema.parse(r);
+        }
+        catch (e) {
+            throw this.mapError(e, true);
+        }
+    }
+    async buildContext(args) {
+        try {
+            const r = await this.retry.buildContext({
+                query: args.query,
+                sessionId: args.sessionId,
+                orgId: EMPTY_ORG,
+                userId: args.userId,
+                projectId: EMPTY_PROJECT,
+                visibility: args.visibility,
+                metadataFilter: args.metadataFilter,
+                // The facade carries enabled sources as a Set; MemoryClient takes a
+                // sorted array (deterministic wire order).
+                enabledSources: args.enabledSources
+                    ? [...args.enabledSources].sort()
+                    : null,
+                topK: args.topK,
+                maxTokens: args.maxTokens,
+            });
+            return ContextResponseSchema.parse(r);
+        }
+        catch (e) {
+            throw this.mapError(e, true);
+        }
+    }
+    async searchSemantic(args) {
+        try {
+            const rows = await this.retry.fetchSemanticMemories({
+                query: args.query,
+                orgId: EMPTY_ORG,
+                projectId: EMPTY_PROJECT,
+                userId: args.userId,
+                visibility: args.visibility,
+                topK: args.topK,
+            });
+            return rows.map((m) => MemoryChunkSchema.parse(m));
+        }
+        catch (e) {
+            throw this.mapError(e, true);
+        }
+    }
+    async searchEpisodes(args) {
+        try {
+            const rows = await this.retry.fetchEpisodicMemories({
+                query: args.query,
+                orgId: EMPTY_ORG,
+                projectId: EMPTY_PROJECT,
+                userId: args.userId,
+                visibility: args.visibility,
+                sessionId: args.sessionId,
+                topK: args.topK,
+            });
+            return rows.map((m) => MemoryChunkSchema.parse(m));
+        }
+        catch (e) {
+            throw this.mapError(e, true);
+        }
+    }
+    async searchTaxonomic(args) {
+        try {
+            const rows = await this.retry.fetchTaxonomicMemories({
+                query: args.query,
+                orgId: EMPTY_ORG,
+                projectId: EMPTY_PROJECT,
+                domain: args.domain,
+                visibility: args.visibility,
+                topK: args.topK,
+            });
+            return rows.map((m) => MemoryChunkSchema.parse(m));
+        }
+        catch (e) {
+            throw this.mapError(e, true);
+        }
+    }
+    async discoverProcedures(args) {
+        try {
+            return await this.retry.discoverProcedures({
+                query: args.query,
+                orgId: EMPTY_ORG,
+                projectId: EMPTY_PROJECT,
+                userId: args.userId,
+                visibility: args.visibility,
+                tags: args.tags,
+                topK: args.topK,
+                similarityThreshold: args.similarityThreshold,
+                metadataFilter: args.metadataFilter,
+            });
+        }
+        catch (e) {
+            throw this.mapError(e, true);
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // MemoryCrudClient
+    // ---------------------------------------------------------------------------
+    async createSemantic(args) {
+        try {
+            const r = await this.noRetry.createSemantic({
+                label: args.label,
+                text: args.text,
+                orgId: EMPTY_ORG,
+                userId: args.userId,
+                projectId: EMPTY_PROJECT,
+                source: args.source,
+                visibility: args.visibility,
+                agentId: args.agentId,
+                metadata: args.metadata,
+                upsert: args.upsert,
+            });
+            return CreateSemanticResultSchema.parse(r);
+        }
+        catch (e) {
+            throw this.mapError(e, false);
+        }
+    }
+    async getSemantic(args) {
+        try {
+            return await this.retry.getSemantic({
+                orgId: EMPTY_ORG,
+                projectId: EMPTY_PROJECT,
+                label: args.label,
+                userId: args.userId,
+                visibility: args.visibility,
+            });
+        }
+        catch (e) {
+            throw this.mapError(e, false);
+        }
+    }
+    async createEpisodic(args) {
+        try {
+            const r = await this.noRetry.createEpisodic({
+                title: args.title,
+                content: args.content,
+                summaryText: args.summaryText ?? "",
+                orgId: EMPTY_ORG,
+                userId: args.userId,
+                sessionId: args.sessionId,
+                projectId: EMPTY_PROJECT,
+                visibility: args.visibility,
+                agentId: args.agentId,
+                participants: args.participants,
+                tags: args.tags,
+                metadata: args.metadata,
+            });
+            return CreateEpisodicResultSchema.parse(r);
+        }
+        catch (e) {
+            throw this.mapError(e, false);
+        }
+    }
+    async listEpisodic(args) {
+        try {
+            return await this.retry.listEpisodic({
+                orgId: EMPTY_ORG,
+                projectId: EMPTY_PROJECT,
+                userId: args.userId,
+                sessionId: args.sessionId,
+                visibility: args.visibility,
+                limit: args.limit,
+            });
+        }
+        catch (e) {
+            throw this.mapError(e, false);
+        }
+    }
+    async createTaxonomic(args) {
+        try {
+            const r = await this.noRetry.createTaxonomic({
+                domain: args.domain,
+                term: args.term,
+                definition: args.definition,
+                orgId: EMPTY_ORG,
+                userId: args.userId,
+                projectId: EMPTY_PROJECT,
+                relatedTerms: args.relatedTerms,
+                visibility: args.visibility,
+            });
+            return CreateTaxonomicResultSchema.parse(r);
+        }
+        catch (e) {
+            throw this.mapError(e, false);
+        }
+    }
+    async getTaxonomic(args) {
+        try {
+            return await this.retry.getTaxonomic({
+                orgId: EMPTY_ORG,
+                projectId: EMPTY_PROJECT,
+                domain: args.domain,
+                term: args.term,
+                userId: args.userId,
+                visibility: args.visibility,
+            });
+        }
+        catch (e) {
+            throw this.mapError(e, false);
+        }
+    }
+    async getDistinctDomains(args) {
+        try {
+            return await this.retry.getDistinctDomains({
+                orgId: EMPTY_ORG,
+                projectId: EMPTY_PROJECT,
+                visibility: args.visibility,
+            });
+        }
+        catch (e) {
+            throw this.mapError(e, false);
+        }
+    }
+    async createProcedural(args) {
+        if (args.updateExisting) {
+            // The HTTP backends serve only a create route that always creates;
+            // app-bound mode honors updateExisting through its own runtime.
+            throw new MemoryNotSupportedError("updateExisting is not supported by the HTTP memory backends; the create " +
+                "route always creates a new procedure");
+        }
+        try {
+            const r = await this.noRetry.createProcedural({
+                procedure: args.procedure,
+                description: args.description,
+                content: args.content,
+                orgId: EMPTY_ORG,
+                userId: args.userId,
+                projectId: EMPTY_PROJECT,
+                steps: args.steps,
+                resources: args.resources,
+                allowedTools: args.allowedTools,
+                compatibility: args.compatibility,
+                license: args.license,
+                triggerConditions: args.triggerConditions,
+                tags: args.tags,
+                visibility: args.visibility,
+                agentId: args.agentId,
+                extractionSource: args.extractionSource,
+                sourceFormat: args.sourceFormat,
+                sourcePath: args.sourcePath,
+            });
+            return CreateProceduralResultSchema.parse(r);
+        }
+        catch (e) {
+            throw this.mapError(e, false);
+        }
+    }
+    async getProcedural(args) {
+        try {
+            return await this.retry.getProcedural({
+                orgId: EMPTY_ORG,
+                projectId: EMPTY_PROJECT,
+                procedure: args.procedure,
+                userId: args.userId,
+                visibility: args.visibility,
+                includeDeleted: args.includeDeleted,
+            });
+        }
+        catch (e) {
+            throw this.mapError(e, false);
+        }
+    }
+    /**
+     * A bare 404/405 means the platform predates custom-type operations, and a
+     * flag-off gateway rejects with a 400 naming the feature; the server's
+     * unknown-type 404 names the type in a structured body and must pass
+     * through untouched.
+     */
+    mapCustomRouteError(e) {
+        const mapped = this.mapError(e, false);
+        if (mapped instanceof MemoryBadRequestError) {
+            const message = String(mapped.message);
+            if ((mapped.status === 404 || mapped.status === 405) &&
+                !message.includes("unknown custom memory type")) {
+                return new MemoryNotSupportedError("this platform version does not support custom memory types; " +
+                    "save/retrieve requires a platform release with the custom memory " +
+                    "type operations enabled", { cause: mapped });
+            }
+            // The gateway's flag-off rejection reuses the generic INVALID_REQUEST
+            // code, so this message substring is the only stable discriminator for
+            // that 400.
+            if (mapped.status === 400 &&
+                message.includes("custom_memory_types is not enabled")) {
+                return new MemoryNotSupportedError("custom memory types are disabled on this deployment; " +
+                    "save/retrieve requires the custom_memory_types feature to be " +
+                    "enabled", { cause: mapped });
+            }
+        }
+        return mapped;
+    }
+    async createCustom(args) {
+        try {
+            const r = await this.noRetry.createCustom({
+                memoryType: args.memoryType,
+                content: args.content,
+                tags: args.tags,
+                contextualMetadata: args.contextualMetadata,
+            });
+            return CustomMemorySaveResultSchema.parse(r);
+        }
+        catch (e) {
+            throw this.mapCustomRouteError(e);
+        }
+    }
+    async retrieveCustom(args) {
+        try {
+            const r = await this.retry.retrieveCustom({
+                memoryType: args.memoryType,
+                query: args.query,
+                tags: args.tags,
+                topK: args.topK,
+            });
+            return CustomMemoryRetrieveResultSchema.parse(r);
+        }
+        catch (e) {
+            throw this.mapCustomRouteError(e);
+        }
+    }
+    close() {
+        // MemoryClient holds no client to close (native fetch); present for parity.
+    }
+}

package/dist/identity.d.ts

@@ -0,0 +1,31 @@
+/** Identity-resolution algorithm: call arg > bind context > runtime context. */
+import type { MemoryRequestContext } from "./transport.js";
+declare const FIELDS: readonly ["userId", "agentId", "sessionId"];
+type Field = (typeof FIELDS)[number];
+export type ResolvedIdentity = Record<Field, string | null>;
+/**
+ * Resolve identity fields by precedence: call arg > bind ctx > runtime ctx.
+ *
+ * Blank or whitespace-only values are treated as unset at every tier.
+ *
+ * Two optional guards drop tiers for one field each:
+ *
+ * `suppressRuntimeUserId` drops the runtime tier for `userId`. A read asking for
+ * a broad visibility must not borrow the ambient principal as its filter. A
+ * `userId` set by the caller or by bind is deliberate and still applies.
+ *
+ * `suppressInheritedSessionId` drops the bind and runtime tiers for `sessionId`,
+ * so only an explicit call arg applies. A `sessionId` scopes conversation I/O,
+ * not long-term search; episodic search matches it exactly and consolidated
+ * episodic memory is stored without one, so an inherited session matches nothing.
+ */
+export declare function resolveIdentity(args: {
+    callArgs: Partial<Record<Field, string | null | undefined>>;
+    bindCtx?: MemoryRequestContext | null;
+    runtimeCtx?: MemoryRequestContext | null;
+    required?: readonly Field[];
+    suppressRuntimeUserId?: boolean;
+    suppressInheritedSessionId?: boolean;
+}): ResolvedIdentity;
+export {};
+//# sourceMappingURL=identity.d.ts.map

package/dist/identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.d.ts","sourceRoot":"","sources":["../src/identity.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAGhF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAE3D,QAAA,MAAM,MAAM,6CAA8C,CAAC;AAC3D,KAAK,KAAK,GAAG,CAAC,OAAO,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC;AAErC,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC;AAW5D;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE;IACpC,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC,CAAC;IAC5D,OAAO,CAAC,EAAE,oBAAoB,GAAG,IAAI,CAAC;IACtC,UAAU,CAAC,EAAE,oBAAoB,GAAG,IAAI,CAAC;IACzC,QAAQ,CAAC,EAAE,SAAS,KAAK,EAAE,CAAC;IAC5B,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,0BAA0B,CAAC,EAAE,OAAO,CAAC;CACtC,GAAG,gBAAgB,CAgCnB"}

package/dist/identity.js

@@ -0,0 +1,48 @@
+/** Identity-resolution algorithm: call arg > bind context > runtime context. */
+import { MemoryIdentityError } from "./errors.js";
+const FIELDS = ["userId", "agentId", "sessionId"];
+function normalize(value) {
+    // A blank or whitespace-only value carries no identity; treating it as unset
+    // keeps it from satisfying `required` or shadowing a bound value.
+    if (value === null || value === undefined || value.trim() === "") {
+        return null;
+    }
+    return value;
+}
+/**
+ * Resolve identity fields by precedence: call arg > bind ctx > runtime ctx.
+ *
+ * Blank or whitespace-only values are treated as unset at every tier.
+ *
+ * Two optional guards drop tiers for one field each:
+ *
+ * `suppressRuntimeUserId` drops the runtime tier for `userId`. A read asking for
+ * a broad visibility must not borrow the ambient principal as its filter. A
+ * `userId` set by the caller or by bind is deliberate and still applies.
+ *
+ * `suppressInheritedSessionId` drops the bind and runtime tiers for `sessionId`,
+ * so only an explicit call arg applies. A `sessionId` scopes conversation I/O,
+ * not long-term search; episodic search matches it exactly and consolidated
+ * episodic memory is stored without one, so an inherited session matches nothing.
+ */
+export function resolveIdentity(args) {
+    const { callArgs, bindCtx = null, runtimeCtx = null, required = [], suppressRuntimeUserId = false, suppressInheritedSessionId = false, } = args;
+    const resolved = {};
+    for (const field of FIELDS) {
+        let value = normalize(callArgs[field]);
+        const skipInherited = suppressInheritedSessionId && field === "sessionId";
+        if (value === null && bindCtx !== null && !skipInherited) {
+            value = normalize(bindCtx[field]);
+        }
+        const skipRuntime = skipInherited || (suppressRuntimeUserId && field === "userId");
+        if (value === null && runtimeCtx !== null && !skipRuntime) {
+            value = normalize(runtimeCtx[field]);
+        }
+        resolved[field] = value;
+    }
+    const missing = required.filter((field) => resolved[field] === null);
+    if (missing.length > 0) {
+        throw new MemoryIdentityError(`could not resolve required identity field(s): ${missing.join(", ")}`);
+    }
+    return resolved;
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/** @mongodb-js/agent-engine-sdk-memory — unified Memory facade for Atlas Agent Engine. */
+export { Memory, type MemoryOptions } from "./memory.js";
+export { MemorySource, SearchSource, toSearchSource, WriteTurnResultSchema, CreateSemanticResultSchema, CreateEpisodicResultSchema, CreateTaxonomicResultSchema, CreateProceduralResultSchema, CustomMemorySaveResultSchema, RetrievedCustomMemorySchema, CustomMemoryRetrieveResultSchema, MemoryChunkSchema, ContextMetadataSchema, ContextResponseSchema, } from "./models.js";
+export type { JsonValue, WriteTurnResult, CreateSemanticResult, CreateEpisodicResult, CreateTaxonomicResult, CreateProceduralResult, CustomMemorySaveResult, RetrievedCustomMemory, CustomMemoryRetrieveResult, MemoryChunk, ContextMetadata, ContextResponse, } from "./models.js";
+export type { TagScalar, TagMap } from "./tag_syntax.js";
+export type { MemoryRuntime, MemoryCrudClient, MemoryRequestContext, AmbientIdentityRuntime, FetchLike, RequestExtras, } from "./transport.js";
+export { hasAmbientIdentity } from "./transport.js";
+export { resolveIdentity, type ResolvedIdentity } from "./identity.js";
+export { MemoryClientAdapter, type MemoryClientAdapterOptions, } from "./http/client_adapter.js";
+export { MemoryIdentityError, MemoryClientError, MemoryNotSupportedError, MemoryAPIError, MemoryAuthError, MemoryNotProvisionedError, MemoryBadRequestError, MemoryRouteNotFoundError, MemoryServerError, MemoryConnectionError, } from "./errors.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,0FAA0F;AAE1F,OAAO,EAAE,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAKzD,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,cAAc,EACd,qBAAqB,EACrB,0BAA0B,EAC1B,0BAA0B,EAC1B,2BAA2B,EAC3B,4BAA4B,EAC5B,4BAA4B,EAC5B,2BAA2B,EAC3B,gCAAgC,EAChC,iBAAiB,EACjB,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,aAAa,CAAC;AACrB,YAAY,EACV,SAAS,EACT,eAAe,EACf,oBAAoB,EACpB,oBAAoB,EACpB,qBAAqB,EACrB,sBAAsB,EACtB,sBAAsB,EACtB,qBAAqB,EACrB,0BAA0B,EAC1B,WAAW,EACX,eAAe,EACf,eAAe,GAChB,MAAM,aAAa,CAAC;AAErB,YAAY,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzD,YAAY,EACV,aAAa,EACb,gBAAgB,EAChB,oBAAoB,EACpB,sBAAsB,EACtB,SAAS,EACT,aAAa,GACd,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAEpD,OAAO,EAAE,eAAe,EAAE,KAAK,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEvE,OAAO,EACL,mBAAmB,EACnB,KAAK,0BAA0B,GAChC,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,uBAAuB,EACvB,cAAc,EACd,eAAe,EACf,yBAAyB,EACzB,qBAAqB,EACrB,wBAAwB,EACxB,iBAAiB,EACjB,qBAAqB,GACtB,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,9 @@
+/** @mongodb-js/agent-engine-sdk-memory — unified Memory facade for Atlas Agent Engine. */
+export { Memory } from "./memory.js";
+// Copyright 2026 MongoDB, Inc.
+// SPDX-License-Identifier: Apache-2.0
+export { MemorySource, SearchSource, toSearchSource, WriteTurnResultSchema, CreateSemanticResultSchema, CreateEpisodicResultSchema, CreateTaxonomicResultSchema, CreateProceduralResultSchema, CustomMemorySaveResultSchema, RetrievedCustomMemorySchema, CustomMemoryRetrieveResultSchema, MemoryChunkSchema, ContextMetadataSchema, ContextResponseSchema, } from "./models.js";
+export { hasAmbientIdentity } from "./transport.js";
+export { resolveIdentity } from "./identity.js";
+export { MemoryClientAdapter, } from "./http/client_adapter.js";
+export { MemoryIdentityError, MemoryClientError, MemoryNotSupportedError, MemoryAPIError, MemoryAuthError, MemoryNotProvisionedError, MemoryBadRequestError, MemoryRouteNotFoundError, MemoryServerError, MemoryConnectionError, } from "./errors.js";