@tangle-network/agent-knowledge 3.2.1 → 4.0.1

package/dist/chunk-VN2OGUUP.js

@@ -1,851 +0,0 @@
-import {
-  memoryHitToSourceRecord,
-  memoryWriteResultToSourceRecord
-} from "./chunk-XVU5FFQA.js";
-import {
-  sha256,
-  stableId
-} from "./chunk-YMKHCTS2.js";
-
-// src/memory/holdout.ts
-import { randomUUID } from "crypto";
-import { mulberry32 } from "@tangle-network/agent-eval";
-function deterministicRng(key) {
-  return mulberry32(Number.parseInt(sha256(key).slice(0, 8), 16))();
-}
-function canonicalJson(value) {
-  if (typeof value === "bigint") {
-    throw new TypeError("canonicalJson: bigint values are not supported in holdout hashing");
-  }
-  if (value === void 0) return "null";
-  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
-  if (value !== null && typeof value === "object") {
-    const entries = Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`);
-    return `{${entries.join(",")}}`;
-  }
-  return JSON.stringify(value);
-}
-function retrievalHoldoutConfigHash(config) {
-  return sha256(
-    canonicalJson({ epsilon: config.epsilon, watchlist: [...config.watchlist ?? []].sort() })
-  ).slice(0, 16);
-}
-function assertValidHoldoutConfig(config) {
-  const { epsilon, watchlist } = config;
-  if (typeof epsilon !== "number" || !Number.isFinite(epsilon) || epsilon < 0 || epsilon > 1) {
-    throw new Error(`retrieval holdout epsilon must be a number in [0, 1], got ${String(epsilon)}`);
-  }
-  if (watchlist !== void 0 && (!Array.isArray(watchlist) || watchlist.some((id) => typeof id !== "string"))) {
-    throw new Error("retrieval holdout watchlist must be an array of item-id strings");
-  }
-}
-function safeEmit(config, event) {
-  try {
-    config.onEvent(event);
-  } catch (error) {
-    console.error(
-      "[agent-knowledge] retrieval holdout onEvent sink threw; retrieval continues",
-      error
-    );
-  }
-}
-function applyRetrievalHoldout(hits, config, ctx = {}) {
-  assertValidHoldoutConfig(config);
-  const rng = config.rng ?? deterministicRng;
-  const sessionId = ctx.sessionId ?? ctx.scope?.sessionId;
-  const holdoutEligible = typeof sessionId === "string" && sessionId.length > 0;
-  const base = holdoutEventBase(hits, config, ctx);
-  let session;
-  if (holdoutEligible) {
-    const prior = ctx.session?.sessionId === sessionId ? ctx.session : void 0;
-    session = prior ?? {
-      sessionId,
-      callCount: 0,
-      // The epsilon coin depends only on sessionId, so assignment is independent of task
-      // features by construction and exactly replayable (design rules D1 + D5).
-      sessionHoldout: rng(`${sessionId}#holdout`) < config.epsilon,
-      targetId: null,
-      pickPropensity: null
-    };
-    session = { ...session, callCount: session.callCount + 1 };
-  }
-  const watchlistEligible = base.watchlistEligible;
-  if (session?.sessionHoldout && session.targetId === null && watchlistEligible.length > 0) {
-    const candidates = [...watchlistEligible].sort();
-    const index = Math.min(
-      Math.floor(rng(`${session.sessionId}#pick`) * candidates.length),
-      candidates.length - 1
-    );
-    const picked = candidates[index];
-    if (picked !== void 0) {
-      session = { ...session, targetId: picked, pickPropensity: 1 / candidates.length };
-    }
-  }
-  const targetId = session?.sessionHoldout ? session.targetId ?? null : null;
-  const droppedId = targetId !== null && hits.some((hit) => hit.id === targetId) ? targetId : null;
-  const delivered = droppedId === null ? hits : hits.filter((hit) => hit.id !== droppedId);
-  const pickPropensity = session?.sessionHoldout ? session.pickPropensity ?? null : null;
-  const event = {
-    ...base,
-    callIndex: session?.callCount ?? 0,
-    holdoutEligible,
-    sessionHoldout: session?.sessionHoldout ?? false,
-    sessionTargetId: targetId,
-    droppedId,
-    pickPropensity,
-    dropPropensity: pickPropensity !== null ? config.epsilon * pickPropensity : null,
-    deliveredIds: delivered.map((hit) => hit.id)
-  };
-  safeEmit(config, event);
-  return droppedId === null ? { delivered: hits, event, ...session !== void 0 ? { session } : {} } : { delivered, event, ...session !== void 0 ? { session } : {} };
-}
-function holdoutEventBase(hits, config, ctx) {
-  const sessionId = ctx.sessionId ?? ctx.scope?.sessionId;
-  const watchlist = config.watchlist ?? [];
-  const watchlistSet = new Set(watchlist);
-  const plaintext = config.includePlaintextIdentifiers === true;
-  return {
-    v: 1,
-    eventId: randomUUID(),
-    ts: (/* @__PURE__ */ new Date()).toISOString(),
-    ...config.adapterId !== void 0 ? { adapterId: config.adapterId } : {},
-    ...plaintext && sessionId !== void 0 ? { sessionId } : {},
-    ...ctx.taskId !== void 0 ? { taskId: ctx.taskId } : {},
-    ...sessionId !== void 0 ? { sessionIdHash: sha256(sessionId).slice(0, 16) } : {},
-    ...ctx.query !== void 0 ? { queryHash: sha256(ctx.query).slice(0, 16) } : {},
-    ...plaintext && ctx.scope !== void 0 ? { scope: ctx.scope } : {},
-    ...ctx.scope !== void 0 ? { scopeHash: sha256(canonicalJson(ctx.scope)).slice(0, 16) } : {},
-    config: {
-      epsilon: config.epsilon,
-      watchlist: [...watchlist],
-      ...config.configVersion !== void 0 ? { configVersion: config.configVersion } : {}
-    },
-    configHash: retrievalHoldoutConfigHash(config),
-    eligible: hits.map((hit, index) => ({
-      id: hit.id,
-      rank: index + 1,
-      ...typeof (hit.normalizedScore ?? hit.score) === "number" ? { score: hit.normalizedScore ?? hit.score } : {},
-      kind: hit.kind,
-      contentHash: sha256(hit.text).slice(0, 16)
-    })),
-    watchlistEligible: hits.filter((hit) => watchlistSet.has(hit.id)).map((hit) => hit.id),
-    ...config.corpusVersion !== void 0 ? { corpusVersion: config.corpusVersion } : {}
-  };
-}
-function emitRetrievalHoldoutBypass(hits, config, ctx, bypassReason) {
-  assertValidHoldoutConfig(config);
-  const event = {
-    ...holdoutEventBase(hits, config, ctx),
-    callIndex: 0,
-    holdoutEligible: false,
-    sessionHoldout: false,
-    sessionTargetId: null,
-    droppedId: null,
-    pickPropensity: null,
-    dropPropensity: null,
-    deliveredIds: hits.map((hit) => hit.id),
-    bypassReason
-  };
-  safeEmit(config, event);
-  return event;
-}
-var DEFAULT_MAX_TRACKED_SESSIONS = 1e4;
-var sessionRegistry = /* @__PURE__ */ new Map();
-function resetRetrievalHoldoutRegistry() {
-  sessionRegistry.clear();
-}
-function applySessionStickyRetrievalHoldout(hits, config, ctx = {}) {
-  assertValidHoldoutConfig(config);
-  const sessionId = ctx.sessionId ?? ctx.scope?.sessionId;
-  const configHash = retrievalHoldoutConfigHash(config);
-  let sessions = sessionRegistry.get(configHash);
-  if (!sessions) {
-    sessions = /* @__PURE__ */ new Map();
-    sessionRegistry.set(configHash, sessions);
-  }
-  const prior = sessionId !== void 0 ? sessions.get(sessionId) : void 0;
-  const result = applyRetrievalHoldout(hits, config, {
-    ...ctx,
-    ...prior ? { session: prior } : {}
-  });
-  if (sessionId !== void 0 && result.session) {
-    const cap = config.maxTrackedSessions ?? DEFAULT_MAX_TRACKED_SESSIONS;
-    if (!sessions.has(sessionId) && sessions.size >= cap) {
-      const oldest = sessions.keys().next().value;
-      if (oldest !== void 0) sessions.delete(oldest);
-    }
-    sessions.set(sessionId, result.session);
-  }
-  return result;
-}
-function toOffPolicyTrajectory(events, options) {
-  const groups = /* @__PURE__ */ new Map();
-  let unattributableEvents = 0;
-  for (const event of events) {
-    if (event.sessionIdHash === void 0) {
-      unattributableEvents += 1;
-      continue;
-    }
-    const key = `${event.configHash}:${event.sessionIdHash}`;
-    const group = groups.get(key);
-    if (group) group.push(event);
-    else groups.set(key, [event]);
-  }
-  const trajectories = [];
-  const sessions = [];
-  const excluded = [];
-  for (const [runId, group] of groups) {
-    const ordered = [...group].sort((a, b) => a.callIndex - b.callIndex || a.ts.localeCompare(b.ts));
-    const randomized = ordered.filter((event) => event.holdoutEligible);
-    const firstEvent = ordered[0];
-    if (firstEvent?.sessionIdHash === void 0) continue;
-    const base = {
-      runId,
-      configHash: firstEvent.configHash,
-      sessionIdHash: firstEvent.sessionIdHash,
-      callCount: randomized.length,
-      bypassCallCount: ordered.length - randomized.length
-    };
-    const first = randomized[0];
-    if (first === void 0) {
-      excluded.push({
-        ...base,
-        sessionHoldout: false,
-        sessionTargetId: null,
-        droppedId: null,
-        firstCandidateCount: 0,
-        behaviorProb: 1,
-        mixedExposure: false,
-        exclusionReason: "no-randomized-calls"
-      });
-      continue;
-    }
-    const targets = new Set(
-      randomized.map((event) => event.sessionTargetId).filter((target) => target !== null)
-    );
-    const arms = new Set(randomized.map((event) => event.sessionHoldout));
-    const mixedExposure = targets.size > 1 || arms.size > 1;
-    const dropEvent = randomized.find((event) => event.droppedId !== null);
-    const firstIntersecting = randomized.find((event) => event.watchlistEligible.length > 0);
-    const sessionTargetId = dropEvent?.sessionTargetId ?? [...targets][0] ?? null;
-    let behaviorProb;
-    if (dropEvent !== void 0) {
-      if (dropEvent.dropPropensity === null) {
-        throw new Error(`holdout event ${dropEvent.eventId} recorded a drop without dropPropensity`);
-      }
-      behaviorProb = dropEvent.dropPropensity;
-    } else if (!mixedExposure && sessionTargetId !== null) {
-      throw new Error(
-        `holdout session ${base.sessionIdHash} has a drawn target but no drop event: the event batch is missing this session draw call`
-      );
-    } else if (firstIntersecting === void 0) {
-      behaviorProb = 1;
-    } else {
-      behaviorProb = 1 - first.config.epsilon;
-    }
-    const summary = {
-      ...base,
-      sessionHoldout: first.sessionHoldout,
-      sessionTargetId,
-      droppedId: dropEvent?.droppedId ?? null,
-      firstCandidateCount: firstIntersecting ? new Set(firstIntersecting.watchlistEligible).size : 0,
-      behaviorProb,
-      mixedExposure,
-      ...mixedExposure ? { exclusionReason: "mixed-exposure" } : {}
-    };
-    if (mixedExposure) {
-      excluded.push(summary);
-      continue;
-    }
-    const reward = options.rewards[summary.sessionIdHash];
-    if (reward === void 0) {
-      throw new Error(
-        `no reward for session ${summary.sessionIdHash}: filter events to scored sessions before converting`
-      );
-    }
-    trajectories.push({
-      runId,
-      reward,
-      behaviorProb,
-      targetProb: options.targetProb?.(summary) ?? (summary.droppedId === null ? 1 : 0),
-      qHat: options.qHat?.(summary) ?? null
-    });
-    sessions.push(summary);
-  }
-  return { trajectories, sessions, excluded, unattributableEvents };
-}
-
-// src/memory/adapter.ts
-async function defaultGetMemoryContext(adapter, query, options = {}) {
-  const hits = await adapter.search(query, options);
-  const delivered = options.holdout ? applySessionStickyRetrievalHoldout(hits, options.holdout, {
-    query,
-    ...options.scope !== void 0 ? { scope: options.scope } : {},
-    ...options.scope?.tags?.taskId !== void 0 ? { taskId: options.scope.tags.taskId } : {}
-  }).delivered : hits;
-  return {
-    query,
-    hits: delivered,
-    sourceRecords: delivered.map((hit) => memoryHitToSourceRecord(hit, { scope: options.scope })),
-    text: renderMemoryContext(delivered)
-  };
-}
-function renderMemoryContext(hits) {
-  return hits.map((hit, index) => {
-    const label = hit.title ?? `${hit.kind}:${hit.id}`;
-    const score = typeof hit.normalizedScore === "number" ? ` score=${hit.normalizedScore.toFixed(3)}` : "";
-    return [`[${index + 1}] ${label}${score}`, hit.text].join("\n");
-  }).join("\n\n");
-}
-
-// src/memory/neo4j.ts
-function createNeo4jAgentMemoryAdapter(options) {
-  const client = options.client;
-  const id = options.id ?? "neo4j-agent-memory";
-  return {
-    id,
-    async search(query, searchOptions = {}) {
-      const sdkHits = await searchNeo4jMemory(client, query, searchOptions, id);
-      if (sdkHits.length > 0) return sdkHits;
-      const result = await callOptional(
-        client,
-        ["search", "memory_search"],
-        [query, neo4jOptions(searchOptions)]
-      );
-      if (result !== void 0) return normalizeHits(result, searchOptions, id);
-      const context = await callOptional(
-        client,
-        ["getContext", "get_context"],
-        [query, neo4jOptions(searchOptions)]
-      );
-      if (context !== void 0) return normalizeHits(context, searchOptions, id);
-      return [];
-    },
-    async getContext(query, searchOptions = {}) {
-      const shortTerm = nested(client, ["shortTerm", "short_term"], {});
-      const sessionId = searchOptions.scope?.sessionId;
-      if (sessionId) {
-        const conversationContext = await callOptional(
-          shortTerm,
-          ["getContext", "get_context"],
-          [sessionId]
-        );
-        if (conversationContext !== void 0) {
-          const hits2 = normalizeConversationContextHits(conversationContext, searchOptions, id);
-          const text = textFromConversationContext(conversationContext) ?? (typeof conversationContext === "string" ? conversationContext : hits2.length > 0 ? renderHits(hits2) : "");
-          if (searchOptions.holdout) {
-            emitRetrievalHoldoutBypass(
-              hits2,
-              searchOptions.holdout,
-              holdoutBypassContext(query, searchOptions),
-              "short-term-context"
-            );
-          }
-          return {
-            query,
-            text,
-            hits: hits2,
-            sourceRecords: hits2.map(
-              (hit) => memoryHitToSourceRecord(hit, { scope: searchOptions.scope })
-            ),
-            metadata: { adapter: id, rawContext: conversationContext }
-          };
-        }
-      }
-      const result = await callOptional(
-        client,
-        ["getContext", "get_context"],
-        [query, neo4jOptions(searchOptions)]
-      );
-      if (result === void 0) {
-        return defaultGetMemoryContext(
-          {
-            search: async () => {
-              const sdkHits = await searchNeo4jMemory(client, query, searchOptions, id);
-              if (sdkHits.length > 0) return sdkHits;
-              const searchResult = await callOptional(
-                client,
-                ["search", "memory_search"],
-                [query, neo4jOptions(searchOptions)]
-              );
-              return normalizeHits(searchResult, searchOptions, id);
-            }
-          },
-          query,
-          searchOptions
-        );
-      }
-      if (typeof result === "string") {
-        const hit = {
-          id: stableId("mem", `${id}:${query}:${result}`),
-          uri: `memory://${id}/context/${stableId("ctx", query)}`,
-          kind: "fact",
-          text: result,
-          title: "Memory context",
-          normalizedScore: 1
-        };
-        if (searchOptions.holdout) {
-          emitRetrievalHoldoutBypass(
-            [hit],
-            searchOptions.holdout,
-            holdoutBypassContext(query, searchOptions),
-            "raw-string-context"
-          );
-        }
-        return {
-          query,
-          text: result,
-          hits: [hit],
-          sourceRecords: [memoryHitToSourceRecord(hit, { scope: searchOptions.scope })],
-          metadata: { adapter: id }
-        };
-      }
-      const hits = normalizeHits(result, searchOptions, id);
-      if (hits.length > 0)
-        return defaultGetMemoryContext({ search: async () => hits }, query, searchOptions);
-      return defaultGetMemoryContext({ search: async () => [] }, query, searchOptions);
-    },
-    async write(input) {
-      const result = await writeNeo4jMemory(client, input, id);
-      return {
-        ...result,
-        sourceRecord: memoryWriteResultToSourceRecord(result, input.text, { scope: input.scope })
-      };
-    }
-  };
-}
-async function writeNeo4jMemory(client, input, adapterId) {
-  const scope = input.scope ?? {};
-  const sessionId = scope.sessionId ?? input.metadata?.sessionId;
-  let result;
-  if (input.kind === "message") {
-    const shortTerm = nested(client, ["shortTerm", "short_term"], client);
-    result = await callOptional(
-      shortTerm,
-      ["addMessage"],
-      [
-        sessionId,
-        input.role ?? "user",
-        input.text,
-        {
-          metadata: input.metadata,
-          conversationId: sessionId,
-          userId: scope.userId
-        }
-      ]
-    );
-    if (result === void 0) {
-      result = await callRequired(
-        shortTerm,
-        ["add_message"],
-        [
-          {
-            session_id: sessionId,
-            sessionId,
-            role: input.role ?? "user",
-            content: input.text,
-            user_identifier: scope.userId,
-            userIdentifier: scope.userId,
-            metadata: input.metadata
-          }
-        ]
-      );
-    }
-  } else if (input.kind === "entity") {
-    const longTerm = nested(client, ["longTerm", "long_term"], client);
-    result = await callOptional(
-      longTerm,
-      ["addEntity"],
-      [
-        input.entityName ?? input.title ?? input.text,
-        input.entityType ?? "ENTITY",
-        neo4jEntityOptions(input)
-      ]
-    );
-    if (result === void 0) {
-      result = await callRequired(
-        longTerm,
-        ["add_entity"],
-        [
-          input.entityName ?? input.title ?? input.text,
-          input.entityType ?? "ENTITY",
-          neo4jWriteOptions(input)
-        ]
-      );
-    }
-  } else if (input.kind === "preference") {
-    const longTerm = nested(client, ["longTerm", "long_term"], client);
-    result = await callOptional(
-      longTerm,
-      ["addPreference"],
-      [input.category ?? "general", input.text, neo4jPreferenceOptions(input)]
-    );
-    if (result === void 0) {
-      result = await callRequired(
-        longTerm,
-        ["add_preference"],
-        [input.category ?? "general", input.text, neo4jWriteOptions(input)]
-      );
-    }
-  } else {
-    result = await callRequired(
-      nested(client, ["longTerm", "long_term"], client),
-      ["addFact", "add_fact"],
-      [
-        input.subject ?? input.title ?? input.kind,
-        input.predicate ?? "states",
-        input.object ?? input.text
-      ]
-    );
-  }
-  const id = idFromResult(result) ?? input.id ?? stableId("mem", `${input.kind}:${input.text}`);
-  return {
-    accepted: true,
-    id,
-    uri: `memory://${adapterId}/${encodeURIComponent(id)}`,
-    kind: input.kind,
-    metadata: { rawResult: result }
-  };
-}
-async function searchNeo4jMemory(client, query, options, adapterId) {
-  const searches = [];
-  const kinds = options.kinds;
-  const includeKind = (kind) => !kinds?.length || kinds.includes(kind);
-  const shortTerm = nested(client, ["shortTerm", "short_term"], {});
-  const longTerm = nested(client, ["longTerm", "long_term"], {});
-  const reasoning = nested(client, ["reasoning"], {});
-  if (includeKind("message")) {
-    searches.push(
-      callOptional(
-        shortTerm,
-        ["searchMessages", "search_messages"],
-        [query, searchMessagesOptions(options)]
-      ).then((result) => normalizeHits(result, { ...options, kinds: ["message"] }, adapterId))
-    );
-  }
-  if (includeKind("entity")) {
-    searches.push(
-      callOptional(
-        longTerm,
-        ["searchEntities", "search_entities"],
-        [query, searchEntitiesOptions(options)]
-      ).then((result) => normalizeHits(result, { ...options, kinds: ["entity"] }, adapterId))
-    );
-  }
-  if (includeKind("preference")) {
-    searches.push(
-      callOptional(
-        longTerm,
-        ["searchPreferences", "search_preferences"],
-        [query, searchPreferencesOptions(options)]
-      ).then((result) => normalizeHits(result, { ...options, kinds: ["preference"] }, adapterId))
-    );
-  }
-  if (includeKind("reasoning-trace")) {
-    searches.push(
-      callOptional(
-        reasoning,
-        ["getSimilarTraces", "get_similar_traces"],
-        [query, similarTracesOptions(options)]
-      ).then(
-        (result) => normalizeHits(result, { ...options, kinds: ["reasoning-trace"] }, adapterId)
-      )
-    );
-  }
-  const hits = (await Promise.all(searches)).flat();
-  return hits.sort((a, b) => (b.normalizedScore ?? b.score ?? 0) - (a.normalizedScore ?? a.score ?? 0)).slice(0, options.limit);
-}
-function holdoutBypassContext(query, options) {
-  return {
-    query,
-    ...options.scope !== void 0 ? { scope: options.scope } : {},
-    ...options.scope?.tags?.taskId !== void 0 ? { taskId: options.scope.tags.taskId } : {}
-  };
-}
-function neo4jOptions(options) {
-  return {
-    limit: options.limit,
-    k: options.limit,
-    min_score: options.minScore,
-    minScore: options.minScore,
-    user_identifier: options.scope?.userId,
-    userIdentifier: options.scope?.userId,
-    session_id: options.scope?.sessionId,
-    sessionId: options.scope?.sessionId,
-    namespace: options.scope?.namespace,
-    tenant_id: options.scope?.tenantId,
-    tenantId: options.scope?.tenantId,
-    kinds: options.kinds,
-    metadata: options.metadata
-  };
-}
-function searchMessagesOptions(options) {
-  return {
-    limit: options.limit,
-    sessionId: options.scope?.sessionId,
-    conversationId: options.scope?.sessionId,
-    threshold: options.minScore,
-    metadata: options.metadata
-  };
-}
-function searchEntitiesOptions(options) {
-  return {
-    limit: options.limit,
-    type: options.metadata?.type
-  };
-}
-function searchPreferencesOptions(options) {
-  return {
-    limit: options.limit,
-    category: options.metadata?.category
-  };
-}
-function similarTracesOptions(options) {
-  return {
-    limit: options.limit,
-    sessionId: options.scope?.sessionId,
-    successOnly: options.metadata?.successOnly
-  };
-}
-function neo4jWriteOptions(input) {
-  return {
-    user_identifier: input.scope?.userId,
-    userIdentifier: input.scope?.userId,
-    session_id: input.scope?.sessionId,
-    sessionId: input.scope?.sessionId,
-    namespace: input.scope?.namespace,
-    confidence: input.confidence,
-    metadata: input.metadata
-  };
-}
-function neo4jEntityOptions(input) {
-  return {
-    description: input.metadata?.description ?? input.title
-  };
-}
-function neo4jPreferenceOptions(input) {
-  return {
-    context: input.metadata?.context ?? input.title
-  };
-}
-async function callOptional(target, names, args) {
-  for (const name of names) {
-    const fn = target[name];
-    if (typeof fn === "function") return await fn.apply(target, args);
-  }
-  return void 0;
-}
-async function callRequired(target, names, args) {
-  const result = await callOptional(target, names, args);
-  if (result !== void 0) return result;
-  throw new Error(`Neo4j agent-memory client is missing method ${names.join(" or ")}`);
-}
-function nested(target, names, fallback) {
-  for (const name of names) {
-    const value = target[name];
-    if (value && typeof value === "object") return value;
-  }
-  return fallback;
-}
-function normalizeHits(value, options, adapterId) {
-  const rawHits = rawHitsFrom(value);
-  return rawHits.map((hit, index) => normalizeHit(hit, index, adapterId)).filter((hit) => hit !== null).filter(
-    (hit) => options.minScore === void 0 ? true : (hit.normalizedScore ?? hit.score ?? 0) >= options.minScore
-  ).filter((hit) => options.kinds?.length ? options.kinds.includes(hit.kind) : true).slice(0, options.limit);
-}
-function normalizeHit(value, index, adapterId) {
-  if (typeof value === "string") {
-    return {
-      id: stableId("mem", value),
-      uri: `memory://${adapterId}/${stableId("mem", value)}`,
-      kind: "fact",
-      text: value,
-      normalizedScore: index === 0 ? 1 : void 0
-    };
-  }
-  const obj = record(value);
-  if (!obj) return null;
-  const kind = memoryKind(stringField(obj, ["kind", "type", "label"]), obj);
-  const text = textFromHitObject(obj, kind);
-  if (!text) return null;
-  const id = stringField(obj, ["id", "memoryId", "uuid"]) ?? stableId("mem", text);
-  return {
-    id,
-    uri: stringField(obj, ["uri"]) ?? `memory://${adapterId}/${encodeURIComponent(id)}`,
-    kind,
-    text,
-    title: stringField(obj, ["title", "name", "task", "subject"]),
-    score: numberField(obj, ["score"]),
-    normalizedScore: numberField(obj, ["normalizedScore", "normalized_score"]),
-    confidence: numberField(obj, ["confidence"]),
-    createdAt: stringField(obj, ["createdAt", "created_at"]),
-    validUntil: stringField(obj, ["validUntil", "valid_until"]),
-    lastVerifiedAt: stringField(obj, ["lastVerifiedAt", "last_verified_at"]),
-    metadata: obj
-  };
-}
-function memoryKind(value, obj = {}) {
-  if (value === "message" || value === "entity" || value === "fact" || value === "preference" || value === "observation" || value === "reasoning-trace") {
-    return value;
-  }
-  if ("role" in obj && "content" in obj) return "message";
-  if ("name" in obj && ("type" in obj || "entityType" in obj)) return "entity";
-  if ("preference" in obj && "category" in obj) return "preference";
-  if ("task" in obj && "steps" in obj) return "reasoning-trace";
-  return "fact";
-}
-function rawHitsFrom(value) {
-  if (Array.isArray(value)) return value;
-  const obj = record(value);
-  if (!obj) return typeof value === "string" ? [value] : [];
-  if (Array.isArray(obj.hits)) return obj.hits;
-  if (Array.isArray(obj.results)) return obj.results;
-  if (Array.isArray(obj.messages)) return obj.messages;
-  if (Array.isArray(obj.recentMessages)) return obj.recentMessages;
-  if (Array.isArray(obj.observations)) return obj.observations;
-  if (Array.isArray(obj.reflections)) return obj.reflections;
-  if (typeof obj.content === "string" || typeof obj.text === "string") return [obj];
-  return [];
-}
-function textFromHitObject(obj, kind) {
-  const direct = stringField(obj, [
-    "text",
-    "content",
-    "body",
-    "summary",
-    "preference",
-    "description"
-  ]);
-  if (direct) return direct;
-  if (kind === "entity") return stringField(obj, ["name"]);
-  if (kind === "fact") {
-    const subject = stringField(obj, ["subject"]);
-    const predicate = stringField(obj, ["predicate"]);
-    const object = stringField(obj, ["object", "obj"]);
-    if (subject && predicate && object) return `${subject} ${predicate} ${object}`;
-  }
-  if (kind === "reasoning-trace") {
-    const task = stringField(obj, ["task"]);
-    const outcome = stringField(obj, ["outcome"]);
-    return [task, outcome].filter(Boolean).join("\n") || void 0;
-  }
-  return void 0;
-}
-function textFromConversationContext(value) {
-  const obj = record(value);
-  if (!obj) return void 0;
-  const parts = [
-    ...rawHitsFrom(obj.reflections).map((hit) => normalizeContextPart(hit)),
-    ...rawHitsFrom(obj.observations).map((hit) => normalizeContextPart(hit)),
-    ...rawHitsFrom(obj.recentMessages).map((hit) => normalizeContextPart(hit))
-  ].filter(Boolean);
-  return parts.length > 0 ? parts.join("\n\n") : void 0;
-}
-function normalizeConversationContextHits(value, options, adapterId) {
-  const obj = record(value);
-  if (!obj) return normalizeHits(value, options, adapterId);
-  const raw = [
-    ...rawHitsFrom(obj.reflections).map((hit) => tagContextHit(hit, "observation", "Reflection")),
-    ...rawHitsFrom(obj.observations).map((hit) => tagContextHit(hit, "observation", "Observation")),
-    ...rawHitsFrom(obj.recentMessages).map((hit) => tagContextHit(hit, "message"))
-  ];
-  return raw.length > 0 ? normalizeHits(raw, options, adapterId) : normalizeHits(value, options, adapterId);
-}
-function tagContextHit(value, kind, title) {
-  return value && typeof value === "object" && !Array.isArray(value) ? { kind, title, ...value } : { kind, title, content: value };
-}
-function normalizeContextPart(value) {
-  if (typeof value === "string") return value;
-  const obj = record(value);
-  return obj ? textFromHitObject(obj, memoryKind(stringField(obj, ["kind", "type", "label"]), obj)) : void 0;
-}
-function renderHits(hits) {
-  return hits.map((hit) => hit.text).join("\n\n");
-}
-function idFromResult(value) {
-  const obj = record(value);
-  return obj ? stringField(obj, ["id", "memoryId", "uuid"]) : void 0;
-}
-function record(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
-}
-function stringField(obj, names) {
-  for (const name of names) {
-    const value = obj[name];
-    if (typeof value === "string" && value.length > 0) return value;
-  }
-  return void 0;
-}
-function numberField(obj, names) {
-  for (const name of names) {
-    const value = obj[name];
-    if (typeof value === "number" && Number.isFinite(value)) return value;
-  }
-  return void 0;
-}
-
-// src/memory/schemas.ts
-import { z } from "zod";
-var AgentMemoryKindSchema = z.enum([
-  "message",
-  "entity",
-  "fact",
-  "preference",
-  "observation",
-  "reasoning-trace"
-]);
-var AgentMemoryScopeSchema = z.object({
-  tenantId: z.string().optional(),
-  userId: z.string().optional(),
-  sessionId: z.string().optional(),
-  namespace: z.string().optional(),
-  tags: z.record(z.string(), z.string()).optional()
-});
-var AgentMemoryHitSchema = z.object({
-  id: z.string().min(1),
-  uri: z.string().min(1),
-  kind: AgentMemoryKindSchema,
-  text: z.string().min(1),
-  title: z.string().optional(),
-  score: z.number().optional(),
-  normalizedScore: z.number().optional(),
-  confidence: z.number().optional(),
-  createdAt: z.string().optional(),
-  validUntil: z.string().optional(),
-  lastVerifiedAt: z.string().optional(),
-  metadata: z.record(z.string(), z.unknown()).optional()
-});
-var AgentMemoryWriteInputSchema = z.object({
-  kind: AgentMemoryKindSchema,
-  text: z.string().min(1),
-  id: z.string().optional(),
-  title: z.string().optional(),
-  role: z.enum(["system", "user", "assistant", "tool"]).optional(),
-  entityName: z.string().optional(),
-  entityType: z.string().optional(),
-  category: z.string().optional(),
-  predicate: z.string().optional(),
-  subject: z.string().optional(),
-  object: z.string().optional(),
-  confidence: z.number().min(0).max(1).optional(),
-  scope: AgentMemoryScopeSchema.optional(),
-  metadata: z.record(z.string(), z.unknown()).optional()
-});
-
-export {
-  deterministicRng,
-  retrievalHoldoutConfigHash,
-  applyRetrievalHoldout,
-  emitRetrievalHoldoutBypass,
-  resetRetrievalHoldoutRegistry,
-  applySessionStickyRetrievalHoldout,
-  toOffPolicyTrajectory,
-  defaultGetMemoryContext,
-  renderMemoryContext,
-  createNeo4jAgentMemoryAdapter,
-  AgentMemoryKindSchema,
-  AgentMemoryScopeSchema,
-  AgentMemoryHitSchema,
-  AgentMemoryWriteInputSchema
-};
-//# sourceMappingURL=chunk-VN2OGUUP.js.map