The action this settlement settles: its run and its action id, the reference fabric.reconcile takes when the settlement is refused and a person reconciles instead.

Binds a typed handler. classify decides, for every typed error, what it means: a definite failure the model sees (Explain), or an effect that may have happened (Uncertain), which blocks the run until it is reconciled. There is no default: a timeout after a request was sent must not look like a clean failure the model could simply retry.

The handler runs in its own task with the run’s context, the Call it answers and the decoded input. Its body is bounded by the agent’s timeout (agent.with_tool_timeout, 60 s by default) or with_timeout.

Binds a typed handler that also receives its invocation’s Settlement (see the module documentation), and whose stopped run waits up to settle_within for that settlement before recording an uncertain effect. settle_within must be at least 1 ms and at most 2^32 - 1 ms, the longest timer the runtime sets (agent.build checks it). The handler’s own result is used when it returns; the settlement matters only once its task was stopped, also by its body timeout. classify is as for bind.

The description the model reads.

An external idempotency key for this logical action. Stable across replay, independent of correlation, with unambiguous part boundaries.

The typed input of action when it calls definition: the policy’s typed match on a tool. Ok(None) when the action calls another tool. A graph node whose operation has the tool’s name (built from the same definition, say) matches too.

Error(detail) when the action names this definition’s tool but its arguments do not decode with this definition’s input codec: the definition the policy matches on is not the one the agent’s tool was bound from (another definition shares its name). The runtime decoded the arguments with the bound tool’s codec before the policy ran, so this happens only when the two drifted apart. Pass it on as the policy’s error, which stops the run: an action the policy cannot read is never allowed by a fall-through.

fn policy(member: Member, action: policy.Action) {
  use reservation <- result.try(tool.input(reserve_definition(), action))
  case reservation {
    Some(Reservation(isbn:)) -> check_reservation(member, isbn)
    None -> Ok(policy.Allow)
  }
}

The codec of the tool’s arguments: its JSON Schema is what the model is told, and it decodes what the model sends. Another runtime that serves the same tool (an MCP server, say) can declare and decode with it.

The name the model calls the tool by.

The codec of the tool’s result, as the model reads it.

The content fabric.reconcile and fabric.reconcile_stored take for an action of definition: the output encoded with the tool’s output codec, as the handler’s result would have been, or for Error(message) the definite failure the model sees ({"error": message}, as for Explain). Use it instead of writing the JSON by hand.

let assert Ok(content) =
  tool.reconciliation(refund_definition, Ok(Refund(id: "r-1")))
fabric.reconcile(handle, uncertain.reference, content)

Settles the invocation’s result: an output, encoded with the tool’s output codec, or a typed failure, Explain (definite) or Uncertain. Blocks until the run has recorded or refused it. A refusal is observed (settlement_refused) with summary: what a person needs to reconcile the action when the run did not record the settlement. The summary goes to telemetry handlers, so it must not carry secrets.

The content fabric.reconcile takes when a person cannot yet say what happened: {"unconfirmed": note}, which tells the model the effect may or may not have happened and why, so it does not report the effect as done or as failed.

An uncertain effect waits for a reconciliation, and the run with it. Leave it unreconciled while the answer is near: the run stays Suspended, and fabric.reconcile with reconciliation later records what happened. Reconcile it as unconfirmed only to let the run go on without the answer: the action then ends Reconciled and leaves the run’s uncertain effects, so the application tracks the open question from there, and a policy that must not repeat the effect refuses a second call itself.

let content =
  tool.unconfirmed_reconciliation("finance is checking with the provider")
fabric.reconcile(handle, uncertain.reference, content)

Whether a tool name fits the model providers’ shared grammar: 1–64 ASCII letters, digits, underscores or hyphens.

Lets the runtime start this tool’s body again, up to max_attempts starts in all, when an attempt ends without a result of its own: its body crashed, ran past its timeout, or its runner was lost (a restart, a lost node). Without it, such an action becomes an uncertain effect that a person reconciles.

Use it only for a tool whose effect is safe to repeat: a read, or a write the handler makes idempotent (keyed by call.run and call.action, which stay the same across attempts). A typed failure the handler returns (Explain, Uncertain) is never replayed, nor is a tool stopped by a cancellation. An approved action that is replayed after a lost runner asks for its approval again, as any approved action does at recovery. agent.build refuses fewer than 1 or more than 100 attempts (InvalidToolLimit); run.ActionRecord.replays counts the replays.

Bounds this tool’s body by timeout instead of the agent’s (agent.with_tool_timeout): run.After(duration), or run.Infinity for a body that may run as long as it needs. A body still running at its timeout is stopped and its action becomes an uncertain effect (it may have acted), unless the tool is replayable (with_replay). agent.build refuses a timeout under 1 ms or over 2^32 - 1 ms (InvalidToolLimit). A sub-agent delegation has no body: its child run’s own limits bound it.