Conflict Resolution

from dakera import DakeraClient
from datetime import datetime
import openai

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

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

def detect_contradiction(existing: str, new: str) -> bool:
    """LLM-based contradiction check (application logic, not a Dakera call)."""
    resp = oai.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user",
                   "content": f"Do these two statements contradict? YES or NO.\nA: {existing}\nB: {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 HIGH_STAKES_TAGS.intersection(new_tags):
        return {"action": "ask-user", "existing": existing_mem.content, "proposed": new_content}

    # Recency wins: demote the loser and mark it superseded
    client.update_importance(
        agent_id=AGENT,
        memory_ids=[existing_mem.id],
        importance=0.15
    )
    client.update_memory(
        agent_id=AGENT,
        memory_id=existing_mem.id,
        content=f"[SUPERSEDED] {existing_mem.content}"
    )
    # Store the new winner
    client.store_memory(
        agent_id=AGENT,
        content=new_content,
        importance=new_importance,
        memory_type="semantic",
        tags=new_tags
    )
    # Audit entry (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(tags):
        return client.store_memory(agent_id=AGENT, content=content,
                                   importance=importance, memory_type=memory_type, tags=tags)
    # Recall scores rank candidates; the contradiction check makes the decision
    candidates = client.recall(agent_id=AGENT, query=content, min_importance=0.3, top_k=3)
    for mem in candidates.memories:
        if 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: a 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:3000', apiKey: 'dk-...' });
const oai = new OpenAI();
const AGENT = 'personal-assistant';
const CONFLICT_ELIGIBLE = new Set(['preference', 'fact', 'profile']);
const HIGH_STAKES = new Set(['medical', 'address', 'financial']);

// Application logic: Dakera does not judge contradictions
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.\nA: ${a}\nB: ${b}` }]
  });
  return r.choices[0].message.content?.trim().toUpperCase() === 'YES';
}

async function storeWithConflictCheck(
  content: string, importance: number, tags: string[], memory_type: 'episodic' | 'semantic' = 'semantic'
) {
  if (!tags.some(t => CONFLICT_ELIGIBLE.has(t))) {
    return client.storeMemory(AGENT, { content, importance, memory_type, tags });
  }
  const candidates = await client.recall(AGENT, content, { min_importance: 0.3, top_k: 3 });
  for (const mem of candidates.memories) {
    if (!(await detectContradiction(mem.content, content))) continue;
    if (tags.some(t => HIGH_STAKES.has(t))) {
      return { action: 'ask-user', existing: mem.content, proposed: content };
    }
    // Recency wins: demote and mark the loser, store the winner, log it
    await client.updateImportance(AGENT, { memory_ids: [mem.id], importance: 0.15 });
    await client.updateMemory(AGENT, mem.id, { content: `[SUPERSEDED] ${mem.content}` });
    await client.storeMemory(AGENT, { content, importance, memory_type, 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, memory_type: 'episodic', tags: ['conflict-log'], ttl_seconds: 7776000
    });
    return { action: 'resolved-recency' };
  }
  return client.storeMemory(AGENT, { content, importance, memory_type, tags });
}

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

use dakera_client::memory::{UpdateImportanceRequest, UpdateMemoryRequest};
use dakera_client::{DakeraClient, MemoryType, RecallRequest, StoreMemoryRequest};

let client = DakeraClient::builder("http://localhost:3000").api_key("dk-...").build()?;
let agent = "personal-assistant";
let new_content = "User prefers dark mode (May 2026)";

// 1. Recall similar memories as conflict candidates
let candidates = client.recall(
    RecallRequest::new(agent, "UI theme display mode preference")
        .with_min_importance(0.3)
        .with_top_k(3),
).await?;

// 2. Your contradiction check decides; recall scores only rank the candidates
for mem in &candidates.memories {
    if !is_contradiction(&mem.content, new_content) {
        continue;
    }
    // Demote the loser and mark it superseded
    client.update_importance(agent, UpdateImportanceRequest {
        memory_ids: vec![mem.id.clone()],
        importance: 0.15,
    }).await?;
    client.update_memory(agent, &mem.id, UpdateMemoryRequest {
        content: Some(format!("[SUPERSEDED] {}", mem.content)),
        ..Default::default()
    }).await?;

    // Store the new winner
    client.store_memory(
        StoreMemoryRequest::new(agent, new_content)
            .with_type(MemoryType::Semantic)
            .with_importance(0.80)
            .with_tags(vec!["preference".into(), "ui".into()]),
    ).await?;

    // Audit entry with a 90-day TTL
    client.store_memory(
        StoreMemoryRequest::new(agent, "CONFLICT LOG: light-mode -> dark-mode, recency, 2026-05-20")
            .with_type(MemoryType::Episodic)
            .with_importance(0.4)
            .with_tags(vec!["conflict-log".into()])
            .with_ttl(7_776_000),
    ).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 float32, tags []string) error {
    minImp := float32(0.3)
    candidates, err := client.Recall(ctx, agent, dakera.RecallRequest{
        Query: content, MinImportance: &minImp, TopK: 3,
    })
    if err != nil {
        return err
    }
    for _, mem := range candidates.Memories {
        // Your contradiction check decides; recall scores only rank the candidates
        if !isContradiction(mem.Content, content) {
            continue
        }
        if isHighStakes(tags) {
            fmt.Printf("ASK USER: '%s' vs '%s'\n", mem.Content, content)
            return nil
        }
        // Demote the loser and mark it superseded
        if err := client.UpdateImportance(ctx, agent, dakera.UpdateImportanceRequest{
            MemoryIDs: []string{mem.ID}, Importance: 0.15,
        }); err != nil {
            return err
        }
        superseded := "[SUPERSEDED] " + mem.Content
        if _, err := client.UpdateMemory(ctx, agent, mem.ID, dakera.UpdateMemoryRequest{Content: &superseded}); err != nil {
            return err
        }
        // Store the winner
        if _, err := client.StoreMemory(ctx, agent, dakera.StoreMemoryRequest{
            Content: content, Importance: &importance, MemoryType: "semantic", Tags: tags,
        }); err != nil {
            return err
        }
        // Audit entry with a 90-day TTL
        logImp, ttl := float32(0.4), 7776000
        _, err := client.StoreMemory(ctx, agent, dakera.StoreMemoryRequest{
            Content:    fmt.Sprintf("CONFLICT LOG: recency resolved %s", time.Now().Format("2006-01-02")),
            Importance: &logImp, MemoryType: "episodic",
            Tags: []string{"conflict-log"}, TTLSeconds: &ttl,
        })
        return err
    }
    _, err = client.StoreMemory(ctx, agent, dakera.StoreMemoryRequest{
        Content: content, Importance: &importance, MemoryType: "semantic", Tags: tags,
    })
    return err
}