Support-ticket triage agent

soma.toml

[package]
name = "agents-corpus"
version = "0.1.0"
description = "Verified AI-agent example cells (training corpus)"

# Agent LLM config. `mock = "echo"` keeps every example in this directory
# hermetic: `soma test` / `soma run` need no network and no API key, and
# results are deterministic. For a live run, delete the `mock` line (or
# override with SOMA_LLM_MOCK) and provide the key via env.
[agent]
provider = "anthropic"
model    = "claude-opus-4-6"
key      = "${ANTHROPIC_API_KEY}"
mock     = "echo"

# Termination proof for verified_termination.cell's `workflow` machine:
# every path eventually reaches a terminal, no deadlocks.
# `cells` scopes these properties to Solver — the other agents in this
# directory have their own state names and must not inherit them.
[verify]
cells = ["Solver"]
deadlock_free = true
eventually    = ["done", "failed"]

[verify.after.understanding]
eventually = ["solving", "failed"]

[verify.after.solving]
eventually = ["verifying", "failed"]

[verify.after.verifying]
eventually = ["done", "failed"]

triage_agent.cell

// Support-ticket triage agent.
// Demonstrates: a verified lifecycle state machine, set_budget cap, tool
// handlers with deterministic keyword classification (no LLM call — see
// services/refund_agent.cell for think() + validated JSON output), and a
// test cell that runs without any network.
//
// Run:  SOMA_LLM_MOCK=echo soma run triage_agent.cell --signal triage "login broken"
// Test: SOMA_LLM_MOCK=echo soma test triage_agent.cell

cell agent Triage {
    face {
        signal triage(text: String) -> Map
        tool classify(text: String) -> String "Classify ticket urgency: low, medium, high"
        promise "agent always reaches routed or failed"
    }

    memory {
        tickets: Map<String, Map> [persistent]
    }

    state lifecycle {
        initial: idle
        idle      -> reading
        reading   -> classifying
        classifying -> routed
        *         -> failed
    }

    // Deterministic tool: keyword-based urgency, no LLM needed.
    on classify(text: String) {
        let t = lowercase(text)
        if contains(t, "broken") || contains(t, "down") { return "high" }
        if contains(t, "slow") { return "medium" }
        "low"
    }

    on triage(text: String) {
        set_budget(2000)
        // Per-ticket state-machine instance, so each triage runs its own
        // verified lifecycle from idle to routed.
        let id = to_string(next_id())
        transition(id, "reading")

        transition(id, "classifying")
        let urgency = classify(text)

        let queue = if urgency == "high" { "escalation" } else { "standard" }
        tickets.set(id, map("id", id, "text", text, "urgency", urgency, "queue", queue))

        transition(id, "routed")
        map("id", id, "urgency", urgency, "queue", queue, "status", "routed")
    }
}

cell test TriageTests {
    rules {
        assert classify("the server is down") == "high"
        assert classify("page loads slow") == "medium"
        assert classify("how do I rename a file") == "low"
        assert triage("login broken").urgency == "high"
        assert triage("login broken").queue == "escalation"
        assert triage("minor typo").status == "routed"
    }
}