Customer support bot

from vectorshift.agent import (
    Agent, AgentTools, AgentType, LlmInfo, MemoryConfig,
)
from vectorshift.agent.tool import (
    ToolInput, ToolInputType, ToolApprovalConfig,
)

agent = Agent.new(
    name="Acme support",
    type=AgentType.CONVERSATIONAL,
    llm_info=LlmInfo(provider="openai", model_id="gpt-5.1"),
    tools=[
        # Web search the agent can call autonomously.
        AgentTools.exa_ai(
            tool_name="exa_ai_search",
            query=ToolInput(type=ToolInputType.DYNAMIC, description="What to search"),
            num_results=3,
            approval_config=ToolApprovalConfig.LET_AGENT_DECIDE,
        ),
    ],
    instructions=(
        "You are a friendly Acme support agent. "
        "Use exa_ai_search when the user asks about current events or external facts. "
        "If a request would change a customer's data, call the gated tool — it will pause "
        "for human approval. If you cannot resolve a request, say so plainly."
    ),
    memory_config=MemoryConfig(enable_session_memory=True),
)
print(f"Created agent: {agent.name} (id={agent.id})")

# Add another tool with REQUIRES_APPROVAL — agent will pause before invoking.
agent.add_tool.exa_ai(
    tool_name="exa_ai_gated",
    query=ToolInput(type=ToolInputType.DYNAMIC, description="Search query"),
    num_results=ToolInput(
        type=ToolInputType.STATIC, description="Number of results", value=5
    ),
    approval_config=ToolApprovalConfig.REQUIRES_APPROVAL,
)

print("Tools:", [t.name for t in agent.tools])
agent.save()

import asyncio
from vectorshift.events import SessionEventType

async def stream_one_turn(session) -> str:
    full = ""
    async for event in session.listen(
        event_types=[
            SessionEventType.MESSAGE_DELTA,
            SessionEventType.MESSAGE_COMPLETE,
        ]
    ):
        if event.delta:
            print(event.delta, end="", flush=True)
            full += event.delta
        if event.is_complete:
            full = event.text or full
            break
    print()
    return full

async def main():
    async with await agent.create_session() as session:
        await session.send("Hi, can you remind me what your refund policy is?")
        await stream_one_turn(session)

asyncio.run(main())

async with await agent.create_session() as session:
    await session.send("What are the latest developments in quantum computing this week?")

    async for event in session.listen():
        match event.type:
            case SessionEventType.THINKING:
                print(f"  [thinking] {event.data.get('summary', '')}")
            case SessionEventType.TOOL_CALL:
                print(f"  [tool call] {event.tool_name} — {event.data.get('status', '')}")
            case SessionEventType.SEARCH_RESULT:
                print("  [search] results received")
            case SessionEventType.MESSAGE_DELTA:
                print(event.delta, end="", flush=True)
            case SessionEventType.MESSAGE_COMPLETE:
                print()
                break
            case SessionEventType.ERROR:
                print(f"\n  [error] {event.error}")
                break
            case _:
                pass  # ignore PONG, MESSAGE_POSTED, etc.

async with await agent.create_session() as session:
    await session.send(
        "Find current news on quantum computing. Use the EXA AI search tool."
    )

    async for event in session.listen():
        if event.type == SessionEventType.APPROVAL_REQUEST:
            tool = event.data.get("tool_name") or event.data.get("tool_id")
            print(f"\n[approval] tool={tool!r} — auto-approving for demo")
            await session.respond(event, approved=True)
            # In production, push the decision to a human:
            # await session.respond_approval(
            #     event, approved=True, confirm={"num_results": 3}
            # )
            continue

        if event.type == SessionEventType.TOOL_CALL:
            print(f"[tool call] {event.tool_name}")
            continue

        if event.type == SessionEventType.TOOL_RESULT:
            print(f"[tool result] {str(event.data.get('result', ''))[:200]}")
            continue

        if event.delta:
            print(event.delta, end="", flush=True)

        if event.is_complete:
            print("\n(turn complete)")
            break

async with await agent.create_session() as session:
    await session.send("My name is Alice and I live in Boston.")
    await stream_one_turn(session)

    # Same session — the agent should remember.
    await session.send("What did I just tell you about myself?")
    reply = await stream_one_turn(session)

    if "Alice" in reply and "Boston" in reply:
        print("✓ context retained across turns")

    # Fetch the full session history any time.
    messages = await session.get_messages()
    print(f"history length: {len(messages)}")

from vectorshift.session import Session

SESSION_ID = "..."  # captured from session.session_id earlier

async def resume():
    session = Session(session_id=SESSION_ID)
    async with session:
        await session.send("Pick up where we left off — what were we discussing?")
        await stream_one_turn(session)

asyncio.run(resume())