Function augmentGraphWithSupportObjects

src/pipeline/memoryObjects.ts:1953–2169

(params: {
  store: MemxStoreBundle;
  ctx: MemoryOperationContext;
  objective: MemorySelectionObjective;
  graph: GraphEvidence;
  supportObjects: MemoryObject[];
  graphHypotheses: AbstractionCandidateRecord[];
  seedEntityIds: string[];
  prioritySeedEntityIds?: string[];
})

}

function augmentGraphWithSupportObjects(params: {
  store: MemxStoreBundle;
  ctx: MemoryOperationContext;
  objective: MemorySelectionObjective;
  graph: GraphEvidence;
  supportObjects: MemoryObject[];
  graphHypotheses: AbstractionCandidateRecord[];
  seedEntityIds: string[];
  prioritySeedEntityIds?: string[];
}): GraphEvidence {
  const hasDurableGraph = params.graph.edges.length > 0 || params.graph.pathCandidates.length > 0;
  const nodes = new Map<string, GraphEvidenceNode>(
    params.graph.nodes.map((node) => [node.nodeId, node]),
  );
  const edges = new Map<string, GraphEvidenceEdge>(
    params.graph.edges.map((edge) => [edge.edgeId, edge]),
  );
  const objectNodes = new Map<string, GraphEvidenceNode>();
  const linkedEntityIdsByObject = new Map<string, Set<string>>();
  const taskNodesByTaskId = new Map<string, GraphEvidenceNode>();

  for (const object of params.supportObjects) {
    const node = memoryGraphNodeFromObject(object);
    if (!node) {
      continue;
    }
    ensureGraphNode(nodes, node);
    objectNodes.set(object.objectId, node);
    if (object.kind === "task" && object.attributes.taskId) {
      taskNodesByTaskId.set(object.attributes.taskId, node);
    }
  }

  for (const candidate of params.graphHypotheses) {
    const metadata = parseGraphHypothesisCandidate(candidate);
    if (!metadata) {
      continue;
    }
    const hasStoredEquivalent = [...edges.values()].some(
      (edge) =>
        edge.sourceKind === "stored" &&
        edge.relType === metadata.relationType &&
        edge.relationSlot === metadata.relationSlot &&
        edge.srcNodeId === metadata.sourceNodeId &&
        edge.dstNodeId === metadata.targetNodeId,
    );
    if (hasStoredEquivalent) {
      continue;
    }
    ensureGraphNode(nodes, {
      nodeId: metadata.sourceNodeId,
      nodeKind: "entity",
      name: metadata.sourceName,
      type: metadata.sourceType,
      sourceObjectId: `abstraction_candidate:${candidate.candidateId}`,
      observedAt: candidate.updatedAt,
      confidence: candidate.confidence,
    });