Building
AI Agents

import {
  T3nClient, setEnvironment,
  loadWasmComponent, eth_get_address,
  metamask_sign, createEthAuthInput,
  getNodeUrl, getScriptVersion,
} from "@terminal3/t3n-sdk";

setEnvironment("testnet");

const T3N_API_KEY = process.env.T3N_API_KEY;
const TENANT_SCRIPT = process.env.TENANT_SCRIPT;

if (!T3N_API_KEY)
  throw new Error("Missing T3N_API_KEY");
if (!TENANT_SCRIPT)
  throw new Error("Missing TENANT_SCRIPT");

const wasmComponent = await loadWasmComponent();
const address = eth_get_address(T3N_API_KEY);

const userClient = new T3nClient({
  wasmComponent,
  handlers: {
    EthSign: metamask_sign(
      address, undefined, T3N_API_KEY),
  },
});

await userClient.handshake();
const did = await userClient.authenticate(
  createEthAuthInput(address));
const userDid = did.value;

// Beginner mode: user and agent
// are the same DID.
const agentDid = userDid;

const userContractVersion =
  await getScriptVersion(
    getNodeUrl(), "tee:user/contracts");
const scriptVersion =
  await getScriptVersion(
    getNodeUrl(), TENANT_SCRIPT);

console.log("Authorizing agent...");
await userClient.execute({
  script_name: "tee:user/contracts",
  script_version: userContractVersion,
  function_name: "agent-auth-update",
  input: {
    agents: [
      {
        agentDid,
        scripts: [
          {
            scriptName: TENANT_SCRIPT,
            versionReq: scriptVersion,
            functions: [
              "search-offers",
              "book-offer",
            ],
            allowedHosts: ["api.duffel.com"],
          },
        ],
      },
    ],
  },
});

console.log("Authorized agent:", agentDid);
console.log("For contract:", TENANT_SCRIPT);

import { createInterface } from "readline/promises";
import { stdin as input, stdout as output }
  from "process";
import {
  T3nClient, setEnvironment,
  loadWasmComponent, eth_get_address,
  metamask_sign, createEthAuthInput,
} from "@terminal3/t3n-sdk";

setEnvironment("testnet");

const T3N_API_KEY = process.env.T3N_API_KEY;
if (!T3N_API_KEY)
  throw new Error("Missing T3N_API_KEY");

const rl = createInterface({ input, output });

const email =
  await rl.question("Email for OTP: ");
const firstName =
  await rl.question("First name: ");
const lastName =
  await rl.question("Last name: ");
const dateOfBirth =
  await rl.question("DOB YYYY-MM-DD: ");
const gender =
  await rl.question("Gender m/f: ");

const wasmComponent = await loadWasmComponent();
const address = eth_get_address(T3N_API_KEY);

const client = new T3nClient({
  wasmComponent,
  handlers: {
    EthSign: metamask_sign(
      address, undefined, T3N_API_KEY),
  },
});

await client.handshake();
const did = await client.authenticate(
  createEthAuthInput(address));
console.log("Authenticated DID:", did.value);

await client.runOtpThenUserInput({
  channel: "email",
  emailAddress: email,
  profile: {
    first_name: firstName,
    last_name: lastName,
    date_of_birth: dateOfBirth,
    gender,
    email_address: email,
  },
  getOtpCode: async () =>
    await rl.question("Enter OTP code: "),
});

rl.close();
console.log("Profile updated.");

import {
  T3nClient,
  setEnvironment,
  loadWasmComponent,
  eth_get_address,
  metamask_sign,
  createEthAuthInput,
  getNodeUrl,
  getScriptVersion,
} from "@terminal3/t3n-sdk";
import { stdin as input, stdout as output } from "node:process";
import { createInterface } from "node:readline/promises";

setEnvironment("testnet");

const AGENT_KEY = process.env.AGENT_KEY || process.env.T3N_API_KEY;
const TENANT_SCRIPT = process.env.TENANT_SCRIPT;

if (!AGENT_KEY) throw new Error("Missing AGENT_KEY");
if (!TENANT_SCRIPT) throw new Error("Missing TENANT_SCRIPT");

const wasmComponent = await loadWasmComponent();
const agentAddress = eth_get_address(AGENT_KEY);

const agentClient = new T3nClient({
  wasmComponent,
  handlers: {
    EthSign: metamask_sign(agentAddress, undefined, AGENT_KEY),
  },
});

await agentClient.handshake();
const did = await agentClient.authenticate(createEthAuthInput(agentAddress));
console.log("Agent DID:", did.value);

const scriptVersion = await getScriptVersion(getNodeUrl(), TENANT_SCRIPT);

console.log("Calling search-offers...");
const search = await agentClient.executeAndDecode({
  script_name: TENANT_SCRIPT,
  script_version: scriptVersion,
  function_name: "search-offers",
  input: {
    origin: "LHR",
    destination: "JFK",
    departure_date: "2026-07-15",
    cabin_class: "economy",
    adult_count: 1,
  },
});

if (!search.offers?.length)
  throw new Error("No offers returned");

console.log("\nAvailable offers:");
console.table(formatOfferRows(search.offers));

const rl = createInterface({ input, output });
let offer;
let shouldBook = false;

try {
  while (!offer) {
    const answer = await rl.question(
      `Select an offer to book (1-${search.offers.length}): `,
    );

    try {
      offer = search.offers[parseOfferSelection(answer, search.offers.length)];
    } catch (error) {
      console.log(error.message);
    }
  }

  console.log("\nSelected offer:");
  console.table([formatSelectedOffer(offer)]);

  const confirmation = await rl.question("Book this offer? (y/N): ");
  shouldBook = parseConfirmation(confirmation);
} finally {
  rl.close();
}

if (!shouldBook) {
  console.log("Booking cancelled.");
  process.exit(0);
}

console.log("Calling book-offer...");
const booking = await agentClient.executeAndDecode({
  script_name: TENANT_SCRIPT,
  script_version: scriptVersion,
  function_name: "book-offer",
  input: {
    offer_id: offer.id,
    passenger_id: offer.passenger_ids[0],
    total_amount: offer.total_amount,
    total_currency: offer.total_currency,
  },
});

console.dir(booking, { depth: null });

function formatOfferRows(offers) {
  return offers.map((offer, index) => ({
    "#": index + 1,
    offer_id: offer.id,
    amount: formatAmount(offer),
    expires_at: offer.expires_at || "n/a",
  }));
}

function formatSelectedOffer(offer) {
  return {
    offer_id: offer.id,
    passenger_id: offer.passenger_ids?.[0] || "n/a",
    amount: formatAmount(offer),
    expires_at: offer.expires_at || "n/a",
  };
}

function parseOfferSelection(input, offerCount) {
  const trimmed = input.trim();
  const selected = Number.parseInt(trimmed, 10);

  if (!/^\d+$/.test(trimmed) || selected < 1 || selected > offerCount) {
    throw new Error(`Choose a number from 1 to ${offerCount}`);
  }

  return selected - 1;
}

function parseConfirmation(input) {
  return ["y", "yes"].includes(input.trim().toLowerCase());
}

function formatAmount(offer) {
  return `${offer.total_amount} ${offer.total_currency}`;
}