Integrate the Commerce SDK into an iMessage agent

import { AgentcardClient, buyTool, type BuyTool } from '@agent-cards/commerce-sdk';

export const agentcard = new AgentcardClient({
  clientId: process.env.AGENTCARD_CLIENT_ID ?? '',
  clientSecret: process.env.AGENTCARD_CLIENT_SECRET ?? '',
});

const tools = new Map<string, BuyTool>();

/** The buy tool for one phone number, kept between texts. */
export function buyFor(phone: string): BuyTool {
  let buy = tools.get(phone);
  if (!buy) {
    buy = buyTool({ agentcard, externalUserId: phone, ack: 'text' });
    tools.set(phone, buy);
  }
  return buy;
}

type Part = { type: 'text'; value: string } | { type: 'media'; url: string };

async function send(to: string, parts: Part[]) {
  const res = await fetch('https://api.linqapp.com/api/partner/v3/chats', {
    method: 'POST',
    headers: { Authorization: `Bearer ${process.env.LINQ_API_KEY}`, 'Content-Type': 'application/json' },
    body: JSON.stringify({ from: process.env.LINQ_PHONE_NUMBER, to: [to], message: { parts } }),
  });
  if (!res.ok) throw new Error(`Linq answered ${res.status}`);
}

export const sendText = (to: string, value: string) => send(to, [{ type: 'text', value }]);
export const sendPhoto = (to: string, url: string) => send(to, [{ type: 'media', url }]);

import Anthropic from '@anthropic-ai/sdk';
import { buyFor } from './agentcard';
import { sendPhoto, sendText } from './linq';

const anthropic = new Anthropic();

export async function onText(phone: string, text: string) {
  const turn = buyFor(phone).turn(text, {
    onItem: async (item) => {
      if (item.kind === 'text') return sendText(phone, item.text);
      const { link } = item;
      if (link.kind === 'product' || link.kind === 'store') {
        if (link.imageUrl) await sendPhoto(phone, link.imageUrl);
        await sendText(phone, [link.title, link.price].filter(Boolean).join(' '));
        if (link.url) await sendText(phone, link.url); // a flight has no page, so it sends no link
        return;
      }
      await sendText(phone, link.url ?? ''); // Vault, approval, or store sign-in: the link alone
    },
  });

  const history = await loadHistory(phone); // your code: the user's earlier messages, kept in Redis
  const runner = anthropic.beta.messages.toolRunner({
    model: 'claude-opus-5-5',
    max_tokens: 16000,
    tools: [turn],
    messages: turn.messages(history),
    stream: true,
  });
  for await (const stream of runner) {
    const paragraphs = turn.messageStream(); // each paragraph goes out as its own text
    stream.on('text', (delta) => paragraphs.push(delta));
    await stream.done();
    await paragraphs.end();
  }
  await saveHistory(phone, runner.params.messages); // your code
}

import { waitUntil } from '@vercel/functions';
import { agentcardWebhook } from '@agent-cards/commerce-sdk';
import { buyFor } from '@/agentcard';
import { sendText } from '@/linq';

const webhook = agentcardWebhook({
  secret: process.env.AGENTCARD_WEBHOOK_SECRET ?? '', // returned once, when you create the endpoint
  onMessage: async (phone, message) => {
    const step = buyFor(phone).nextStep(message);
    if (!step) {
      await sendText(phone, message.text);
      await saveAssistantMessage(phone, message.text); // your code: the model reads it from the history
      return;
    }
    // Agentcard waits 10 seconds for an answer, so run the model after the response goes out.
    waitUntil(
      runNextStep(phone, step).catch(async () => {
        step.release();
        await sendText(phone, message.text);
        await saveAssistantMessage(phone, message.text);
      }),
    );
  },
});

export const POST = webhook.fetch;