@neo4j-labs/agent-memory 0.3.0

package/dist/integrations/strands.d.ts

@@ -0,0 +1,239 @@
+import { SessionManager, ConversationManager, ConversationManagerReduceOptions, LocalAgent, SnapshotStorage, SnapshotLocation, Snapshot, SnapshotManifest } from '@strands-agents/sdk';
+import { M as MemoryClient } from '../client-DSqbWQoa.js';
+import '../index-qfRrdQNP.js';
+
+/**
+ * Strands Agents SDK integration — three orthogonal surfaces, exposed
+ * through a single subpath.
+ *
+ *   1. {@link Neo4jSessionStorage} — implements `SnapshotStorage` so
+ *      Strands' `SessionManager` persists session state into a NAMS
+ *      conversation. Hybrid mapping: messages from each snapshot land as
+ *      real `Message` graph nodes via `addMessage`; the rest of the
+ *      framework's per-snapshot state is stashed losslessly in synthetic
+ *      Strands marker messages on that same conversation.
+ *
+ *   2. {@link Neo4jConversationManager} — a `ConversationManager`
+ *      subclass that delegates `reduce()` to an inner manager
+ *      (defaults to `SlidingWindowConversationManager`) AND registers
+ *      a `BeforeInvocationEvent` hook that prepends three-tier context
+ *      (reflections + observations from `getContext()`) to every model
+ *      call. Layered, not replacing — recent-history trimming still
+ *      behaves the way the inner manager defines.
+ *
+ *   3. {@link registerReasoningHooks} — wires Strands hook events to
+ *      our reasoning subclient. Each invocation opens a `ReasoningStep`;
+ *      each tool call records against that step.
+ *
+ *   {@link connectMemoryToAgent} bundles all three for the common case.
+ *
+ * Strands lives in `devDependencies` only — every import below is a
+ * type-only import, erased at compile time. The published
+ * `dist/integrations/strands.js` has no runtime reference to
+ * `@strands-agents/sdk`, so users without Strands installed pay zero
+ * bundle cost.
+ *
+ * @example
+ * ```ts
+ * import { Agent } from "@strands-agents/sdk";
+ * import { MemoryClient } from "@neo4j-labs/agent-memory";
+ * import { connectMemoryToAgent } from "@neo4j-labs/agent-memory/integrations/strands";
+ *
+ * const memory = new MemoryClient();
+ * const conv = await memory.shortTerm.createConversation({ userId: "alice" });
+ *
+ * const agent = new Agent({
+ *   ...await connectMemoryToAgent(memory, { conversationId: conv.id }),
+ *   model,
+ *   tools: [...],
+ * });
+ *
+ * await agent.invoke("Tell me about graph databases.");
+ * ```
+ */
+
+/** Options shared by every public entrypoint in this module. */
+interface StrandsIntegrationOptions {
+    /**
+     * NAMS Conversation id to wire to. Required by the convenience factory and
+     * by individual exports that need correlation across invocations.
+     */
+    conversationId: string;
+    /** Include reflections from `getContext()` in prompt injection. Default: true. */
+    includeReflections?: boolean;
+    /** Include observations from `getContext()` in prompt injection. Default: true. */
+    includeObservations?: boolean;
+}
+/** Options for {@link Neo4jConversationManager}. */
+interface Neo4jConversationManagerOptions extends Pick<StrandsIntegrationOptions, "conversationId" | "includeReflections" | "includeObservations"> {
+    /**
+     * Inner `ConversationManager` to delegate `reduce()` to. When omitted,
+     * defaults to `SlidingWindowConversationManager` (constructed lazily so
+     * Strands' module is only loaded if the manager is actually used).
+     */
+    inner?: ConversationManager;
+}
+/** Options for {@link registerReasoningHooks}. */
+interface ReasoningHooksOptions {
+    /** NAMS Conversation id to attribute reasoning steps and tool calls to. */
+    conversationId: string;
+}
+/**
+ * Returns true if a message is one of our synthetic state/manifest
+ * markers. Exported so consumers walking the conversation can filter
+ * them out of UI rendering. See `SYNTHETIC_MESSAGE_PREFIXES` for the
+ * canonical prefix list.
+ *
+ * Recognizes ANY role — the storage role used by the integration is
+ * `"user"`, but older saves may have used `"system"`. We match on the
+ * content prefix alone for resilience.
+ */
+declare function isSyntheticStrandsMessage(message: {
+    role: string;
+    content: string;
+}): boolean;
+/**
+ * Canonical content prefixes used for synthetic messages. Consumers
+ * (chat UIs, message-list renderers, Cypher queries) can filter on
+ * these to skip the Strands-internal state messages.
+ */
+declare const SYNTHETIC_MESSAGE_PREFIXES: readonly ["__strands_state__:", "__strands_manifest__:"];
+/**
+ * Implements Strands' `SnapshotStorage` against a NAMS `MemoryClient`.
+ *
+ * One Strands session = one NAMS Conversation (keyed by `location.sessionId`).
+ * Snapshots are versions within that conversation:
+ *
+ * - Real conversation messages from `snapshot.data.messages` land as real
+ *   `Message` graph nodes via `addMessage` (so entity extraction, search,
+ *   and the graph view all work on them).
+ * - Non-message snapshot state (Strands' `data` minus `messages`, plus
+ *   `appData`, plus the manifest) is persisted as synthetic `role: "user"`
+ *   messages whose content carries both a marker prefix and a
+ *   base64-encoded JSON blob. NAMS exposes `POST /conversations/{id}/messages`
+ *   as the only documented conversation-scoped write, so this approach
+ *   stays within the documented API surface.
+ *
+ * Consumers walking the message list (chat UIs, Cypher queries) MUST
+ * filter synthetic messages with {@link isSyntheticStrandsMessage}.
+ * Strands itself never sees them: {@link Neo4jSessionStorage.loadSnapshot}
+ * strips them from the reconstructed Snapshot before handing back to
+ * `SessionManager`.
+ *
+ * Auth errors propagate — Strands needs to know if the backing store is
+ * unreachable. Transient errors propagate too; Strands' own retry
+ * semantics (in `SessionManager`) apply.
+ */
+declare class Neo4jSessionStorage implements SnapshotStorage {
+    private readonly memory;
+    constructor(memory: MemoryClient);
+    saveSnapshot(params: {
+        location: SnapshotLocation;
+        snapshotId: string;
+        isLatest: boolean;
+        snapshot: Snapshot;
+    }): Promise<void>;
+    loadSnapshot(params: {
+        location: SnapshotLocation;
+        snapshotId?: string;
+    }): Promise<Snapshot | null>;
+    listSnapshotIds(params: {
+        location: SnapshotLocation;
+        limit?: number;
+        startAfter?: string;
+    }): Promise<string[]>;
+    deleteSession(params: {
+        sessionId: string;
+    }): Promise<void>;
+    loadManifest(params: {
+        location: SnapshotLocation;
+    }): Promise<SnapshotManifest>;
+    saveManifest(params: {
+        location: SnapshotLocation;
+        manifest: SnapshotManifest;
+    }): Promise<void>;
+    /**
+     * Scan a conversation's message list and parse any state markers into
+     * blobs, in original order. Matches on the content prefix alone for
+     * resilience against role normalization on the service side.
+     */
+    private readStateBlobs;
+    /** Same idea, for manifest markers. */
+    private readManifestBlobs;
+    /**
+     * Pull the message list out of `snapshot.data.messages` (the canonical
+     * Strands layout), find ones not yet present on the conversation
+     * (excluding our synthetic markers), and persist them via `addMessage`.
+     * Returns the number of new messages written.
+     */
+    private extractAndPersistMessages;
+}
+/**
+ * Layered ConversationManager: context-injection hook + inner manager.
+ *
+ * The inner manager (defaults to `SlidingWindowConversationManager`) owns
+ * trimming and summarization. This manager registers a
+ * `BeforeInvocationEvent` hook that prepends reflections + observations from
+ * `getContext()` as system messages, BEFORE the inner manager's reduce
+ * logic runs.
+ *
+ * Lazily constructs an inner manager on first `initAgent` invocation so
+ * importing this module doesn't load Strands' runtime unless the manager
+ * is actually used.
+ */
+declare class Neo4jConversationManager {
+    private readonly memory;
+    private readonly options;
+    readonly name = "neo4j:context-injection";
+    /**
+     * Mirrored from Strands' `ConversationManager` to satisfy duck-typing
+     * at compile time. We never set it — context injection has no notion
+     * of a compression threshold.
+     */
+    protected readonly _compressionThreshold: number | undefined;
+    private inner;
+    constructor(memory: MemoryClient, options: Neo4jConversationManagerOptions);
+    reduce(opts: ConversationManagerReduceOptions): Promise<boolean>;
+    initAgent(agent: LocalAgent): Promise<void>;
+    private ensureInner;
+    private injectContext;
+}
+/**
+ * Wire reasoning capture onto a Strands `HookRegistry`.
+ *
+ * - `BeforeInvocationEvent` → `reasoning.recordStep` (opens a step; stashes
+ *   step id on `event.invocationState`).
+ * - `AfterInvocationEvent` → re-records the step with a `result` field
+ *   (best-effort; we don't have a public `updateStep` API yet, so the
+ *   second write supplements rather than mutates).
+ * - `BeforeToolCallEvent` → `reasoning.recordToolCall` with status
+ *   `pending`. Strands tool-call id → our tool-call id map stashed on
+ *   `invocationState`.
+ * - `AfterToolCallEvent` → updates the recorded tool call's status.
+ *
+ * All capture is best-effort: every reasoning write is wrapped in try/catch
+ * and silently swallowed on failure. Reasoning capture must never break the
+ * agent run.
+ */
+declare function registerReasoningHooks(memory: MemoryClient, agent: LocalAgent, options: ReasoningHooksOptions): Promise<void>;
+/** Result of {@link connectMemoryToAgent} — spread directly into `new Agent({ ... })`. */
+interface ConnectMemoryToAgentResult {
+    sessionManager: SessionManager;
+    /**
+     * Typed as `StrandsConversationManager` (the abstract base) so callers
+     * can spread the result straight into `new Agent({ ... })` without
+     * casts. At runtime this is a {@link Neo4jConversationManager}.
+     */
+    conversationManager: ConversationManager;
+}
+/**
+ * One-shot helper that wires the SessionStorage, the ConversationManager, and
+ * (lazily) the reasoning hooks against a NAMS `MemoryClient`. Spread the
+ * return value into `new Agent({ ... })`.
+ *
+ * Reasoning hooks attach themselves automatically when the conversation
+ * manager's `initAgent` runs — no separate registration step required.
+ */
+declare function connectMemoryToAgent(memory: MemoryClient, options: StrandsIntegrationOptions): Promise<ConnectMemoryToAgentResult>;
+
+export { type ConnectMemoryToAgentResult, Neo4jConversationManager, type Neo4jConversationManagerOptions, Neo4jSessionStorage, type ReasoningHooksOptions, SYNTHETIC_MESSAGE_PREFIXES, type StrandsIntegrationOptions, connectMemoryToAgent, isSyntheticStrandsMessage, registerReasoningHooks };

package/dist/integrations/strands.js

@@ -0,0 +1,413 @@
+// src/integrations/strands.ts
+var _strandsModule = null;
+async function loadStrands() {
+  if (!_strandsModule) {
+    _strandsModule = await import('@strands-agents/sdk');
+  }
+  return _strandsModule;
+}
+var STATE_PREFIX = "__strands_state__:";
+var MANIFEST_PREFIX = "__strands_manifest__:";
+var SYNTHETIC_ROLE = "user";
+function encodeBlob(blob) {
+  return base64Encode(JSON.stringify(blob));
+}
+function decodeBlob(content, prefix) {
+  if (!content.startsWith(prefix)) return null;
+  const payload = content.slice(prefix.length);
+  try {
+    return JSON.parse(base64Decode(payload));
+  } catch {
+    return null;
+  }
+}
+function base64Encode(s) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(s, "utf8").toString("base64");
+  }
+  const g = globalThis;
+  if (typeof g.btoa === "function") {
+    const bytes = new TextEncoder().encode(s);
+    let bin = "";
+    for (const b of bytes) bin += String.fromCharCode(b);
+    return g.btoa(bin);
+  }
+  throw new Error("No base64 encoder available in this runtime");
+}
+function base64Decode(b64) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(b64, "base64").toString("utf8");
+  }
+  const g = globalThis;
+  if (typeof g.atob === "function") {
+    const bin = g.atob(b64);
+    const bytes = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+    return new TextDecoder().decode(bytes);
+  }
+  throw new Error("No base64 decoder available in this runtime");
+}
+function isSyntheticStrandsMessage(message) {
+  return message.content.startsWith(STATE_PREFIX) || message.content.startsWith(MANIFEST_PREFIX);
+}
+var SYNTHETIC_MESSAGE_PREFIXES = [STATE_PREFIX, MANIFEST_PREFIX];
+var Neo4jSessionStorage = class {
+  constructor(memory) {
+    this.memory = memory;
+  }
+  async saveSnapshot(params) {
+    const { location, snapshotId, isLatest, snapshot } = params;
+    const conversationId = location.sessionId;
+    const existingConversation = await this.memory.shortTerm.getConversation(conversationId);
+    await this.extractAndPersistMessages(conversationId, snapshot, existingConversation.messages);
+    const strippedSnapshot = stripMessagesFromSnapshot(snapshot);
+    const blob = {
+      snapshotId,
+      isLatest,
+      snapshot: strippedSnapshot,
+      savedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const previous = findLastStateBlobForSnapshotId(
+      this.readStateBlobs(existingConversation.messages),
+      snapshotId
+    );
+    if (previous && sameStateBlob(previous, blob)) return;
+    await this.memory.shortTerm.addMessage(
+      conversationId,
+      SYNTHETIC_ROLE,
+      `${STATE_PREFIX}${encodeBlob(blob)}`
+    );
+  }
+  async loadSnapshot(params) {
+    const conversationId = params.location.sessionId;
+    const conv = await this.memory.shortTerm.getConversation(conversationId);
+    const stateBlobs = this.readStateBlobs(conv.messages);
+    if (stateBlobs.length === 0) return null;
+    let blob;
+    if (params.snapshotId) {
+      blob = findLastStateBlobForSnapshotId(stateBlobs, params.snapshotId);
+    } else {
+      blob = [...stateBlobs].reverse().find((b) => b.isLatest) ?? stateBlobs[stateBlobs.length - 1];
+    }
+    if (!blob) return null;
+    const realMessages = conv.messages.filter((m) => !isSyntheticStrandsMessage(m)).map(toStrandsMessage);
+    return mergeMessagesIntoSnapshot(blob.snapshot, realMessages);
+  }
+  async listSnapshotIds(params) {
+    const conv = await this.memory.shortTerm.getConversation(params.location.sessionId);
+    const stateBlobs = this.readStateBlobs(conv.messages);
+    const seen = /* @__PURE__ */ new Set();
+    const ids = [];
+    for (const blob of stateBlobs) {
+      if (seen.has(blob.snapshotId)) continue;
+      seen.add(blob.snapshotId);
+      ids.push(blob.snapshotId);
+    }
+    let start = 0;
+    if (params.startAfter) {
+      const idx = ids.indexOf(params.startAfter);
+      start = idx >= 0 ? idx + 1 : 0;
+    }
+    return ids.slice(start, params.limit ? start + params.limit : void 0);
+  }
+  async deleteSession(params) {
+    await this.memory.shortTerm.deleteConversation(params.sessionId);
+  }
+  async loadManifest(params) {
+    const conv = await this.memory.shortTerm.getConversation(params.location.sessionId);
+    const blobs = this.readManifestBlobs(conv.messages);
+    const matching = blobs.filter((b) => b.scopeId === params.location.scopeId);
+    return matching[matching.length - 1]?.manifest ?? defaultManifest();
+  }
+  async saveManifest(params) {
+    const blob = {
+      scopeId: params.location.scopeId,
+      manifest: params.manifest,
+      savedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.memory.shortTerm.addMessage(
+      params.location.sessionId,
+      SYNTHETIC_ROLE,
+      `${MANIFEST_PREFIX}${encodeBlob(blob)}`
+    );
+  }
+  // --- Internals ------------------------------------------------------------
+  /**
+   * Scan a conversation's message list and parse any state markers into
+   * blobs, in original order. Matches on the content prefix alone for
+   * resilience against role normalization on the service side.
+   */
+  readStateBlobs(messages) {
+    const blobs = [];
+    for (const msg of messages) {
+      const blob = decodeBlob(msg.content, STATE_PREFIX);
+      if (blob) blobs.push(blob);
+    }
+    return blobs;
+  }
+  /** Same idea, for manifest markers. */
+  readManifestBlobs(messages) {
+    const blobs = [];
+    for (const msg of messages) {
+      const blob = decodeBlob(msg.content, MANIFEST_PREFIX);
+      if (blob) blobs.push(blob);
+    }
+    return blobs;
+  }
+  /**
+   * Pull the message list out of `snapshot.data.messages` (the canonical
+   * Strands layout), find ones not yet present on the conversation
+   * (excluding our synthetic markers), and persist them via `addMessage`.
+   * Returns the number of new messages written.
+   */
+  async extractAndPersistMessages(conversationId, snapshot, existingMessages) {
+    const messages = pickStrandsMessages(snapshot);
+    if (messages.length === 0) return 0;
+    const seen = new Set(
+      (existingMessages ?? (await this.memory.shortTerm.getConversation(conversationId)).messages).filter((m) => !isSyntheticStrandsMessage(m)).map((m) => `${m.role}::${m.content}`)
+    );
+    let writes = 0;
+    for (const msg of messages) {
+      const text = strandsMessageToText(msg);
+      const key = `${msg.role}::${text}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      await this.memory.shortTerm.addMessage(conversationId, msg.role, text);
+      writes++;
+    }
+    return writes;
+  }
+};
+var Neo4jConversationManager = class {
+  constructor(memory, options) {
+    this.memory = memory;
+    this.options = options;
+  }
+  name = "neo4j:context-injection";
+  /**
+   * Mirrored from Strands' `ConversationManager` to satisfy duck-typing
+   * at compile time. We never set it — context injection has no notion
+   * of a compression threshold.
+   */
+  _compressionThreshold = void 0;
+  // We can't extend Strands' abstract class via a static `extends` clause
+  // because Strands is a dynamic import — the base class identity isn't
+  // known at module-load time. Instead we *delegate* to a lazily-built
+  // inner manager and implement the abstract surface explicitly. Strands
+  // duck-types on shape, not on instanceof, so this works.
+  inner = null;
+  async reduce(opts) {
+    const inner = await this.ensureInner();
+    return inner.reduce(opts);
+  }
+  async initAgent(agent) {
+    const inner = await this.ensureInner();
+    inner.initAgent(agent);
+    const strands = await loadStrands();
+    agent.addHook(
+      strands.BeforeInvocationEvent,
+      async (event) => {
+        await this.injectContext(event);
+      }
+    );
+  }
+  async ensureInner() {
+    if (this.inner) return this.inner;
+    if (this.options.inner) {
+      this.inner = this.options.inner;
+      return this.inner;
+    }
+    const strands = await loadStrands();
+    const Ctor = strands.SlidingWindowConversationManager;
+    this.inner = new Ctor();
+    return this.inner;
+  }
+  async injectContext(event) {
+    try {
+      const ctx = await this.memory.shortTerm.getContext(this.options.conversationId);
+      const prepend = [];
+      const includeReflections = this.options.includeReflections ?? true;
+      const includeObservations = this.options.includeObservations ?? true;
+      if (includeReflections && ctx.reflections.length > 0) {
+        for (const r of ctx.reflections) {
+          prepend.push(contextInjectionMessage(`[reflection] ${r.content}`));
+        }
+      }
+      if (includeObservations && ctx.observations.length > 0) {
+        for (const o of ctx.observations) {
+          prepend.push(contextInjectionMessage(`[observation] ${o.content}`));
+        }
+      }
+      if (prepend.length === 0) return;
+      const agentLike = event.agent;
+      agentLike.messages = [...prepend, ...agentLike.messages];
+    } catch {
+    }
+  }
+};
+var INVOCATION_STEP_ID_KEY = "__neo4jReasoningStepId";
+var TOOL_CALL_MAP_KEY = "__neo4jReasoningToolCalls";
+async function registerReasoningHooks(memory, agent, options) {
+  return registerReasoningHooksOnAgent(memory, agent, options);
+}
+async function registerReasoningHooksOnAgent(memory, agent, options) {
+  const strands = await loadStrands();
+  const conversationId = options.conversationId;
+  agent.addHook(strands.BeforeInvocationEvent, async (event) => {
+    try {
+      const step = await memory.reasoning.recordStep({
+        conversationId,
+        reasoning: "agent invocation started",
+        actionTaken: "invoke_agent"
+      });
+      event.invocationState[INVOCATION_STEP_ID_KEY] = step.id;
+      event.invocationState[TOOL_CALL_MAP_KEY] = /* @__PURE__ */ new Map();
+    } catch {
+    }
+  });
+  agent.addHook(strands.AfterInvocationEvent, async (event) => {
+    try {
+      const stepId = event.invocationState[INVOCATION_STEP_ID_KEY];
+      if (typeof stepId !== "string") return;
+      await memory.reasoning.recordStep({
+        conversationId,
+        reasoning: `agent invocation completed (step ${stepId})`,
+        actionTaken: "invocation_complete",
+        result: "ok"
+      });
+    } catch {
+    }
+  });
+  agent.addHook(strands.BeforeToolCallEvent, async (event) => {
+    try {
+      const stepId = event.invocationState[INVOCATION_STEP_ID_KEY];
+      if (typeof stepId !== "string") return;
+      const toolCall = await memory.reasoning.recordToolCall(
+        stepId,
+        event.toolUse.name,
+        event.toolUse.input,
+        { status: "pending" }
+      );
+      const map = event.invocationState[TOOL_CALL_MAP_KEY];
+      if (map instanceof Map) {
+        map.set(event.toolUse.toolUseId, toolCall.id);
+      }
+    } catch {
+    }
+  });
+  agent.addHook(strands.AfterToolCallEvent, async (event) => {
+    try {
+      const stepId = event.invocationState[INVOCATION_STEP_ID_KEY];
+      if (typeof stepId !== "string") return;
+      await memory.reasoning.recordToolCall(
+        stepId,
+        event.toolUse.name,
+        event.toolUse.input,
+        {
+          status: event.error ? "failure" : "success",
+          error: event.error?.message
+        }
+      );
+    } catch {
+    }
+  });
+}
+async function connectMemoryToAgent(memory, options) {
+  const strands = await loadStrands();
+  const sessionManager = new strands.SessionManager({
+    sessionId: options.conversationId,
+    storage: { snapshot: new Neo4jSessionStorage(memory) }
+  });
+  const baseManager = new Neo4jConversationManager(memory, options);
+  const originalInit = baseManager.initAgent.bind(baseManager);
+  baseManager.initAgent = async (agent) => {
+    await originalInit(agent);
+    await registerReasoningHooksOnAgent(memory, agent, {
+      conversationId: options.conversationId
+    });
+  };
+  return {
+    sessionManager,
+    conversationManager: baseManager
+  };
+}
+function defaultManifest() {
+  return {
+    schemaVersion: "1.0",
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function pickStrandsMessages(snapshot) {
+  const data = snapshot.data;
+  if (!data || !Array.isArray(data.messages)) return [];
+  return data.messages;
+}
+function stripMessagesFromSnapshot(snapshot) {
+  const nextData = { ...snapshot.data ?? {} };
+  delete nextData.messages;
+  return { ...snapshot, data: nextData };
+}
+function mergeMessagesIntoSnapshot(blob, messages) {
+  return {
+    ...blob,
+    data: { ...blob.data ?? {}, messages }
+  };
+}
+function strandsMessageToText(msg) {
+  const blocks = msg.content ?? [];
+  if (!Array.isArray(blocks)) return "";
+  const parts = [];
+  for (const b of blocks) {
+    if (b && typeof b === "object") {
+      const block = b;
+      if (typeof block.text === "string") {
+        parts.push(block.text);
+      } else if (block.type) {
+        parts.push(`[${block.type}]`);
+      }
+    }
+  }
+  return parts.join("\n");
+}
+function toStrandsMessage(m) {
+  return {
+    role: m.role,
+    content: [{ text: m.content }]
+  };
+}
+function contextInjectionMessage(text) {
+  return {
+    role: "system",
+    content: [{ text }]
+  };
+}
+function sameStateBlob(a, b) {
+  return a.snapshotId === b.snapshotId && a.isLatest === b.isLatest && jsonLikeEqual(a.snapshot, b.snapshot);
+}
+function findLastStateBlobForSnapshotId(blobs, snapshotId) {
+  for (let i = blobs.length - 1; i >= 0; i--) {
+    if (blobs[i]?.snapshotId === snapshotId) return blobs[i];
+  }
+  return void 0;
+}
+function jsonLikeEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== typeof b) return false;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((value, index) => jsonLikeEqual(value, b[index]));
+  }
+  if (a && b && typeof a === "object" && typeof b === "object") {
+    const aRecord = a;
+    const bRecord = b;
+    const aKeys = Object.keys(aRecord);
+    const bKeys = Object.keys(bRecord);
+    if (aKeys.length !== bKeys.length) return false;
+    return aKeys.every((key) => key in bRecord && jsonLikeEqual(aRecord[key], bRecord[key]));
+  }
+  return false;
+}
+
+export { Neo4jConversationManager, Neo4jSessionStorage, SYNTHETIC_MESSAGE_PREFIXES, connectMemoryToAgent, isSyntheticStrandsMessage, registerReasoningHooks };
+//# sourceMappingURL=strands.js.map
+//# sourceMappingURL=strands.js.map