@tangle-network/agent-knowledge 19.1.5 → 20.0.0

package/dist/index-BhvSH4E4.d.ts

@@ -0,0 +1,512 @@
+import { k as SourceRecord } from "./types-BekdNwGD.js";
+import { c as AgentMemoryWriteInput, d as RetrievalHoldoutCallContext, f as RetrievalHoldoutConfig, h as RetrievalHoldoutResult, i as AgentMemoryHit, l as AgentMemoryWriteResult, m as RetrievalHoldoutEvent, o as AgentMemoryScope, r as AgentMemoryContext, s as AgentMemorySearchOptions, t as AgentMemoryAdapter, u as RetrievalHoldoutBypassReason } from "./types-BWV_Fvp7.js";
+import { ToolDefinition } from "@tangle-network/agent-interface";
+import { z } from "zod";
+import { OffPolicyTrajectory } from "@tangle-network/agent-eval/rl";
+//#region src/memory/adapter.d.ts
+declare function defaultGetMemoryContext(adapter: Pick<AgentMemoryAdapter, 'search'>, query: string, options?: AgentMemorySearchOptions): Promise<AgentMemoryContext>;
+declare function renderMemoryContext(hits: AgentMemoryHit[]): string;
+//#endregion
+//#region src/memory/branch.d.ts
+type AgentMemoryVisibility = 'private' | 'team' | 'shared';
+type AgentMemoryBranchLifetime = 'resumable' | 'attempt';
+interface AgentMemorySharingPolicy {
+  read: readonly AgentMemoryVisibility[];
+  write: AgentMemoryVisibility;
+}
+interface AgentMemoryJournalEntry {
+  sequence: number;
+  input: AgentMemoryWriteInput;
+  result: AgentMemoryWriteResult;
+}
+interface AgentMemoryBranchSnapshot {
+  branchId: string;
+  lifetime: AgentMemoryBranchLifetime;
+  parentBranchId?: string;
+  adapterId: string;
+  policy: AgentMemorySharingPolicy;
+  baseScope: AgentMemoryScope;
+  journal: readonly AgentMemoryJournalEntry[];
+  digest: `sha256:${string}`;
+}
+interface AgentMemoryBranch extends AgentMemoryAdapter {
+  readonly branchId: string;
+  readonly lifetime: AgentMemoryBranchLifetime;
+  readonly parentBranchId?: string;
+  readonly policy: AgentMemorySharingPolicy;
+  snapshot(): Promise<AgentMemoryBranchSnapshot>;
+  fork(options: {
+    branchId: string;
+    adapter?: AgentMemoryAdapter;
+    policy?: AgentMemorySharingPolicy;
+    baseScope?: AgentMemoryScope;
+    lifetime?: AgentMemoryBranchLifetime;
+  }): Promise<AgentMemoryBranch>;
+}
+interface CreateAgentMemoryBranchOptions {
+  adapter: AgentMemoryAdapter;
+  branchId: string;
+  parentBranchId?: string;
+  policy?: AgentMemorySharingPolicy;
+  baseScope?: AgentMemoryScope;
+  /** Attempt branches use a new ID after a process restart and cannot bind persisted state. */
+  lifetime?: AgentMemoryBranchLifetime;
+  /** Rebind a persisted branch whose external memory is still present. */
+  snapshot?: AgentMemoryBranchSnapshot;
+  /** Optional exact logical scopes allowed to write, used by crash-safe experiments. */
+  allowedWriteScopes?: readonly AgentMemoryScope[];
+}
+interface ForkAgentMemoryBranchSnapshotOptions {
+  snapshot: AgentMemoryBranchSnapshot;
+  adapter: AgentMemoryAdapter;
+  branchId: string;
+  policy?: AgentMemorySharingPolicy;
+  baseScope?: AgentMemoryScope;
+  lifetime?: AgentMemoryBranchLifetime;
+}
+/**
+ * Isolates one candidate branch and records accepted writes for durable resume
+ * or replay into a child branch, including a child backed by another provider.
+ */
+declare function createAgentMemoryBranch(options: CreateAgentMemoryBranchOptions): AgentMemoryBranch;
+/** Replays a durable journal into a fresh provider branch. */
+declare function forkAgentMemoryBranchSnapshot(options: ForkAgentMemoryBranchSnapshotOptions): Promise<AgentMemoryBranch>;
+//#endregion
+//#region src/memory/graphiti.d.ts
+interface GraphitiMcpClientLike {
+  callTool(request: {
+    name: string;
+    arguments?: Record<string, unknown>;
+  }): Promise<unknown>;
+}
+interface GraphitiMemoryAdapterOptions {
+  client: GraphitiMcpClientLike;
+  id?: string;
+  /** Stable server/deployment identity for cache-key helpers. Never put credentials here. */
+  backendRef?: string;
+  defaultScope?: AgentMemoryScope;
+  consistency?: 'queued' | 'visible';
+  ingestionTimeoutMs?: number;
+  pollIntervalMs?: number;
+  /** Maximum episodes inspected to prove a queued write became visible. */
+  episodeScanLimit?: number;
+  provenanceEpisodeLimit?: number;
+  search?: readonly ('facts' | 'nodes')[];
+  toolNames?: Partial<GraphitiToolNames>;
+}
+interface GraphitiToolNames {
+  addMemory: string;
+  searchFacts: string;
+  searchNodes: string;
+  getEpisodes: string;
+  clearGraph: string;
+}
+/** Connects the official Graphiti MCP server without coupling to its Python internals. */
+declare function createGraphitiMemoryAdapter(options: GraphitiMemoryAdapterOptions): AgentMemoryAdapter;
+declare function graphitiMemoryAdapterIdentity(options: Pick<GraphitiMemoryAdapterOptions, 'id' | 'consistency' | 'ingestionTimeoutMs' | 'pollIntervalMs' | 'episodeScanLimit' | 'provenanceEpisodeLimit' | 'search' | 'toolNames' | 'defaultScope'> & {
+  backendRef: string;
+}): string;
+//#endregion
+//#region src/memory/hindsight.d.ts
+/** Transport owns endpoint selection and authentication; paths are always bank-bound here. */
+interface HindsightClientLike {
+  request(input: {
+    method: 'GET' | 'POST';
+    path: string;
+    body?: unknown;
+    signal: AbortSignal;
+  }): Promise<{
+    status: number;
+    body: unknown;
+  }>;
+}
+interface HindsightMemoryAdapterOptions {
+  client: HindsightClientLike;
+  /** Stable deployment identity, never a credential. Changing it changes every bank identity. */
+  backendRef: string;
+  branchId: string;
+  requestTimeoutMs?: number;
+  ingestionTimeoutMs?: number;
+  pollIntervalMs?: number;
+  maxTextChars?: number;
+  recallMaxTokens?: number;
+}
+declare class HindsightOperationUnknownError extends Error {
+  readonly bankId: string;
+  readonly operationId: string;
+  readonly documentId: string;
+  constructor(bankId: string, operationId: string, documentId: string, options?: ErrorOptions);
+}
+/** Dedicated bank identity includes the entire logical scope, including the existing branch partition. */
+declare function hindsightMemoryBankId(input: {
+  backendRef: string;
+  branchId: string;
+  scope: AgentMemoryScope;
+}): string;
+/** Hindsight 0.10.2 adapter. Snapshots remain accepted-input journals, never provider database snapshots. */
+declare function createHindsightMemoryAdapter(options: HindsightMemoryAdapterOptions): AgentMemoryAdapter;
+//#endregion
+//#region src/memory/holdout.d.ts
+/**
+ * Deterministic uniform [0,1) for assignment draws. The sha256 key derivation is ours — it makes
+ * every draw replayable from the logged keys alone (design rule D5) — while the generator core is
+ * the substrate's `mulberry32` (@tangle-network/agent-eval statistics vocabulary), seeded with the
+ * top 32 bits of the digest, so the statistical machinery is reused rather than forked.
+ */
+declare function deterministicRng(key: string): number;
+/**
+ * Value-hash of the knobs that DEFINE the experiment (epsilon + watchlist, order-independent).
+ * Everything else on the config (callbacks, attribution stamps, privacy flags) does not change
+ * which assignments are drawn, so it stays out of the hash.
+ */
+declare function retrievalHoldoutConfigHash(config: Pick<RetrievalHoldoutConfig, 'epsilon' | 'watchlist'>): string;
+/**
+ * Pure per-call holdout: takes post-filter hits, returns delivered hits plus the log event
+ * and the next session state. Suppression only removes items (no backfill), and it happens
+ * before rendering so a drop session's context is byte-identical to a natural smaller retrieval.
+ */
+declare function applyRetrievalHoldout(hits: AgentMemoryHit[], config: RetrievalHoldoutConfig, ctx?: RetrievalHoldoutCallContext): RetrievalHoldoutResult;
+/**
+ * Logs a holdout event for adapter context paths that answer WITHOUT going through the
+ * search→render seam (Neo4j short-term conversation context, raw-string getContext results),
+ * so a consumer with a holdout configured still sees every call and the fraction-under-experiment
+ * denominator stays honest instead of silently losing these calls. No suppression is applied:
+ * dropping is only meaningful for retrieved memory hits, never for conversation context.
+ */
+declare function emitRetrievalHoldoutBypass(hits: AgentMemoryHit[], config: RetrievalHoldoutConfig, ctx: Omit<RetrievalHoldoutCallContext, 'session'>, bypassReason: RetrievalHoldoutBypassReason): RetrievalHoldoutEvent;
+/**
+ * Clears all sticky-session state. For test isolation and experiment-epoch boundaries;
+ * sessions in flight afterwards re-draw deterministically (same rng keys), so with the default
+ * rng a reset is invisible in the logs unless eligibility sets changed in between.
+ */
+declare function resetRetrievalHoldoutRegistry(): void;
+/**
+ * Convenience wrapper that threads session state internally, keyed by the VALUE of the
+ * experiment-defining knobs (configHash = epsilon + sorted watchlist) plus sessionId, so a fresh
+ * config object per call — the natural pattern when options are built inline — keeps full
+ * stickiness. Distinct experiments never share session state; two config objects with the same
+ * epsilon/watchlist are the same experiment by definition.
+ */
+declare function applySessionStickyRetrievalHoldout(hits: AgentMemoryHit[], config: RetrievalHoldoutConfig, ctx?: Omit<RetrievalHoldoutCallContext, 'session'>): RetrievalHoldoutResult;
+/** Aggregated view of one session's holdout exposure — the randomization unit of this design. */
+interface RetrievalHoldoutSessionSummary {
+  /** `${configHash}:${sessionIdHash}` — the trajectory's runId. */
+  runId: string;
+  configHash: string;
+  sessionIdHash: string;
+  sessionHoldout: boolean;
+  sessionTargetId: string | null;
+  /** Item actually suppressed in this session (equals sessionTargetId when a drop occurred). */
+  droppedId: string | null;
+  /** |watchlist ∩ E| at the session's first intersecting randomized call; 0 when never intersecting. */
+  firstCandidateCount: number;
+  /** Randomized retrieval calls observed for this session. */
+  callCount: number;
+  /** Adapter bypass calls observed for this session (logged, never randomized). */
+  bypassCallCount: number;
+  /** Session-level probability of the OBSERVED assignment under the behavior policy. */
+  behaviorProb: number;
+  /** True when the session's events disagree on arm or target (e.g. registry eviction re-draw). */
+  mixedExposure: boolean;
+  /** Present only on sessions surfaced in `excluded` rather than converted. */
+  exclusionReason?: 'mixed-exposure' | 'no-randomized-calls';
+}
+interface RetrievalHoldoutOffPolicyOptions {
+  /**
+   * Realized outcome PER SESSION, keyed by sessionIdHash — the session is the randomization
+   * unit, so rewards are per session, never per call. A missing entry for an included session
+   * throws: silently dropping unscored sessions would corrupt the estimator's denominator, so
+   * filter events to scored sessions upstream instead.
+   */
+  rewards: Record<string, number>;
+  /**
+   * Target-policy probability of the session's observed assignment. Default models the
+   * always-deliver-in-full policy: 1 for full-delivery sessions, 0 for drop sessions.
+   */
+  targetProb?: (session: RetrievalHoldoutSessionSummary) => number;
+  /**
+   * Reward-model prediction for the observed assignment. Supply this together
+   * with `vHatTarget`; both estimates must come from evaluation data outside
+   * this session.
+   */
+  qHatChosen?: (session: RetrievalHoldoutSessionSummary) => number | null;
+  /** Expected reward-model value under the target policy. */
+  vHatTarget?: (session: RetrievalHoldoutSessionSummary) => number | null;
+}
+interface RetrievalHoldoutOffPolicyResult {
+  /** One trajectory per (configHash, sessionIdHash), never per call. */
+  trajectories: OffPolicyTrajectory[];
+  /** 1:1 with `trajectories` (same order): the diagnostic view of each converted session. */
+  sessions: RetrievalHoldoutSessionSummary[];
+  /** Sessions not converted because exposure was mixed or retrieval was bypassed. */
+  excluded: RetrievalHoldoutSessionSummary[];
+  /** Events with no sessionIdHash: outside session randomization, cannot join a reward. */
+  unattributableEvents: number;
+}
+/**
+ * Maps retrieval-dropout events onto one `OffPolicyTrajectory` per session for use with
+ * `inverseProbabilityWeighting`, `selfNormalizedImportanceWeighting`, or `doublyRobust`.
+ * Randomization occurs once per session: the arm is selected with P(dropout) = epsilon and
+ * the sticky target is drawn once,
+ * uniformly over watchlist ∩ E at the session's first intersecting call.
+ *
+ * Session-level action space and behavior probabilities (they sum to 1 by construction):
+ * - full delivery: `1 - epsilon`;
+ * - drop candidate i of k = |watchlist ∩ E_first|: `epsilon / k` each (the draw event's logged
+ *   `dropPropensity`);
+ * - sessions whose eligibility sets never intersect the watchlist: probability 1, because full
+ *   delivery was certain in either arm.
+ *
+ * Per-call events are repeated observations WITHIN one session-level randomization; per-call
+ * IPW is statistically invalid for this design (per-call "propensities" imply an action
+ * distribution summing to more than 1 and bias IPS downward). Calls where the sticky target is
+ * absent from E, and adapter bypass calls, fold into the session summary (callCount /
+ * bypassCallCount) instead of generating independent propensities.
+ *
+ * Join contract: `rewards` is keyed by `sessionIdHash` (sha256(sessionId) first 16 hex; compute
+ * the same prefix over the outcome table's session ids, or log with
+ * `includePlaintextIdentifiers: true` and join on raw ids upstream). Events are grouped per
+ * (configHash, sessionIdHash) so different experiment configs are never pooled. Mixed-exposure
+ * sessions (arm or target disagreement, e.g. after registry eviction) are excluded from the
+ * trajectories and surfaced in `excluded` for analysis.
+ */
+declare function toOffPolicyTrajectory(events: RetrievalHoldoutEvent[], options: RetrievalHoldoutOffPolicyOptions): RetrievalHoldoutOffPolicyResult;
+//#endregion
+//#region src/memory/lifecycle.d.ts
+declare const DEFAULT_MEMORY_CLEANUP_TIMEOUT_MS = 180000;
+declare class AgentMemoryLifecycleTimeoutError extends Error {
+  readonly operation: string;
+  readonly timeoutMs: number;
+  constructor(operation: string, timeoutMs: number);
+}
+declare class AgentMemoryLifecycleUnsafeError extends Error {
+  readonly operation: string;
+  readonly priorTimeout: AgentMemoryLifecycleTimeoutError;
+  constructor(operation: string, priorTimeout: AgentMemoryLifecycleTimeoutError);
+}
+declare function resolveMemoryCleanupTimeoutMs(value: number | undefined, label: string): number;
+declare function runBoundedMemoryLifecycle<T>(input: {
+  operation: string;
+  timeoutMs: number;
+  /** Prevent later operations from using the same client while timed-out work may still be running. */
+  resource?: object;
+  /** Cooperatively cancel provider work before reporting a timeout. */
+  abortController?: AbortController;
+  /** Stop waiting when the owning operation is cancelled. */
+  signal?: AbortSignal;
+  /** Let active work settle after cancellation before marking its resource unsafe. */
+  cancellationTimeoutMs?: number;
+  run(): Promise<T> | T;
+}): Promise<T>;
+declare function memoryRecoveryDelayMs(adapter: AgentMemoryAdapter): number;
+declare function sleepForMemoryRecovery(delayMs: number, assertOwned: () => Promise<void>, timeoutMs?: number, operation?: string, signal?: AbortSignal): Promise<void>;
+declare function createMemoryExecutionPool(limit: number): {
+  run<T>(operation: () => Promise<T>): Promise<T>;
+};
+//#endregion
+//#region src/memory/mem0.d.ts
+type Mem0ClientMode = 'hosted' | 'oss';
+interface Mem0Message {
+  role: 'user' | 'assistant';
+  content: string;
+}
+interface Mem0EntityOptions {
+  userId?: string;
+  agentId?: string;
+  runId?: string;
+}
+interface Mem0SearchOptions {
+  filters?: Record<string, unknown>;
+  topK?: number;
+  threshold?: number;
+  rerank?: boolean;
+  showExpired?: boolean;
+}
+interface Mem0HostedClient {
+  add: (messages: Mem0Message[], options: Mem0EntityOptions & {
+    appId?: string;
+    metadata?: Record<string, unknown>;
+    infer?: boolean;
+  }) => Promise<unknown>;
+  search: (query: string, options: Mem0SearchOptions & {
+    latestOnly?: boolean;
+  }) => Promise<unknown>;
+  getAll?: (options: {
+    filters?: Record<string, unknown>;
+    page?: number;
+    pageSize?: number;
+    latestOnly?: boolean;
+    showExpired?: boolean;
+  }) => Promise<unknown>;
+  delete?: (memoryId: string) => Promise<unknown>;
+}
+interface Mem0OssClient {
+  add: (messages: Mem0Message[], options: Mem0EntityOptions & {
+    metadata?: Record<string, unknown>;
+    filters?: Record<string, unknown>;
+    infer?: boolean;
+  }) => Promise<unknown>;
+  search: (query: string, options: Mem0SearchOptions) => Promise<unknown>;
+  getAll?: (options: {
+    filters?: Record<string, unknown>;
+    topK?: number;
+    showExpired?: boolean;
+  }) => Promise<unknown>;
+  delete?: (memoryId: string) => Promise<unknown>;
+}
+interface Mem0MemoryAdapterBaseOptions {
+  id?: string;
+  infer?: boolean;
+  rerank?: boolean;
+  /** Bounds delayed-delete visibility checks and abandoned hosted-write recovery waits. */
+  ingestionTimeoutMs?: number;
+  pollIntervalMs?: number;
+  /** Stable deployment/account identity for cache-key helpers. Never put credentials here. */
+  backendRef?: string;
+  defaultScope?: AgentMemoryScope;
+}
+interface Mem0HostedMemoryAdapterOptions extends Mem0MemoryAdapterBaseOptions {
+  client: Mem0HostedClient;
+  mode: 'hosted';
+  appId?: string;
+  latestOnly?: boolean;
+}
+interface Mem0OssMemoryAdapterOptions extends Mem0MemoryAdapterBaseOptions {
+  client: Mem0OssClient;
+  mode: 'oss';
+  appId?: never;
+  latestOnly?: never;
+}
+type Mem0MemoryAdapterOptions = Mem0HostedMemoryAdapterOptions | Mem0OssMemoryAdapterOptions;
+/** Connects both the hosted Mem0 client and the open-source `Memory` class. */
+declare function createMem0MemoryAdapter(options: Mem0MemoryAdapterOptions): AgentMemoryAdapter;
+/** Stable identity useful for dispatch/cache keys without exposing client credentials. */
+declare function mem0MemoryAdapterIdentity(options: Pick<Mem0MemoryAdapterOptions, 'mode' | 'id' | 'appId' | 'infer' | 'rerank' | 'latestOnly' | 'ingestionTimeoutMs' | 'pollIntervalMs' | 'defaultScope'> & {
+  backendRef: string;
+}): string;
+//#endregion
+//#region src/memory/neo4j.d.ts
+interface Neo4jAgentMemoryAdapterOptions {
+  client: object;
+  /** Match the transport passed to the official MemoryClient. */
+  transport: 'rest' | 'bridge';
+  /** Use Neo4j's whole-conversation context instead of query-based search. */
+  contextMode?: 'search' | 'native';
+  id?: string;
+  /** Assert that the client owns disposable external state for this exact branch. */
+  branchId?: string;
+}
+declare function createNeo4jAgentMemoryAdapter(options: Neo4jAgentMemoryAdapterOptions): AgentMemoryAdapter;
+//#endregion
+//#region src/memory/schemas.d.ts
+declare const AgentMemoryKindSchema: z.ZodEnum<{
+  entity: "entity";
+  fact: "fact";
+  message: "message";
+  observation: "observation";
+  preference: "preference";
+  "reasoning-trace": "reasoning-trace";
+}>;
+declare const AgentMemoryScopeSchema: z.ZodObject<{
+  tenantId: z.ZodOptional<z.ZodString>;
+  userId: z.ZodOptional<z.ZodString>;
+  agentId: z.ZodOptional<z.ZodString>;
+  teamId: z.ZodOptional<z.ZodString>;
+  runId: z.ZodOptional<z.ZodString>;
+  sessionId: z.ZodOptional<z.ZodString>;
+  namespace: z.ZodOptional<z.ZodString>;
+  tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+declare const AgentMemoryHitSchema: z.ZodObject<{
+  id: z.ZodString;
+  uri: z.ZodString;
+  kind: z.ZodEnum<{
+    entity: "entity";
+    fact: "fact";
+    message: "message";
+    observation: "observation";
+    preference: "preference";
+    "reasoning-trace": "reasoning-trace";
+  }>;
+  text: z.ZodString;
+  title: z.ZodOptional<z.ZodString>;
+  score: z.ZodOptional<z.ZodNumber>;
+  normalizedScore: z.ZodOptional<z.ZodNumber>;
+  confidence: z.ZodOptional<z.ZodNumber>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  validUntil: z.ZodOptional<z.ZodString>;
+  lastVerifiedAt: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const AgentMemoryWriteInputSchema: z.ZodObject<{
+  kind: z.ZodEnum<{
+    entity: "entity";
+    fact: "fact";
+    message: "message";
+    observation: "observation";
+    preference: "preference";
+    "reasoning-trace": "reasoning-trace";
+  }>;
+  text: z.ZodString;
+  id: z.ZodOptional<z.ZodString>;
+  title: z.ZodOptional<z.ZodString>;
+  role: z.ZodOptional<z.ZodEnum<{
+    assistant: "assistant";
+    system: "system";
+    tool: "tool";
+    user: "user";
+  }>>;
+  entityName: z.ZodOptional<z.ZodString>;
+  entityType: z.ZodOptional<z.ZodString>;
+  category: z.ZodOptional<z.ZodString>;
+  predicate: z.ZodOptional<z.ZodString>;
+  subject: z.ZodOptional<z.ZodString>;
+  object: z.ZodOptional<z.ZodString>;
+  confidence: z.ZodOptional<z.ZodNumber>;
+  scope: z.ZodOptional<z.ZodObject<{
+    tenantId: z.ZodOptional<z.ZodString>;
+    userId: z.ZodOptional<z.ZodString>;
+    agentId: z.ZodOptional<z.ZodString>;
+    teamId: z.ZodOptional<z.ZodString>;
+    runId: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    namespace: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  }, z.core.$strip>>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+//#endregion
+//#region src/memory/source-record.d.ts
+declare function memoryHitToSourceRecord(hit: AgentMemoryHit, options?: {
+  now?: () => Date;
+  scope?: AgentMemoryScope;
+}): SourceRecord;
+declare function memoryWriteResultToSourceRecord(result: AgentMemoryWriteResult, text: string, options?: {
+  now?: () => Date;
+  scope?: AgentMemoryScope;
+}): SourceRecord;
+//#endregion
+//#region src/memory/tools.d.ts
+interface PlayMemoryRetrievalReceipt {
+  branchId: string;
+  adapterId: string;
+  actorId: string;
+  query: string;
+  context: AgentMemoryContext;
+  receiptDigest: `sha256:${string}`;
+}
+interface CreatePlayMemoryToolsOptions {
+  branch: AgentMemoryBranch;
+  actorId: string;
+  /** Persist through the host's existing record owner before acknowledging a write. */
+  onCheckpoint(snapshot: AgentMemoryBranchSnapshot): Promise<void> | void;
+  recordRetrieval?(receipt: PlayMemoryRetrievalReceipt): Promise<void> | void;
+  /** Optional transport prefix; tool suffixes remain memory_recall and memory_record. */
+  namePrefix?: string;
+  maxTextChars?: number;
+  maxResults?: number;
+}
+declare function createPlayMemoryTools(options: CreatePlayMemoryToolsOptions): ToolDefinition[];
+//#endregion
+export { AgentMemoryVisibility as $, RetrievalHoldoutSessionSummary as A, HindsightOperationUnknownError as B, createMemoryExecutionPool as C, sleepForMemoryRecovery as D, runBoundedMemoryLifecycle as E, resetRetrievalHoldoutRegistry as F, GraphitiToolNames as G, hindsightMemoryBankId as H, retrievalHoldoutConfigHash as I, AgentMemoryBranch as J, createGraphitiMemoryAdapter as K, toOffPolicyTrajectory as L, applySessionStickyRetrievalHoldout as M, deterministicRng as N, RetrievalHoldoutOffPolicyOptions as O, emitRetrievalHoldoutBypass as P, AgentMemorySharingPolicy as Q, HindsightClientLike as R, DEFAULT_MEMORY_CLEANUP_TIMEOUT_MS as S, resolveMemoryCleanupTimeoutMs as T, GraphitiMcpClientLike as U, createHindsightMemoryAdapter as V, GraphitiMemoryAdapterOptions as W, AgentMemoryBranchSnapshot as X, AgentMemoryBranchLifetime as Y, AgentMemoryJournalEntry as Z, Mem0OssMemoryAdapterOptions as _, memoryWriteResultToSourceRecord as a, renderMemoryContext as at, AgentMemoryLifecycleTimeoutError as b, AgentMemoryScopeSchema as c, createNeo4jAgentMemoryAdapter as d, CreateAgentMemoryBranchOptions as et, Mem0ClientMode as f, Mem0OssClient as g, Mem0MemoryAdapterOptions as h, memoryHitToSourceRecord as i, defaultGetMemoryContext as it, applyRetrievalHoldout as j, RetrievalHoldoutOffPolicyResult as k, AgentMemoryWriteInputSchema as l, Mem0HostedMemoryAdapterOptions as m, PlayMemoryRetrievalReceipt as n, createAgentMemoryBranch as nt, AgentMemoryHitSchema as o, Mem0HostedClient as p, graphitiMemoryAdapterIdentity as q, createPlayMemoryTools as r, forkAgentMemoryBranchSnapshot as rt, AgentMemoryKindSchema as s, CreatePlayMemoryToolsOptions as t, ForkAgentMemoryBranchSnapshotOptions as tt, Neo4jAgentMemoryAdapterOptions as u, createMem0MemoryAdapter as v, memoryRecoveryDelayMs as w, AgentMemoryLifecycleUnsafeError as x, mem0MemoryAdapterIdentity as y, HindsightMemoryAdapterOptions as z };
+//# sourceMappingURL=index-BhvSH4E4.d.ts.map

package/dist/index-BhvSH4E4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BhvSH4E4.d.ts","names":[],"sources":["../src/memory/adapter.ts","../src/memory/branch.ts","../src/memory/graphiti.ts","../src/memory/hindsight.ts","../src/memory/holdout.ts","../src/memory/lifecycle.ts","../src/memory/mem0.ts","../src/memory/neo4j.ts","../src/memory/schemas.ts","../src/memory/source-record.ts","../src/memory/tools.ts"],"mappings":"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"}

package/dist/index-OAxtm6is.d.ts

@@ -0,0 +1,9 @@
+import { t as AgentMemoryAdapter } from "./types-BWV_Fvp7.js";
+//#region src/benchmarks/adapters.d.ts
+declare function createNoopMemoryBenchmarkAdapter(id?: string): AgentMemoryAdapter;
+declare function createInMemoryBenchmarkAdapter(options?: {
+  id?: string;
+}): AgentMemoryAdapter;
+//#endregion
+export { createNoopMemoryBenchmarkAdapter as n, createInMemoryBenchmarkAdapter as t };
+//# sourceMappingURL=index-OAxtm6is.d.ts.map

package/dist/index-OAxtm6is.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-OAxtm6is.d.ts","names":[],"sources":["../src/benchmarks/adapters.ts"],"mappings":";;iBASgB,iCAAiC,cAAmB;iBAuBpD,+BAA+B;EAAW;IAAqB"}