Record a hand-off between two agents

npm install @sanning/anchor @sanning/proof

pip install sanning-anchor sanning-proof

// 64 lowercase hex characters: the key the other side addresses.
const publicKey = await anchorer.publicKeyHex();

# 64 lowercase hex characters: the key the other side addresses.
public_key = anchorer.public_key_hex()

import { createHandoff } from "@sanning/anchor";

// `anchorer` is this agent's anchorer. `caseId` groups every message in
// one case, and is committed permanently, so keep it opaque.
const handoff = createHandoff({ anchorer, caseId: "case-5d1e9a" });

const sent = await handoff.send({
  message: {
    task: "credit-assessment",
    recommendation: "approve",
    tier: 2,
  },
  // The receiving agent's Ed25519 public key, 64 hex characters.
  to: RECEIVER_PUBLIC_KEY,
});

// The message bytes, and the evidence that travels beside them.
await transport.send({ body: sent.wireBytes, sanning: sent.attachment });

from sanning_anchor import create_handoff

# `anchorer` is this agent's anchorer. `case_id` groups every message in
# one case, and is committed permanently, so keep it opaque.
handoff = create_handoff(anchorer=anchorer, case_id="case-5d1e9a")

sent = handoff.send(
    message={
        "task": "credit-assessment",
        "recommendation": "approve",
        "tier": 2,
    },
    # The receiving agent's Ed25519 public key, 64 hex characters.
    to=RECEIVER_PUBLIC_KEY,
)

# The message bytes, and the evidence that travels beside them.
transport.send(body=sent.wire_bytes, sanning=sent.attachment)

import { createHandoff } from "@sanning/anchor";

const handoff = createHandoff({ anchorer, caseId: "case-5d1e9a" });

const received = await handoff.receive({
  attachment: arrived.sanning,
  wireBytes: arrived.body,
  outcome: "accepted",
  // Refuse a sender you do not deal with before anything is recorded.
  expectedSender: SENDER_PUBLIC_KEY,
});

// This is the message the sender committed to.
await agent.handle(received.message);

from sanning_anchor import create_handoff

handoff = create_handoff(anchorer=anchorer, case_id="case-5d1e9a")

received = handoff.receive(
    attachment=arrived["sanning"],
    wire_bytes=arrived["body"],
    outcome="accepted",
    # Refuse a sender you do not deal with before anything is recorded.
    expected_sender=SENDER_PUBLIC_KEY,
)

# This is the message the sender committed to.
agent.handle(received.message)

// On the receiving side: send back the record `receive` wrote.
await transport.sendBack({ receivedRecord: received.receivedRecord });

# On the receiving side: send back the record `receive` wrote.
transport.send_back(received_record=received.received_record)

// On the sending side: `handoff` is the same helper `send` used, and
// `backConfirmation` is whatever the receiver sent back above.
const confirmation = await handoff.confirm({
  sent,
  receivedRecord: backConfirmation.receivedRecord,
});

if (!confirmation.confirmed) {
  throw new Error(
    `hand-off not confirmed: ${confirmation.reasons.map((r) => r.detail).join("; ")}`,
  );
}

# On the sending side: `handoff` is the same helper `send` used, and
# `back_confirmation` is whatever the receiver sent back above.
confirmation = handoff.confirm(
    sent=sent,
    received_record=back_confirmation["received_record"],
)

if not confirmation.confirmed:
    reasons = "; ".join(reason.detail for reason in confirmation.reasons)
    raise RuntimeError(f"hand-off not confirmed: {reasons}")

import { filePart } from "@sanning/anchor";

const part = await filePart({ content: pdfBytes, mediaType: "application/pdf" });
// { kind: "file", media_type, content_hash, content_length }

from sanning_anchor import file_part

part = file_part(content=pdf_bytes, media_type="application/pdf")

import { FsRecordBuffer } from "@sanning/anchor";

const anchorer = createAnchorer({
  // Your other options, as in "Anchor from your agent".
  buffer: new FsRecordBuffer("/var/lib/assessor/sanning-buffer"),
});

from sanning_anchor import FsRecordBuffer

anchorer = Anchorer(
    # Your other options, as in "Anchor from your agent".
    buffer=FsRecordBuffer("/var/lib/assessor/sanning-buffer"),
)