Kill it. Resume it.Nothing happens twice.

name = "refund_card"
effect = "write"                  # the operator's word, never the client's
# grants this client the right to close its own call by report alone;
# wire-payout.toml in this example sets it false, so a human closes every payout
trust_completion = true
require_equal = ["amount_cents"]  # reported must equal what the intent said

[input_schema]
type = "object"
required = ["order_id", "amount_cents", "currency"]

# provider_refund_id is the one field a client could not have invented
# without the provider answering, so a completion lacking it is a claim
[output_schema]
type = "object"
required = ["provider_refund_id", "status", "amount_cents"]

# elided here: each field's own [input_schema.properties.*] table

from salvor import Client

# whatever names your loop's definition; salvor records it and hands it
# back on replay, and never resolves it
AGENT = "sha256:client-tools-refund-desk"

with Client("http://127.0.0.1:8080") as c:
    # the operator's declarations are the model's tool definitions
    tools = [{"name": t.name, "input_schema": t.input_schema}
             for t in c.list_client_tools()]

    run = c.open_client_run()
    run.append([run.envelope(0, "RunStarted", agent_def_hash=AGENT, input={})])

    # a model step records its intent AND its completion, so it takes 1 and 2
    step = run.model_step(1, {
        "model": "claude-opus-4-8",
        "max_tokens": 512,
        "tools": tools,
        "messages": [{"role": "user", "content": "ORD-7781 arrived damaged."}],
    })
    call = next(b for b in step.response["content"] if b["type"] == "tool_use")

    opened = run.client_tool_intent(3, call["name"], call["input"])
    # call_provider is YOUR code: the money moves here and salvor never sees
    # it. Perform it under salvor's derived key, so a retry after a crash
    # cannot refund the same order twice.
    charged = call_provider(opened.idempotency_key, call["input"])
    run.client_tool_completion(3, {
        "provider_refund_id": charged["provider_refund_id"],
        "status": charged["status"],
        "amount_cents": charged["amount_cents"],
    })

import { SalvorClient } from "@salvor-run/client";

// whatever names your loop's definition; salvor records it and hands it
// back on replay, and never resolves it
const AGENT = "sha256:client-tools-refund-desk";

const salvor = new SalvorClient("http://127.0.0.1:8080");

// the operator's declarations are the model's tool definitions
const decls = await salvor.listClientTools();
const tools = decls.map((t) => ({ name: t.name, input_schema: t.inputSchema }));

const run = await salvor.openClientRun();
await run.append([run.envelope(0, "RunStarted", { agent_def_hash: AGENT, input: {} })]);

// a model step records its intent AND its completion, so it takes 1 and 2
const step = await run.modelStep(1, {
  model: "claude-opus-4-8",
  max_tokens: 512,
  tools,
  messages: [{ role: "user", content: "ORD-7781 arrived damaged." }],
});
// response is the provider's JSON, typed unknown; narrow it to read a block
type Block = { type: string; name: string; input: unknown };
const { content } = step.response as { content: Block[] };
const call = content.find((b) => b.type === "tool_use")!;

const opened = await run.clientToolIntent(3, call.name, call.input);
// callProvider is YOUR code: the money moves here and salvor never sees it.
// Perform it under salvor's derived key, so a retry after a crash cannot
// refund the same order twice.
const charged = await callProvider(opened.idempotencyKey, call.input);
await run.clientToolCompletion(3, {
  provider_refund_id: charged.provider_refund_id,
  status: charged.status,
  amount_cents: charged.amount_cents,
});