Production-Ready Templates

import { openai } from "@ai-sdk/openai";
import { generateText, tool } from "ai";
import { z } from "zod";
import { AttessoClient } from "@attesso/sdk";
import { WebClient } from "@slack/web-api";

const attesso = new AttessoClient({
  apiKey: process.env.ATTESSO_API_KEY!
});
const slack = new WebClient(process.env.SLACK_BOT_TOKEN);

// The AI tool that executes purchases
const purchaseTool = tool({
  description: "Purchase a software license",
  parameters: z.object({
    item: z.string().describe("What to purchase"),
    amount: z.number().describe("Price in cents"),
    vendor: z.string().describe("Vendor name"),
    mandate_id: z.string().describe("Active mandate ID"),
  }),
  execute: async ({ item, amount, vendor, mandate_id }) => {
    // Check mandate has sufficient remaining_limit
    const mandate = await attesso.getMandate(mandate_id);

    if (!mandate || mandate.status !== "active") {
      return {
        success: false,
        error: "No active mandate found."
      };
    }

    if (mandate.remaining_limit < amount) {
      return {
        success: false,
        error: "Insufficient remaining_limit."
      };
    }

    // Issue an ephemeral JIT card
    const card = await attesso.issueCard(mandate_id, {
      amount,
      ttl_seconds: 300,
    });

    return {
      success: true,
      card_id: card.card_id,
      message: `Card issued for ${item}, $${(amount/100).toFixed(2)}`
    };
  },
});

// Handle incoming Slack messages
export async function handleSlackMessage(event: SlackEvent) {
  const { text, user, channel } = event;

  const result = await generateText({
    model: openai("gpt-4o"),
    tools: { purchase: purchaseTool },
    system: `You are a procurement assistant. Help
employees purchase software and tools.`,
    prompt: text,
  });

  await slack.chat.postMessage({
    channel,
    text: result.text,
  });
}

import { AttessoClient } from "@attesso/sdk";

const attesso = new AttessoClient({
  apiKey: process.env.ATTESSO_API_KEY!
});

interface SubscriptionConfig {
  service: string;
  amount: number;       // Monthly charge in cents
  external_user_id: string;
}

// Request mandate for a recurring subscription
export async function requestSubscription(
  config: SubscriptionConfig
) {
  // Create mandate request. Default fee mode is markup.
  const request = await attesso.createMandateRequest({
    amount: config.amount,
    external_user_id: config.external_user_id,
    validity_window: "30d",
    category: `subscription:${config.service}`,
    metadata: {
      service: config.service,
      type: "subscription",
    },
  });

  // Send approval_url to user
  return {
    request_id: request.id,
    approval_url: request.approval_url,
    spending_limit: request.spending_limit,
  };
}

// After user approves, issue card for this billing cycle
export async function chargeSubscription(
  mandate_id: string,
  amount: number,
) {
  const card = await attesso.issueCard(mandate_id, {
    amount,
    ttl_seconds: 300,
  });

  return {
    card_id: card.card_id,
    number: card.number,
    exp_month: card.exp_month,
    exp_year: card.exp_year,
    cvc: card.cvc,
  };
}

// Example: Netflix subscription
const sub = await requestSubscription({
  service: "Netflix",
  amount: 1599,           // $15.99/month
  external_user_id: "user_123",
});

console.log(`Approve at: ${sub.approval_url}`);

// After approval, charge each month:
// const card = await chargeSubscription(mandate_id, 1599);
// Use card at Netflix checkout

// Cancel anytime. Revoke the mandate.
export async function cancelSubscription(mandate_id: string) {
  await attesso.revokeMandate(mandate_id);
  // No further cards can be issued
}