Marketplace Payout

npm install @codespar/sdk @codespar/claude @anthropic-ai/sdk

import Anthropic from "@anthropic-ai/sdk";
import { CodeSpar } from "@codespar/sdk";
import { getTools, handleToolUse, toToolResultBlock } from "@codespar/claude";

const claude = new Anthropic();
const codespar = new CodeSpar({ apiKey: process.env.CODESPAR_API_KEY });

interface Order {
  order_id: string;
  buyer: { email: string; card_token: string };
  seller: { id: string; bank_pix_key: string; cnpj: string };
  gross_amount: number; // centavos, e.g. 100000 = R$1,000
  platform_fee_bps: number; // basis points, e.g. 1500 = 15%
}

async function marketplacePayout(order: Order) {
  const session = await codespar.create(order.seller.id, {
    servers: ["stripe", "stark-bank", "nuvem-fiscal"],
    metadata: {
      order_id: order.order_id,
      marketplace_flow: "payout_v1",
    },
  });

  try {
    const tools = await getTools(session);
    const platformFee = Math.round(order.gross_amount * order.platform_fee_bps / 10000);
    const payoutAmount = order.gross_amount - platformFee;

    const messages: Anthropic.MessageParam[] = [
      {
        role: "user",
        content: `
Execute a marketplace order settlement:

1. Charge R$${(order.gross_amount / 100).toFixed(2)} on the buyer card (token: ${order.buyer.card_token}) via Stripe.
2. Once the charge settles, pay out R$${(payoutAmount / 100).toFixed(2)} via Pix to the seller key ${order.seller.bank_pix_key} via Stark Bank.
3. Issue an NF-e for the platform fee R$${(platformFee / 100).toFixed(2)} to seller CNPJ ${order.seller.cnpj} via the fiscal provider.
4. Return the charge_id, payout_id, and nfe_access_key.

Stop immediately if the charge fails — do not attempt payout or invoice.
        `,
      },
    ];

    let response = await claude.messages.create({
      model: "claude-opus-4-6",
      max_tokens: 4096,
      tools,
      messages,
    });

    let iterations = 0;
    while (response.stop_reason === "tool_use" && iterations < 10) {
      const blocks = response.content.filter(
        (b): b is Anthropic.ToolUseBlock => b.type === "tool_use",
      );
      const results = await Promise.all(
        blocks.map(async (block) => {
          const out = await handleToolUse(session, block);
          return toToolResultBlock(block.id, out);
        }),
      );
      messages.push({ role: "assistant", content: response.content });
      messages.push({ role: "user", content: results });
      response = await claude.messages.create({
        model: "claude-opus-4-6",
        max_tokens: 4096,
        tools,
        messages,
      });
      iterations++;
    }

    const final = response.content.find(
      (b): b is Anthropic.TextBlock => b.type === "text",
    );
    return final?.text ?? "";
  } finally {
    await session.close();
  }
}

import { CodeSpar } from "@codespar/sdk";
const cs = new CodeSpar({ apiKey: process.env.CODESPAR_API_KEY });
const session = await cs.create("user_123", { servers: ["asaas"] });
// ---cut---
declare const order: {
  gross_amount: number;
  buyer: { card_token: string };
  seller: { bank_pix_key: string; cnpj: string };
};
declare const platformFee: number;
// ---cut---
import { loop } from "@codespar/sdk";

const result = await loop(session, {
  steps: [
    {
      tool: "codespar_pay",
      params: { method: "card", amount: order.gross_amount, card_token: order.buyer.card_token },
    },
    {
      tool: "codespar_pay",
      params: (prev) => ({
        action: "payout",
        method: "pix",
        amount: order.gross_amount - platformFee,
        pix_key: order.seller.bank_pix_key,
        source_payment_id: (prev[0].data as { payment_id: string }).payment_id,
      }),
    },
    {
      tool: "codespar_invoice",
      params: (prev) => ({
        type: "nfe",
        amount: platformFee,
        customer: { cnpj: order.seller.cnpj },
        reference: (prev[0].data as { payment_id: string }).payment_id,
      }),
    },
  ],
  abortOnError: true, // stop if the charge fails
});

steps: [
  { tool: "codespar_pay", params: { method: "card", amount: order.gross } },
  ...order.sellers.map((seller) => ({
    tool: "codespar_pay",
    params: { action: "payout", method: "pix", amount: seller.share, pix_key: seller.pix },
  })),
]