Conflict Resolution

from dakera import DakeraClient
from datetime import datetime
import openai

client = DakeraClient(base_url="http://localhost:3300", api_key="dk-...")
oai = openai.OpenAI()
AGENT = "personal-assistant"

CONFLICT_ELIGIBLE_TAGS = {"preference", "fact", "profile"}
CONFLICT_THRESHOLD = 0.82
HIGH_STAKES_TAGS = {"medical", "address", "financial"}

def detect_contradiction(existing: str, new: str) -> bool:
    """LLM-based contradiction detection."""
    resp = oai.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user",
                   "content": f"Do these two statements contradict? YES or NO.
A: {existing}
B: {new}"}]
    )
    return resp.choices[0].message.content.strip().upper() == "YES"

def resolve_conflict(existing_mem, new_content: str, new_importance: float, new_tags: list):
    """Apply recency-wins or escalate to ask-user for high-stakes facts."""
    if any(t in HIGH_STAKES_TAGS for t in (existing_mem.tags or [])):
        return {"action": "ask-user", "existing": existing_mem.content, "proposed": new_content}

    # Recency wins: demote loser
    client.update_importance(
        agent_id=AGENT,
        memory_id=existing_mem.id,
        importance=0.15
    )
    client.update_memory(
        agent_id=AGENT,
        memory_id=existing_mem.id,
        content=f"[SUPERSEDED] {existing_mem.content}",
        tags=(existing_mem.tags or []) + ["superseded"]
    )
    # Store new winner
    client.store_memory(
        agent_id=AGENT,
        content=new_content,
        importance=new_importance,
        memory_type="semantic",
        tags=new_tags
    )
    # Audit log (90 day TTL)
    client.store_memory(
        agent_id=AGENT,
        content=f"CONFLICT LOG: '{existing_mem.content[:50]}' -> '{new_content[:50]}', recency, {datetime.now().date()}",
        importance=0.4,
        memory_type="episodic",
        tags=["conflict-log"],
        ttl_seconds=7776000
    )
    return {"action": "resolved-recency"}

def store_with_conflict_check(content: str, importance: float, tags: list, memory_type: str = "semantic"):
    """Write-time conflict detection and resolution."""
    if not CONFLICT_ELIGIBLE_TAGS.intersection(set(tags)):
        return client.store_memory(agent_id=AGENT, content=content,
                                   importance=importance, memory_type=memory_type, tags=tags)
    candidates = client.recall(agent_id=AGENT, query=content, min_importance=0.3, top_k=3)
    for mem in candidates.memories:
        sim = getattr(mem, 'similarity_score', 0.0) or 0.0
        if sim >= CONFLICT_THRESHOLD and detect_contradiction(mem.content, content):
            return resolve_conflict(mem, content, importance, tags)
    return client.store_memory(agent_id=AGENT, content=content,
                               importance=importance, memory_type=memory_type, tags=tags)

# Usage: preference update triggers conflict detection
store_with_conflict_check(
    content="User prefers dark mode (confirmed May 2026)",
    importance=0.80,
    tags=["preference", "ui"]
)

import { DakeraClient } from '@dakera-ai/dakera';
import OpenAI from 'openai';

const client = new DakeraClient({ baseUrl: 'http://localhost:3300', apiKey: 'dk-...' });
const oai = new OpenAI();
const AGENT = 'personal-assistant';
const CONFLICT_THRESHOLD = 0.82;
const CONFLICT_ELIGIBLE = new Set(['preference', 'fact', 'profile']);
const HIGH_STAKES = new Set(['medical', 'address', 'financial']);

async function detectContradiction(a: string, b: string): Promise<boolean> {
  const r = await oai.chat.completions.create({
    model: 'gpt-4o-mini',
    messages: [{ role: 'user', content: `Contradict? YES or NO.
A: ${a}
B: ${b}` }]
  });
  return r.choices[0].message.content?.trim().toUpperCase() === 'YES';
}

async function storeWithConflictCheck(
  content: string, importance: number, tags: string[], memoryType = 'semantic'
) {
  if (!tags.some(t => CONFLICT_ELIGIBLE.has(t))) {
    return client.storeMemory(AGENT, { content, importance, memoryType, tags });
  }
  const candidates = await client.recall(AGENT, content, { min_importance: 0.3, top_k: 3 });
  for (const mem of candidates.memories) {
    if ((mem.similarityScore ?? 0) >= CONFLICT_THRESHOLD && await detectContradiction(mem.content, content)) {
      if ((mem.tags ?? []).some((t: string) => HIGH_STAKES.has(t))) {
        return { action: 'ask-user', existing: mem.content, proposed: content };
      }
      // Recency wins
      await client.updateImportance(AGENT, { memory_id: mem.id, importance: 0.15 });
      await client.updateMemory(AGENT, mem.id, {
        content: `[SUPERSEDED] ${mem.content}`,
        tags: [...(mem.tags ?? []), 'superseded']
      });
      await client.storeMemory(AGENT, { content, importance, memoryType, tags });
      await client.storeMemory(AGENT, {
        content: `CONFLICT LOG: '${mem.content.slice(0,50)}' -> '${content.slice(0,50)}', recency, ${new Date().toISOString().split('T')[0]}`,
        importance: 0.4, memoryType: 'episodic', tags: ['conflict-log'], ttl_seconds: 7776000
      });
      return { action: 'resolved-recency' };
    }
  }
  return client.storeMemory(AGENT, { content, importance, memoryType, tags });
}

// Usage
await storeWithConflictCheck('User prefers dark mode (May 2026)', 0.80, ['preference', 'ui']);

use dakera_rs::{Client, StoreMemoryRequest, RecallRequest};

let client = Client::new("http://localhost:3300", "dk-...");
let agent = "personal-assistant";

// 1. Recall similar memories to detect conflicts
let candidates = client.recall(agent, RecallRequest {
    query: "UI theme display mode preference".into(),
    min_importance: Some(0.3),
    top_k: Some(3),
    ..Default::default()
}).await?;

// 2. For each high-similarity candidate, check contradiction (your logic)
for mem in &candidates.memories {
    if mem.similarity_score.unwrap_or(0.0) >= 0.82 {
        if is_contradiction(&mem.content, "User prefers dark mode") {
            // Demote old via REST: PUT /v1/memory/{id}/importance { importance: 0.15 }
            // Update content via REST: PUT /v1/memory/{id} { content: "[SUPERSEDED]..." }

            // Store new winner
            client.store_memory(agent, StoreMemoryRequest {
                content: "User prefers dark mode (May 2026)".into(),
                importance: Some(0.80),
                memory_type: "semantic".into(),
                tags: vec!["preference".into(), "ui".into()],
                ..Default::default()
            }).await?;

            // Store audit log with TTL
            client.store_memory(agent, StoreMemoryRequest {
                content: format!("CONFLICT LOG: recency resolved 2026-05-20"),
                importance: Some(0.4),
                memory_type: "episodic".into(),
                tags: vec!["conflict-log".into()],
                ttl_seconds: Some(7776000),
                ..Default::default()
            }).await?;
            break;
        }
    }
}

package main

import (
    "context"
    "fmt"
    "time"
    dakera "github.com/dakera-ai/dakera-go"
)

func storeWithConflictCheck(ctx context.Context, client *dakera.Client, agent, content string, importance float64, tags []string) error {
    candidates, _ := client.Recall(ctx, agent, dakera.RecallRequest{
        Query: content, MinImportance: 0.3, TopK: 3,
    })
    for _, mem := range candidates.Memories {
        if mem.SimilarityScore >= 0.82 && isContradiction(mem.Content, content) {
            if isHighStakes(mem.Tags) {
                fmt.Printf("ASK USER: '%s' vs '%s'
", mem.Content, content)
                return nil
            }
            // Demote loser via REST (PUT /v1/memory/{id}/importance)
            // Store winner
            client.StoreMemory(ctx, agent, dakera.StoreMemoryRequest{
                Content: content, Importance: importance,
                MemoryType: "semantic", Tags: tags,
            })
            // Audit log
            client.StoreMemory(ctx, agent, dakera.StoreMemoryRequest{
                Content:    fmt.Sprintf("CONFLICT LOG: recency resolved %s", time.Now().Format("2006-01-02")),
                Importance: 0.4, MemoryType: "episodic",
                Tags: []string{"conflict-log"}, TtlSeconds: 7776000,
            })
            return nil
        }
    }
    client.StoreMemory(ctx, agent, dakera.StoreMemoryRequest{
        Content: content, Importance: importance, MemoryType: "semantic", Tags: tags,
    })
    return nil
}