OpenAI Agents SDK: Add Persistent Memory with sovseal

import os
import asyncio
from dotenv import load_dotenv
from agents import Agent, Runner, function_tool
from sovseal import AgentStateClient, EngineUnavailableError

load_dotenv()

# Shared client instance — reused across all tool calls in a session.
# store/recall need no endpoint/api_key; they talk to the local native host.
client = AgentStateClient()


# 1. Memory search tool — wraps sovseal-sdk's recall()
@function_tool
def search_memory(query: str) -> str:
    """Search through past conversations and stored preferences for the user."""
    try:
        hits = client.recall(query, top_k=3)
    except EngineUnavailableError as e:
        return f"Memory engine unavailable ({e.reason})."
    if hits:
        return "\n".join(f"- {h['text']}" for h in hits)
    return "No relevant memories found."


# 2. Memory save tool — wraps sovseal-sdk's store()
@function_tool
def save_memory(content: str) -> str:
    """Save an important fact or preference about the user to persistent memory."""
    try:
        client.store(content)
    except EngineUnavailableError as e:
        return f"Memory engine unavailable ({e.reason}) — not saved."
    return "Information saved successfully."


# 3. Specialist agents
travel_agent = Agent(
    name="Travel Planner",
    instructions=(
        "You are a travel planning specialist. Always call search_memory first "
        "to check for stored travel preferences or past destinations for the user."
    ),
    tools=[search_memory, save_memory],
    model="gpt-4o",
)

health_agent = Agent(
    name="Health Advisor",
    instructions=(
        "You are a health and wellness advisor. Call search_memory first "
        "to retrieve any dietary restrictions or health preferences for the user."
    ),
    tools=[search_memory, save_memory],
    model="gpt-4o",
)


# 4. Triage agent with handoffs
triage_agent = Agent(
    name="Personal Assistant",
    instructions=(
        "You are a triage assistant. Route the user to the Travel Planner or "
        "Health Advisor based on their request. "
        "Use the memory tools to personalise every interaction."
    ),
    handoffs=[travel_agent, health_agent],
    model="gpt-4o",
)


# 5. Run a session and persist the outcome
async def chat_session(user_input: str, user_id: str) -> str:
    result = await Runner.run_async(triage_agent, user_input, user_id=user_id)

    # Persist the session summary so future runs have context
    try:
        client.store(
            f"User '{user_id}' requested: '{user_input}'. "
            f"Agent responded: '{result.final_output}'"
        )
    except EngineUnavailableError:
        pass  # fail open — engine not installed/running

    return result.final_output


if __name__ == "__main__":
    response = asyncio.run(
        chat_session("Plan a healthy meal for my trip to Rome", "alice_12")
    )
    print("Assistant Response:", response)